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

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

subsequently load supported files in same directory, Next/Previous? menuitem (part of ticket #66)

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