source: trunk/Lucide/SOURCE/gui/lucide.cpp @ 212

Last change on this file since 212 was 212, checked in by Eugene Romanenko, 14 years ago

Zoom in/Zoom out menuitems and corresponding Ctrl++/Ctrl+- hotkeys. Ctrl+Shift++/Ctrl+Shift+- hotkeys for rotate CW/CCW, Ctrl+P for Print (closes #108)

File size: 40.5 KB
Line 
1/* ***** BEGIN LICENSE BLOCK *****
2 * Version: CDDL 1.0/LGPL 2.1
3 *
4 * The contents of this file are subject to the COMMON DEVELOPMENT AND
5 * DISTRIBUTION LICENSE (CDDL) Version 1.0 (the "License"); you may not use
6 * this file except in compliance with the License. You may obtain a copy of
7 * the License at http://www.sun.com/cddl/
8 *
9 * Software distributed under the License is distributed on an "AS IS" basis,
10 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11 * for the specific language governing rights and limitations under the
12 * License.
13 *
14 * The Initial Developer of the Original Code is
15 * Eugene Romanenko, netlabs.org.
16 * Portions created by the Initial Developer are Copyright (C) 2006
17 * the Initial Developer. All Rights Reserved.
18 *
19 * Contributor(s):
20 *
21 * Alternatively, the contents of this file may be used under the terms of
22 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
23 * in which case the provisions of the LGPL are applicable instead of those
24 * above. If you wish to allow use of your version of this file only under the
25 * terms of the LGPL, and not to allow others to use your version of this file
26 * under the terms of the CDDL, indicate your decision by deleting the
27 * provisions above and replace them with the notice and other provisions
28 * required by the LGPL. If you do not delete the provisions above, a recipient
29 * may use your version of this file under the terms of any one of the CDDL
30 * or the LGPL.
31 *
32 * ***** END LICENSE BLOCK ***** */
33
34
35#define INCL_WIN
36#define INCL_DOS
37#define INCL_SPL
38#define INCL_SPLDOSPRINT
39#define INCL_DEV
40#include <os2.h>
41
42#include <string>
43#include <stdio.h>
44#include <process.h>
45
46#include <ludoc.xh>
47
48#include "Lucide.h"
49#include "pluginman.h"
50#include "pluginViewDlg.h"
51#include "fontsInfoDlg.h"
52#include "docInfoDlg.h"
53#include "findDlg.h"
54#include "printDlg.h"
55#include "progressDlg.h"
56#include "settingsDlg.h"
57#include "passwordDlg.h"
58#include "docViewer.h"
59#include "indexWindow.h"
60#include "lusettings.h"
61#include "luutils.h"
62#include "tb_spl.h"
63#include "Lucide_res.h"
64#include "messages.h"
65
66
67#define ID_SPLITTER 1
68
69const char *appName    = "Lucide";
70const char *appVersion = VERSION;
71const char *fwp        = "FrameWindowPos";
72const char *lvd        = "LastViewedDir";
73const char *splpos     = "SplitterPos";
74const char *showind    = "ShowIndex";
75
76HWND createToolbar( HWND hwnd );
77void AboutBox( HWND hWndFrame );
78void initPipeMon( HWND hWndFrame );
79void unInitPipeMon();
80
81HAB   hab            = NULLHANDLE;
82HWND  hWndFrame      = NULLHANDLE;
83HWND  hWndMenu       = NULLHANDLE;
84HWND  hToolBar       = NULLHANDLE;
85HWND  hVertSplitter  = NULLHANDLE;
86HWND  hFrameSysmenu  = NULLHANDLE;
87HWND  hFrameTitlebar = NULLHANDLE;
88HWND  hFrameMinMax   = NULLHANDLE;
89
90Environment    *ev        = somGetGlobalEnvironment();
91LuDocument     *doc       = NULL;
92PluginManager  *pluginMan = NULL;
93DocumentViewer *docViewer = NULL;
94IndexWindow    *indexWin  = NULL;
95FindDlg        *findDlg   = NULL;
96LuSettings     *settings  = NULL;
97char           *title     = NULL;
98
99
100bool         Lucide::dontSwitchPage                = false;
101SHORT        Lucide::splitterPos                   = 100;
102bool         Lucide::showIndex                     = true;
103bool         Lucide::isMaxview                     = false;
104bool         Lucide::isFullscreen                  = false;
105LuWindowPos  Lucide::winPos                        = {0};
106char         Lucide::docFullName[ CCHMAXPATH ]     = "";
107char         Lucide::docFileName[ CCHMAXPATHCOMP ] = "";
108char        *Lucide::password                      = NULL;
109ActiveWindow Lucide::activeWindow                  = AwView;
110// static data for asynch loading document
111ProgressDlg *Lucide::loadProgressDlg               = NULL;
112bool         Lucide::docLoaded                     = false;;
113char        *Lucide::loadError                     = NULL;
114long         Lucide::loadErrorCode                 = LU_LDERR_NO_ERROR;
115void        *Lucide::thumbnailData                 = NULL;
116int          Lucide::thumbnailDataLen              = 0;
117
118
119HMODULE _hmod = NULLHANDLE;
120
121unsigned APIENTRY LibMain( unsigned hmod, unsigned termination )
122{
123    if ( termination ) {
124        // DLL is detaching from process
125    } else {
126        // DLL is attaching to process
127        _hmod = hmod;
128    }
129    return( 1 );
130}
131
132
133PFNWP pOldSplProc;
134
135void Lucide::enableCopy( bool enable )
136{
137    WinEnableMenuItem( hWndMenu, CM_COPY, enable );
138}
139
140void Lucide::setOfPages( long pages )
141{
142    char *pgfrm = newstrdupL( TB_PAGENUM );
143    char pgnum[ 32 ];
144    snprintf( pgnum, sizeof( pgnum ), pgfrm, pages );
145    delete pgfrm;
146    WinSetDlgItemText( hToolBar, TBID_OFPAGES, pgnum );
147    WinSendDlgItemMsg( hToolBar, TBID_PAGENUM, SPBM_SETLIMITS,
148                       MPFROMLONG( pages ), MPFROMLONG( 1 ) );
149}
150
151void Lucide::checkNavigationMenus()
152{
153    WinEnableMenuItem( hWndMenu, CM_GOTOPAGE, TRUE );
154    BOOL enfirst = ( docViewer->getCurrentPage() != 0 );
155    BOOL enlast = ( docViewer->getCurrentPage() != ( doc->getPageCount( ev ) - 1 ) );
156    WinEnableMenuItem( hWndMenu, CM_FIRSTPAGE, enfirst );
157    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIRSTPAGE), (MPARAM)enfirst );
158    WinEnableMenuItem( hWndMenu, CM_PREVPAGE, enfirst );
159    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PREVPAGE), (MPARAM)enfirst );
160    WinEnableMenuItem( hWndMenu, CM_NEXTPAGE, enlast );
161    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_NEXTPAGE), (MPARAM)enlast );
162    WinEnableMenuItem( hWndMenu, CM_LASTPAGE, enlast );
163    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_LASTPAGE), (MPARAM)enlast );
164
165    bool tmp = dontSwitchPage;
166    dontSwitchPage = true;
167    WinSendDlgItemMsg( hToolBar, TBID_PAGENUM, SPBM_SETCURRENTVALUE,
168                       MPFROMLONG( docViewer->getCurrentPage() + 1 ), MPVOID );
169    dontSwitchPage = tmp;
170    indexWin->goToPage( NULL, docViewer->getCurrentPage() );
171}
172
173void Lucide::enableZoomMenus()
174{
175    BOOL scalable = doc->isScalable( ev );
176    WinEnableMenuItem( hWndMenu, CM_FITWINDOW, scalable );
177    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWINDOW), (MPARAM)scalable );
178    WinEnableMenuItem( hWndMenu, CM_ACTSIZE, scalable );
179    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ACTSIZE), (MPARAM)scalable );
180    WinEnableMenuItem( hWndMenu, CM_FITWIDTH, scalable );
181    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWIDTH), (MPARAM)scalable );
182    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ZOOM_IN_OUT), (MPARAM)scalable );
183    WinEnableMenuItem( hWndMenu, CM_ZOOM_IN, scalable );
184    WinEnableMenuItem( hWndMenu, CM_ZOOM_OUT, scalable );
185    WinEnableControl( hToolBar, TBID_ZOOM, scalable );
186    BOOL rotable = doc->isRotable( ev );
187    WinEnableMenuItem( hWndMenu, CM_ROTATE90CW, rotable );
188    WinEnableMenuItem( hWndMenu, CM_ROTATE90CCW, rotable );
189}
190
191
192void Lucide::setZoomChecks( SHORT cmd, SHORT cbind, double zoom )
193{
194    if ( cmd != -1 )
195    {
196        WinCheckMenuItem( hWndMenu, cmd, TRUE );
197        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( cmd ), (MPARAM)TRUE );
198    }
199
200    if ( cbind != -1 )
201    {
202        char buf[ 255 ] = "";
203        WinSendDlgItemMsg( hToolBar, TBID_ZOOM, LM_QUERYITEMTEXT,
204                           MPFROM2SHORT( cbind, sizeof( buf ) ), MPFROMP( buf ) );
205        WinSetDlgItemText( hToolBar, TBID_ZOOM, buf );
206    }
207
208    if ( zoom != 0 )
209    {
210        std::string z = str( zoom * 100.0 ) + "%";
211        WinSetDlgItemText( hToolBar, TBID_ZOOM, z.c_str() );
212    }
213}
214
215void Lucide::checkZoomMenus()
216{
217    double zoom = docViewer->getZoom();
218
219    WinCheckMenuItem( hWndMenu, CM_FITWINDOW, FALSE );
220    WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT(CM_FITWINDOW), (MPARAM)FALSE );
221    WinCheckMenuItem( hWndMenu, CM_ACTSIZE, FALSE );
222    WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT(CM_ACTSIZE), (MPARAM)FALSE );
223    WinCheckMenuItem( hWndMenu, CM_FITWIDTH, FALSE );
224    WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT(CM_FITWIDTH), (MPARAM)FALSE );
225
226    if ( zoom == -2 ) {
227        setZoomChecks( CM_FITWINDOW, 1, 0 );
228    } else if ( zoom == -1 ) {
229        setZoomChecks( CM_FITWIDTH, 2, 0 );
230    } else if ( zoom == 1 ) {
231        setZoomChecks( CM_ACTSIZE, 0, 0 );
232    } else {
233        setZoomChecks( -1, -1, zoom );
234    }
235}
236
237void Lucide::checkMenus()
238{
239    // pre-set "Actual size"
240    setZoomChecks( CM_ACTSIZE, 0, 0 );
241
242    if ( doc == NULL )
243    {
244        // "single page" mode by default
245        WinCheckMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
246
247        WinEnableMenuItem( hWndMenu, CM_SAVEAS, FALSE );
248        WinEnableMenuItem( hWndMenu, CM_PRINT, FALSE );
249        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PRINT), (MPARAM)FALSE );
250        WinEnableMenuItem( hWndMenu, CM_DOCINFO, FALSE );
251        WinEnableMenuItem( hWndMenu, CM_FONTSINFO, FALSE );
252
253        WinEnableMenuItem( hWndMenu, CM_COPY, FALSE );
254        WinEnableMenuItem( hWndMenu, CM_SELECTALL, FALSE );
255        WinEnableMenuItem( hWndMenu, CM_FIND, FALSE );
256        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIND), (MPARAM)FALSE );
257        WinEnableMenuItem( hWndMenu, CM_FINDAGAIN, FALSE );
258        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FINDAGAIN), (MPARAM)FALSE );
259
260        WinEnableMenuItem( hWndMenu, CM_FIRSTPAGE, FALSE );
261        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIRSTPAGE), (MPARAM)FALSE );
262        WinEnableMenuItem( hWndMenu, CM_PREVPAGE, FALSE );
263        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PREVPAGE), (MPARAM)FALSE );
264        WinEnableMenuItem( hWndMenu, CM_NEXTPAGE, FALSE );
265        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_NEXTPAGE), (MPARAM)FALSE );
266        WinEnableMenuItem( hWndMenu, CM_LASTPAGE, FALSE );
267        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_LASTPAGE), (MPARAM)FALSE );
268        WinEnableMenuItem( hWndMenu, CM_GOTOPAGE, FALSE );
269
270        WinEnableMenuItem( hWndMenu, CM_FITWINDOW, FALSE );
271        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWINDOW), (MPARAM)FALSE );
272        WinEnableMenuItem( hWndMenu, CM_ACTSIZE, FALSE );
273        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ACTSIZE), (MPARAM)FALSE );
274        WinEnableMenuItem( hWndMenu, CM_FITWIDTH, FALSE );
275        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWIDTH), (MPARAM)FALSE );
276        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ZOOM_IN_OUT), (MPARAM)FALSE );
277        WinEnableMenuItem( hWndMenu, CM_ZOOM_IN, FALSE );
278        WinEnableMenuItem( hWndMenu, CM_ZOOM_OUT, FALSE );
279        WinEnableControl( hToolBar, TBID_ZOOM, FALSE );
280
281        WinEnableMenuItem( hWndMenu, CM_ROTATE90CW, FALSE );
282        WinEnableMenuItem( hWndMenu, CM_ROTATE90CCW, FALSE );
283        WinEnableMenuItem( hWndMenu, CM_SINGLEPAGE, FALSE );
284        WinEnableMenuItem( hWndMenu, CM_CONTINUOUS, FALSE );
285
286        setOfPages( 0 );
287        return;
288    }
289
290
291    checkNavigationMenus();
292    enableZoomMenus();
293    checkZoomMenus();
294
295    WinEnableMenuItem( hWndMenu, CM_PRINT, TRUE );
296    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PRINT), (MPARAM)TRUE );
297    WinEnableMenuItem( hWndMenu, CM_SAVEAS, doc->isSaveable( ev ) );
298    setOfPages( doc->getPageCount( ev ) );
299    WinEnableMenuItem( hWndMenu, CM_FONTSINFO, doc->isHaveFontInfo( ev ) );
300    WinEnableMenuItem( hWndMenu, CM_DOCINFO, TRUE );
301
302    BOOL haveText = doc->isHaveText( ev );
303    WinEnableMenuItem( hWndMenu, CM_FIND, haveText );
304    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIND), (MPARAM)haveText );
305    WinEnableMenuItem( hWndMenu, CM_SELECTALL, haveText );
306
307    WinEnableMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
308    WinEnableMenuItem( hWndMenu, CM_CONTINUOUS, TRUE );
309}
310
311void Lucide::goToPage( long page )
312{
313    if ( docViewer != NULL ) {
314        docViewer->goToPage( page );
315    }
316}
317
318void Lucide::setZoom( double zoom )
319{
320    if ( docViewer != NULL ) {
321        docViewer->setZoom( zoom );
322        checkZoomMenus();
323    }
324}
325
326void Lucide::setDocument( LuDocument *_doc )
327{
328    docViewer->setDocument( _doc );
329    indexWin->setDocument( _doc );
330    checkMenus();
331}
332
333void Lucide::setPageLayout( PgLayout layout )
334{
335    if ( layout == SinglePage ) {
336        WinCheckMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
337        WinCheckMenuItem( hWndMenu, CM_CONTINUOUS, FALSE );
338    }
339    else {
340        WinCheckMenuItem( hWndMenu, CM_SINGLEPAGE, FALSE );
341        WinCheckMenuItem( hWndMenu, CM_CONTINUOUS, TRUE );
342    }
343
344    docViewer->setPageLayout( layout );
345}
346
347
348void Lucide::closeDocument()
349{
350    docViewer->close();
351    delete doc;
352    doc = NULL;
353    WinSetWindowText( hWndFrame, title );
354
355    if ( thumbnailData != NULL ) {
356        writeThumbnail( docFullName );
357        delete thumbnailData;
358        thumbnailData = NULL;
359        thumbnailDataLen = 0;
360    }
361}
362
363void Lucide::loadthread( void* )
364{
365    HAB thab = WinInitialize( 0 );
366    HMQ thmq = WinCreateMsgQueue( thab, 0 );
367
368    docLoaded = doc->loadFile( ev, docFullName, password, &loadErrorCode, &loadError );
369    if ( docLoaded ) {
370        if ( doc->isCreateFileThumbnail( ev ) && isThumbNeeded( docFullName ) ) {
371            loadProgressDlg->setText( getLocalizedString( MSGS_CREATING_THUMBNAIL ).c_str() );
372            createThumbnail( doc );
373        }
374    }
375    loadProgressDlg->hide();
376
377    WinDestroyMsgQueue( thmq );
378    WinTerminate( thab );
379    _endthread();
380}
381
382void Lucide::loadDocument( const char *fn )
383{
384    char *msg = newstrdupL( MSGS_NO_SUIT_PLUG );
385
386    // find extension
387    char *ext = strrchr( fn, '.' );
388    if ( ext == NULL )
389    {
390        WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
391                       NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
392    }
393    else
394    {
395        // test if extension supported and then close previous opened document
396        if ( pluginMan->createDocumentForExt( ext + 1, true ) == NULL )
397        {
398            WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
399                           NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
400        }
401        else
402        {
403            closeDocument();
404
405            doc = pluginMan->createDocumentForExt( ext + 1, false );
406            if ( doc == NULL )
407            {
408                WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
409                               NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
410            }
411            else
412            {
413                strcpy( docFullName, fn );
414                if ( password != NULL ) {
415                    delete password;
416                    password = NULL;
417                }
418                bool once = true;
419                while ( once || ( password != NULL ) )
420                {
421                    once = false;
422                    docLoaded = false;
423                    loadError = NULL;
424
425                    // Load document asynchronously
426                    loadProgressDlg = new ProgressDlg( hWndFrame );
427                    char *ldmsg = newstrdupL( MSGS_LOADING_DOCUMENT );
428                    loadProgressDlg->setText( ldmsg );
429                    delete ldmsg;
430                    loadProgressDlg->show( loadthread, NULL ); // doc will be loaded
431                    delete loadProgressDlg;
432
433                    if ( password != NULL ) {
434                        delete password;
435                        password = NULL;
436                    }
437
438                    if ( docLoaded )
439                    {
440                        char *t = new char[ 2048 ];
441                        char _fn[ _MAX_FNAME ];
442                        char _ex[ _MAX_EXT ];
443                        _splitpath( fn, NULL, NULL, _fn, _ex );
444                        strcpy( docFileName, _fn );
445                        strcat( docFileName, _ex );
446                        snprintf( t, 2048, "%s - %s", docFileName, title );
447                        WinSetWindowText( hWndFrame, t );
448                        delete t;
449                        setDocument( doc );
450                    }
451                    else
452                    {
453                        if ( loadErrorCode == LU_LDERR_NO_ERROR )
454                        {
455                            char *m = newstrdupL( MSGS_FILE_LOAD_ERROR );
456                            WinMessageBox( HWND_DESKTOP, hWndFrame, m,
457                                           NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
458                            delete m;
459                        }
460                        else
461                        {
462                            std::string msgTempl = getLocalizedString( MSGS_LDERR );
463
464                            const int errmsgLen = 1024;
465                            char *errmsg = new char[ errmsgLen ];
466                            memset( errmsg, 0, errmsgLen );
467
468                            if ( loadErrorCode == LU_LDERR_CUSTOM )
469                            {
470                                snprintf( errmsg, errmsgLen, msgTempl.c_str(), loadError );
471                                SOMFree( loadError );
472                            }
473                            else
474                            {
475                                const char *lmsg = NULL;
476                                switch ( loadErrorCode )
477                                {
478                                    case LU_LDERR_OUT_OF_MEMORY:
479                                        lmsg = MSGS_LDERR_OUT_OF_MEMORY;
480                                        break;
481                                    case LU_LDERR_OPEN_ERROR:
482                                        lmsg = MSGS_LDERR_OPEN_ERROR;
483                                        break;
484                                    case LU_LDERR_READ_ERROR:
485                                        lmsg = MSGS_LDERR_READ_ERROR;
486                                        break;
487                                    case LU_LDERR_DAMAGED:
488                                        lmsg = MSGS_LDERR_DAMAGED;
489                                        break;
490                                    case LU_LDERR_WRONG_FORMAT:
491                                        lmsg = MSGS_LDERR_WRONG_FORMAT;
492                                        break;
493                                    case LU_LDERR_ENCRYPTED:
494                                        {
495                                            lmsg = MSGS_LDERR_ENCRYPTED;
496
497                                            PasswordDlg *pd = new PasswordDlg( hWndFrame );
498                                            if ( pd->showDialog() == DID_OK ) {
499                                                password = newstrdup( pd->getPassword() );
500                                            }
501                                            delete pd;
502                                        }
503                                        break;
504                                }
505
506                                if ( lmsg != NULL ) {
507                                    snprintf( errmsg, errmsgLen, msgTempl.c_str(),
508                                              getLocalizedString( lmsg ).c_str() );
509                                }
510                            }
511
512                            if ( password == NULL )
513                            {
514                                WinMessageBox( HWND_DESKTOP, hWndFrame, errmsg, NULL, 0,
515                                               MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
516                            }
517                            delete errmsg;
518                        } // ( loadErrorCode == LU_LDERR_NO_ERROR )
519
520                        if ( password == NULL ) {
521                            delete doc;
522                            doc = NULL;
523                        }
524                    } // ( docLoaded )
525                } // while ( once || ( password != NULL ) )
526            } // ( doc == NULL )
527        } // ( pluginMan->createDocumentForExt( ext + 1, true ) == NULL )
528    } // ( ext == NULL )
529    delete msg;
530}
531
532void Lucide::openDocument()
533{
534    char dirbuf[ CCHMAXPATH ];
535    PFILEDLG fd = new FILEDLG;
536    memset( fd, 0, sizeof( FILEDLG ) );
537    fd->cbSize = sizeof( FILEDLG );
538    fd->fl = FDS_CENTER | FDS_OPEN_DIALOG;
539    PrfQueryProfileString( HINI_USERPROFILE, appName, lvd, "",
540                           dirbuf, sizeof( dirbuf ) );
541    snprintf( fd->szFullFile, sizeof( fd->szFullFile ),
542              "%s%s", dirbuf, pluginMan->getExtsMask().c_str() );
543    WinFileDlg( HWND_DESKTOP, hWndFrame, fd );
544    if ( fd->lReturn == DID_OK )
545    {
546        char drv[ _MAX_DRIVE ] = "";
547        char dir[ _MAX_PATH ] = "";
548        char buf[ _MAX_PATH ] = "";
549        _splitpath( fd->szFullFile, drv, dir, NULL, NULL );
550        _makepath( buf, drv, dir, NULL, NULL );
551        PrfWriteProfileString( HINI_USERPROFILE, appName, lvd, buf );
552
553        loadDocument( fd->szFullFile );
554    }
555    delete fd;
556}
557
558void Lucide::saveDocumentAs()
559{
560    char dirbuf[ CCHMAXPATH ];
561    PFILEDLG fd = new FILEDLG;
562    memset( fd, 0, sizeof( FILEDLG ) );
563    fd->cbSize = sizeof( FILEDLG );
564    fd->fl = FDS_CENTER | FDS_SAVEAS_DIALOG;
565    PrfQueryProfileString( HINI_USERPROFILE, appName, lvd, "",
566                           dirbuf, sizeof( dirbuf ) );
567    char fil[ _MAX_FNAME ] = "";
568    char ext[ _MAX_EXT ] = "";
569    _splitpath( docFullName, NULL, NULL, fil, ext );
570    snprintf( fd->szFullFile, sizeof( fd->szFullFile ),
571                "%s%s%s", dirbuf, fil, ext );
572    WinFileDlg( HWND_DESKTOP, hWndFrame, fd );
573    if ( fd->lReturn == DID_OK )
574    {
575        bool doSave = true;
576        if ( access( fd->szFullFile, F_OK ) == 0 )
577        {
578            char *t = newstrdupL( MSGS_WARNING );
579            char *m = newstrdupL( MSGS_OVERWRITE_FILE );
580            ULONG response = WinMessageBox( HWND_DESKTOP, hWndFrame, m, t,
581                                            0, MB_YESNO | MB_WARNING | MB_MOVEABLE );
582            delete m;
583            delete t;
584
585            doSave = ( response == MBID_YES );
586        }
587        if ( doSave )
588        {
589            if ( !doc->saveAs( ev, fd->szFullFile ) )
590            {
591                char *m = newstrdupL( MSGS_FILE_SAVE_ERROR );
592                WinMessageBox( HWND_DESKTOP, hWndFrame, m, NULL,
593                               0, MB_OK | MB_ERROR | MB_MOVEABLE );
594                delete m;
595            }
596        }
597    }
598    delete fd;
599}
600
601void Lucide::checkNavpane()
602{
603    if ( Lucide::showIndex ) {
604        WinCheckMenuItem( hWndMenu, CM_NAVPANE, TRUE );
605        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( CM_NAVPANE ), (MPARAM)TRUE );
606    }
607    else {
608        WinCheckMenuItem( hWndMenu, CM_NAVPANE, FALSE );
609        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( CM_NAVPANE ), (MPARAM)FALSE );
610    }
611}
612
613
614void Lucide::toggleMaxview()
615{
616    ULONG ulFrameStyle = WinQueryWindowULong( hWndFrame, QWL_STYLE );
617
618    if ( isMaxview )
619    {
620        WinSetParent( hFrameSysmenu,  hWndFrame, FALSE );
621        WinSetParent( hFrameTitlebar, hWndFrame, FALSE );
622        WinSetParent( hFrameMinMax,   hWndFrame, FALSE );
623        ulFrameStyle |= FS_SIZEBORDER;
624    }
625    else
626    {
627        WinQueryWindowPos( hWndFrame, &winPos.Swp );
628        winPos.XRestore  = WinQueryWindowUShort( hWndFrame, QWS_XRESTORE );
629        winPos.YRestore  = WinQueryWindowUShort( hWndFrame, QWS_YRESTORE );
630        winPos.CXRestore = WinQueryWindowUShort( hWndFrame, QWS_CXRESTORE );
631        winPos.CYRestore = WinQueryWindowUShort( hWndFrame, QWS_CYRESTORE );
632        winPos.XMinimize = WinQueryWindowUShort( hWndFrame, QWS_XMINIMIZE );
633        winPos.YMinimize = WinQueryWindowUShort( hWndFrame, QWS_YMINIMIZE );
634
635        WinSetParent( hFrameSysmenu,  HWND_OBJECT, FALSE );
636        WinSetParent( hFrameTitlebar, HWND_OBJECT, FALSE );
637        WinSetParent( hFrameMinMax,   HWND_OBJECT, FALSE );
638        ulFrameStyle &= ~FS_SIZEBORDER;
639    }
640
641    WinSetWindowULong( hWndFrame, QWL_STYLE, ulFrameStyle );
642    WinSendMsg( hWndFrame, WM_UPDATEFRAME,
643                MPFROMLONG( FCF_TITLEBAR | FCF_SIZEBORDER | FCF_SYSMENU | FCF_MINMAX ),
644                MPVOID );
645
646    if ( isMaxview )
647    {
648        WinSetWindowUShort( hWndFrame, QWS_XRESTORE,  winPos.XRestore );
649        WinSetWindowUShort( hWndFrame, QWS_YRESTORE,  winPos.YRestore );
650        WinSetWindowUShort( hWndFrame, QWS_CXRESTORE, winPos.CXRestore );
651        WinSetWindowUShort( hWndFrame, QWS_CYRESTORE, winPos.CYRestore );
652        WinSetWindowUShort( hWndFrame, QWS_XMINIMIZE, winPos.XMinimize );
653        WinSetWindowUShort( hWndFrame, QWS_YMINIMIZE, winPos.YMinimize );
654        ULONG swpopt = SWP_MOVE | SWP_SIZE | SWP_SHOW;
655        WinSetWindowPos( hWndFrame, NULLHANDLE,
656                         winPos.Swp.x, winPos.Swp.y, winPos.Swp.cx, winPos.Swp.cy,
657                         swpopt );
658    }
659    else
660    {
661        WinSetWindowPos( hWndFrame, HWND_TOP, 0, 0,
662                         WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ),
663                         WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ),
664                         SWP_SIZE | SWP_MOVE | SWP_ZORDER );
665    }
666
667    isMaxview = !isMaxview;
668}
669
670
671void Lucide::toggleFullscreen()
672{
673    if ( isFullscreen )
674    {
675        docViewer->setFullscreen( false );
676        WinSetParent( docViewer->getFrameHWND(), hWndFrame, TRUE );
677        WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
678                    MPFROMHWND( indexWin->getHWND() ),
679                    MPFROMHWND( docViewer->getFrameHWND() ) );
680    }
681    else
682    {
683        docViewer->setFullscreen( true );
684        WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
685                    MPFROMHWND( indexWin->getHWND() ),
686                    MPFROMHWND( NULLHANDLE ) );
687        WinSetParent( docViewer->getFrameHWND(), HWND_DESKTOP, FALSE );
688        WinSetWindowPos( docViewer->getFrameHWND(), HWND_TOP, 0, 0,
689                         WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ),
690                         WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ),
691                         SWP_SIZE | SWP_MOVE | SWP_ZORDER );
692    }
693
694    isFullscreen = !isFullscreen;
695}
696
697void Lucide::focusDocview()
698{
699    WinSetFocus( HWND_DESKTOP, docViewer->getViewHWND() );
700}
701
702void Lucide::focusIndex()
703{
704    WinSetFocus( HWND_DESKTOP, indexWin->getIndexHWND() );
705}
706
707void Lucide::cmdSwitchWindow()
708{
709    if ( activeWindow == AwIndex ) {
710        focusDocview();
711    } else {
712        focusIndex();
713    }
714}
715
716void Lucide::toggleZoom()
717{
718    if ( ( doc != NULL ) && doc->isScalable( ev ) )
719    {
720        bool isZoom = !docViewer->isZoomMode();
721        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( CM_ZOOM_IN_OUT ), (MPARAM)isZoom );
722        docViewer->setZoomMode( isZoom );
723    }
724}
725
726void Lucide::cmdMinimize()
727{
728    if ( isFullscreen ) {
729        toggleFullscreen();
730    }
731    WinSetWindowPos( hWndFrame, HWND_TOP, 0, 0, 0, 0, SWP_MINIMIZE );
732}
733
734void Lucide::cmdSwitchToFullscreen()
735{
736    if ( !isFullscreen )
737    {
738        SWP pos = {0};
739        WinQueryWindowPos( hWndFrame, &pos );
740
741        if ( pos.fl & SWP_MINIMIZE ) {
742            WinSetWindowPos( hWndFrame, HWND_TOP, 0, 0, 0, 0,
743                    SWP_SHOW | SWP_ACTIVATE | SWP_RESTORE | SWP_ZORDER );
744        }
745        toggleFullscreen();
746    }
747}
748
749void Lucide::newWindow()
750{
751    PROGDETAILS pd;
752    pd.Length                      = sizeof( PROGDETAILS );
753    pd.progt.progc                 = PROG_DEFAULT;
754    pd.progt.fbVisible             = SHE_VISIBLE;
755    pd.pszTitle                    = NULL;
756    pd.pszExecutable               = __argv[0];
757    pd.pszParameters               = NULL;
758    pd.pszStartupDir               = NULL;
759    pd.pszIcon                     = NULL;
760    pd.pszEnvironment              = NULL;
761    pd.swpInitial.fl               = SWP_ACTIVATE;
762    pd.swpInitial.cy               = 0;
763    pd.swpInitial.cx               = 0;
764    pd.swpInitial.y                = 0;
765    pd.swpInitial.x                = 0;
766    pd.swpInitial.hwndInsertBehind = HWND_TOP;
767    pd.swpInitial.hwnd             = NULLHANDLE;
768    pd.swpInitial.ulReserved1      = 0;
769    pd.swpInitial.ulReserved2      = 0;
770
771    WinStartApp( NULLHANDLE, &pd, NULL, NULL, 0 );
772}
773
774static MRESULT EXPENTRY splProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
775{
776    switch ( msg )
777    {
778        case WM_CONTROL:
779        {
780            if ( ( SHORT1FROMMP( mp1 ) == ID_SPLITTER ) &&
781                 ( SHORT2FROMMP( mp1 ) == SBN_POSITIONCHANGED ) )
782            {
783                SHORT pos = SHORT1FROMMP( mp2 );
784                if ( pos > 0 ) {
785                    Lucide::splitterPos = pos;
786                    Lucide::showIndex = true;
787                }
788                else {
789                    Lucide::showIndex = false;
790                }
791                Lucide::checkNavpane();
792            }
793        }
794        break;
795
796        case WM_COMMAND:
797        {
798            switch ( SHORT1FROMMP(mp1) )
799            {
800                case CM_NEW_WINDOW:
801                    Lucide::newWindow();
802                    return (MRESULT)FALSE;
803
804                case CM_OPEN:
805                    Lucide::openDocument();
806                    return (MRESULT)FALSE;
807
808                case CM_SAVEAS:
809                    Lucide::saveDocumentAs();
810                    return (MRESULT)FALSE;
811
812                case CM_PRINT:
813                {
814                    PrintDlg *d = new PrintDlg( hWndFrame, doc, Lucide::docFileName, docViewer->getCurrentPage() + 1 );
815                    if ( d->showDialog() == DID_OK )
816                    {
817                        // print
818                        PrintSetup *p = new PrintSetup;
819                        memset( p, 0, sizeof( PrintSetup ) );
820                        d->getPrintSetup( p );
821                        printDocument( hWndFrame, doc, Lucide::docFileName, p );
822                        delete p;
823                    }
824                    delete d;
825                    return (MRESULT)FALSE;
826                }
827
828                case CM_EXIT:
829                    WinPostMsg( hWndFrame, WM_CLOSE, NULL, NULL );
830                    return (MRESULT)FALSE;
831
832                case CM_DOCINFO:
833                {
834                    LuDocumentInfo *dinfo = doc->getDocumentInfo( ev );
835                    DocInfoDlg *d = new DocInfoDlg( hWndFrame, dinfo );
836                    d->doDialog();
837                    LuDocument::freeDocumentInfo( ev, dinfo );
838                    return (MRESULT)FALSE;
839                }
840
841                case CM_FONTSINFO:
842                {
843                    FontsInfoDlg *d = new FontsInfoDlg( hWndFrame, doc );
844                    d->doDialog();
845                    return (MRESULT)FALSE;
846                }
847
848                case CM_PLUGINSLIST:
849                {
850                    PluginViewDlg *d = new PluginViewDlg( hWndFrame,
851                                                pluginMan->getPluginsList() );
852                    d->doDialog();
853                    return (MRESULT)FALSE;
854                }
855
856                case CM_COPY:
857                    docViewer->copyToClipbrd();
858                    return (MRESULT)FALSE;
859
860                case CM_SELECTALL:
861                    docViewer->selectAll();
862                    return (MRESULT)FALSE;
863
864                case CM_FIND:
865                    if ( findDlg->showDialog() == DID_OK ) {
866                        if ( strlen( findDlg->getSearchString() ) > 0 )
867                        {
868                            docViewer->searchDocument( findDlg->getSearchString(),
869                                            findDlg->isCaseSensitive(), false );
870
871                            WinEnableMenuItem( hWndMenu, CM_FINDAGAIN, TRUE );
872                            WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FINDAGAIN), (MPARAM)TRUE );
873                        }
874                    }
875                    return (MRESULT)FALSE;
876
877                case CM_FINDAGAIN:
878                    docViewer->searchDocument( findDlg->getSearchString(),
879                                               findDlg->isCaseSensitive(), true );
880                    return (MRESULT)FALSE;
881
882                case CM_SETTINGS:
883                {
884                    SettingsDlg *d = new SettingsDlg( hWndFrame, settings );
885                    d->doDialog();
886                    return (MRESULT)FALSE;
887                }
888
889                case CM_FIRSTPAGE:
890                    Lucide::goToPage( 0 );
891                    return (MRESULT)FALSE;
892
893                case CM_NEXTPAGE:
894                    Lucide::goToPage( docViewer->getCurrentPage() + 1 );
895                    return (MRESULT)FALSE;
896
897                case CM_PREVPAGE:
898                    Lucide::goToPage( docViewer->getCurrentPage() - 1 );
899                    return (MRESULT)FALSE;
900
901                case CM_LASTPAGE:
902                    Lucide::goToPage( doc->getPageCount( ev ) - 1 );
903                    return (MRESULT)FALSE;
904
905                case CM_GOTOPAGE:
906                {
907                    GotoDlg *d = new GotoDlg( hWndFrame, doc->getPageCount( ev ),
908                                                docViewer->getCurrentPage() + 1 );
909                    if ( d->showDialog() == DID_OK ) {
910                        long pg = d->getPage();
911                        if ( pg > 0 ) {
912                            Lucide::goToPage( pg - 1 );
913                        }
914                    }
915                    delete d;
916                    return (MRESULT)FALSE;
917                }
918
919                case CM_FITWINDOW:
920                    Lucide::setZoom( -2 );
921                    return (MRESULT)FALSE;
922
923                case CM_ACTSIZE:
924                    Lucide::setZoom( 1 );
925                    return (MRESULT)FALSE;
926
927                case CM_FITWIDTH:
928                    Lucide::setZoom( -1 );
929                    return (MRESULT)FALSE;
930
931                case CM_ZOOM_IN_OUT:
932                    Lucide::toggleZoom();
933                    return (MRESULT)FALSE;
934
935                case CM_ZOOM_IN:
936                    docViewer->zoomInOut( true );
937                    return (MRESULT)FALSE;
938
939                case CM_ZOOM_OUT:
940                    docViewer->zoomInOut( false );
941                    return (MRESULT)FALSE;
942
943                case CM_SINGLEPAGE:
944                    Lucide::setPageLayout( SinglePage );
945                    return (MRESULT)FALSE;
946
947                case CM_CONTINUOUS:
948                    Lucide::setPageLayout( Continuous );
949                    return (MRESULT)FALSE;
950
951                case CM_ROTATE90CW:
952                    docViewer->setRotation( docViewer->getRotation() + 90 );
953                    return (MRESULT)FALSE;
954
955                case CM_ROTATE90CCW:
956                    docViewer->setRotation( docViewer->getRotation() - 90 );
957                    return (MRESULT)FALSE;
958
959                case CM_NAVPANE:
960                    {
961                        Lucide::showIndex = !Lucide::showIndex;
962                        Lucide::checkNavpane();
963                        WinSendMsg( hVertSplitter, SBM_SETSPLITTERPOS,
964                            MPFROMSHORT( Lucide::showIndex ? Lucide::splitterPos : 0 ), MPVOID );
965                        if ( !Lucide::showIndex ) {
966                            Lucide::focusDocview();
967                        }
968                    }
969                    return (MRESULT)FALSE;
970
971                case CM_MAXVIEW:
972                    Lucide::toggleMaxview();
973                    return (MRESULT)FALSE;
974
975                case CM_FULLSCREEN:
976                    Lucide::toggleFullscreen();
977                    return (MRESULT)FALSE;
978
979                case CM_PRODINFO:
980                    AboutBox( hWndFrame );
981                    return (MRESULT)FALSE;
982
983                case CM_MINIMIZE:
984                    Lucide::cmdMinimize();
985                    return (MRESULT)FALSE;
986
987                case CM_TOFULLSCREEN:
988                    Lucide::cmdSwitchToFullscreen();
989                    return (MRESULT)FALSE;
990
991                case CM_SWITCHWINDOW:
992                    Lucide::cmdSwitchWindow();
993                    return (MRESULT)FALSE;
994            }
995        }
996        break;
997    }
998    return pOldSplProc( hwnd, msg, mp1, mp2 );
999}
1000
1001
1002char deffont[] = "9.WarpSans";
1003int deffontlen = sizeof( deffont );
1004
1005extern "C" APIRET APIENTRY LucideMain( int argc, char *argv[] )
1006{
1007    HMQ   hmq;
1008    QMSG  qmsg;
1009    hab = WinInitialize( 0 );
1010    hmq = WinCreateMsgQueue( hab, 0 );
1011
1012    loadLang();
1013
1014    settings = new LuSettings;
1015    settings->load();
1016
1017    pluginMan = new PluginManager;
1018
1019    InitPMSplitterClass( hab );
1020    InitPMToolbarClass( hab );
1021
1022    ULONG ulFrameFlags = FCF_TITLEBAR | FCF_SIZEBORDER | FCF_SYSMENU |
1023                         FCF_MINMAX | FCF_TASKLIST | FCF_NOBYTEALIGN | FCF_ICON;
1024    title = newstrdupL( MSGS_MAIN_WIN_TITLE );
1025    hWndFrame = WinCreateStdWindow( HWND_DESKTOP, 0, &ulFrameFlags, NULL, title,
1026                                    WS_SYNCPAINT|WS_VISIBLE, _hmod, IDI_MAIN_ICON, NULL );
1027    hFrameSysmenu  = WinWindowFromID( hWndFrame, FID_SYSMENU );
1028    hFrameTitlebar = WinWindowFromID( hWndFrame, FID_TITLEBAR );
1029    hFrameMinMax   = WinWindowFromID( hWndFrame, FID_MINMAX );
1030    WinSetAccelTable( hab, WinLoadAccelTable( hab, _hmod, IDA_MAINACCEL ), hWndFrame );
1031    hWndMenu = WinLoadMenu( hWndFrame, _hmod, IDM_MAINMENU );
1032    localizeMenu( hWndMenu );
1033    WinSetWindowUShort( hWndMenu, QWS_ID, FID_MENU );
1034
1035    // Vertical splitter and his windows - Index and Document view
1036    hVertSplitter = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
1037                                     WS_VISIBLE | SBS_VSPLIT,
1038                                     0, 0, 0, 0, hWndFrame, HWND_TOP,
1039                                     ID_SPLITTER, NULL, NULL );
1040
1041    indexWin = new IndexWindow( hWndFrame );
1042
1043    DocumentViewer::registerClass();
1044
1045    docViewer = new DocumentViewer( hWndFrame );
1046
1047    WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
1048                MPFROMHWND( indexWin->getHWND() ), MPFROMHWND( docViewer->getFrameHWND() ) );
1049    Lucide::splitterPos = PrfQueryProfileInt( HINI_USERPROFILE, appName, splpos, Lucide::splitterPos );
1050    Lucide::showIndex = PrfQueryProfileInt( HINI_USERPROFILE, appName, showind, Lucide::showIndex );
1051    WinSendMsg( hVertSplitter, SBM_SETSPLITTERPOS,
1052                MPFROMSHORT( Lucide::showIndex ? Lucide::splitterPos : 0 ), MPVOID );
1053
1054    // Horizontal splitter and its windows - Toolbar and Vertical splitter
1055    // Horizontal splitter is client window
1056    HWND hHorizSplitter = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
1057                                           WS_VISIBLE | SBS_HSPLIT | SBS_SECONDFIXED,
1058                                           0, 0, 0, 0, hWndFrame, HWND_TOP,
1059                                           FID_CLIENT, NULL, NULL );
1060    pOldSplProc = WinSubclassWindow( hHorizSplitter, splProc );
1061
1062    hToolBar = createToolbar( hWndFrame );
1063
1064    WinSendMsg( hHorizSplitter, SBM_SETWINDOWS,
1065                MPFROMHWND( hVertSplitter ), MPFROMHWND( hToolBar ) );
1066    // ãáâ ­®¢šâì 䚪ášà®¢ ­­ë© à §¬¥à €«ï âã«¡ à 
1067    WinSendMsg( hHorizSplitter, SBM_SETFIXEDSIZE,
1068                MPFROMSHORT( DEFAULT_PICTSIZE + TOOLBAR_HEIGHT_ADD ), MPVOID );
1069
1070    findDlg = new FindDlg( hWndFrame );
1071    Lucide::checkMenus();
1072    Lucide::setPageLayout( settings->layout );
1073    Lucide::setZoom( settings->zoom );
1074
1075    // ®ª § âì ®ª­® ¯à®£à ¬¬ë
1076    if ( !PMRestoreWindowPos( NULL, appName, fwp, hWndFrame,
1077                              TRUE, TRUE, FALSE, FALSE, FALSE ) ) {
1078        WinSetWindowPos( hWndFrame, HWND_TOP, 100, 100, 630, 400,
1079                         SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ACTIVATE );
1080    }
1081
1082    Lucide::focusDocview();
1083
1084    if ( argc > 1 ) {
1085        Lucide::loadDocument( argv[1] );
1086    }
1087
1088    Lucide::checkNavpane();
1089    initPipeMon( hWndFrame );
1090
1091    // Messsage loop
1092    while ( WinGetMsg( hab, &qmsg, 0, 0, 0 ) ) {
1093        WinDispatchMsg( hab, &qmsg );
1094    }
1095
1096    if ( WinIsWindow( hab, hWndFrame ) )
1097    {
1098        char valbuf[ 3 ] = "";
1099        PrfWriteProfileString( HINI_USERPROFILE, appName, splpos,
1100                               itoa( Lucide::splitterPos, valbuf, 10 ) );
1101        PrfWriteProfileString( HINI_USERPROFILE, appName, showind,
1102                               itoa( Lucide::showIndex, valbuf, 10 ) );
1103        PMStoreWindowPos( NULL, appName, fwp, hWndFrame );
1104    }
1105
1106    WinDestroyWindow( hWndFrame );
1107
1108    Lucide::closeDocument();
1109    delete docViewer;
1110    delete indexWin;
1111
1112    // must be freed _after_ document
1113    delete pluginMan;
1114
1115    delete findDlg;
1116    delete title;
1117    delete settings;
1118    unInitPipeMon();
1119
1120    WinDestroyMsgQueue( hmq );
1121    WinTerminate( hab );
1122    return 0;
1123}
1124
Note: See TracBrowser for help on using the repository browser.