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

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

Don't process commands that are disabled in the menu while in fullscreen.

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