source: trunk/Lucide/gui/lucide.cpp @ 391

Last change on this file since 391 was 391, checked in by dmik, 11 years ago

Close Lucide in fullscreen and max view mode with Alt-F4.

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