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

Last change on this file since 393 was 393, checked in by dmik, 12 years ago

Make copy to clipboard work in input fields in fullscreen mode (PM misbehavior).

File size: 53.6 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        }
1183        break;
1184
1185        case WM_SYSCOMMAND:
1186        {
1187            if ( SHORT1FROMMP(mp1) == SC_CLOSE ) {
1188                // the system menu is disabled in fullscreen/presentation mode
1189                // but we still want to exit with Alt-F4 so always handle it here
1190                WinPostMsg( hWndFrame, WM_CLOSE, NULL, NULL );
1191                return (MRESULT)FALSE;
1192            }
1193        }
1194        break;
1195    }
1196
1197    return pOldFrameProc( hwnd, msg, mp1, mp2 );
1198}
1199
1200static MRESULT EXPENTRY splProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
1201{
1202    switch ( msg )
1203    {
1204        case WM_CONTROL:
1205        {
1206            if ( ( SHORT1FROMMP( mp1 ) == ID_SPLITTER ) &&
1207                 ( SHORT2FROMMP( mp1 ) == SBN_POSITIONCHANGED ) )
1208            {
1209                SHORT pos = SHORT1FROMMP( mp2 );
1210                if ( pos > 0 ) {
1211                    Lucide::splitterPos = pos;
1212                    Lucide::showIndex = true;
1213                }
1214                else {
1215                    Lucide::showIndex = false;
1216                }
1217                Lucide::checkNavpane();
1218            }
1219        }
1220        break;
1221
1222        case WM_COMMAND:
1223        {
1224            switch ( SHORT1FROMMP(mp1) )
1225            {
1226                case CM_NEW_WINDOW:
1227                    Lucide::newWindow( NULL, false );
1228                    return (MRESULT)FALSE;
1229
1230                case CM_OPEN:
1231                    Lucide::openDocument();
1232                    return (MRESULT)FALSE;
1233
1234                case CM_FILEFIRST:
1235                    Lucide::gotoFile( ListFirst );
1236                    return (MRESULT)FALSE;
1237
1238                case CM_FILEPREVIOUS:
1239                    Lucide::gotoFile( ListPrevious );
1240                    return (MRESULT)FALSE;
1241
1242                case CM_FILENEXT:
1243                    Lucide::gotoFile( ListNext );
1244                    return (MRESULT)FALSE;
1245
1246                case CM_FILELAST:
1247                    Lucide::gotoFile( ListLast );
1248                    return (MRESULT)FALSE;
1249
1250                case CM_RECENT + 1:
1251                case CM_RECENT + 2:
1252                case CM_RECENT + 3:
1253                case CM_RECENT + 4:
1254                case CM_RECENT + 5:
1255                case CM_RECENT + 6:
1256                case CM_RECENT + 7:
1257                case CM_RECENT + 8:
1258                case CM_RECENT + 9:
1259                {
1260                    std::string f = recent->getFile( SHORT1FROMMP(mp1) );
1261                    Lucide::loadDocument( f.c_str() );
1262                    return (MRESULT)FALSE;
1263                }
1264
1265                case CM_RECENTCLEAR:
1266                    recent->clear();
1267                    return (MRESULT)FALSE;
1268
1269                case CM_SAVEAS:
1270                    Lucide::saveDocumentAs();
1271                    return (MRESULT)FALSE;
1272
1273                case CM_CLOSE:
1274                    Lucide::closeDocument();
1275                    return (MRESULT)FALSE;
1276
1277                case CM_PRINT:
1278                {
1279                    PrintDlg *d = new PrintDlg( hWndFrame, doc, Lucide::docFileName,
1280                                                docViewer->getCurrentPage() + 1 );
1281                    if ( d->showDialog() == DID_OK )
1282                    {
1283                        // print
1284                        PrintSetup *p = new PrintSetup;
1285                        memset( p, 0, sizeof( PrintSetup ) );
1286                        d->getPrintSetup( p );
1287                        printDocument( hWndFrame, doc, Lucide::docFileName, p );
1288                        delete p;
1289                    }
1290                    delete d;
1291                    return (MRESULT)FALSE;
1292                }
1293
1294                case CM_EXIT:
1295                    WinPostMsg( hWndFrame, WM_CLOSE, NULL, NULL );
1296                    return (MRESULT)FALSE;
1297
1298                case CM_DOCINFO:
1299                {
1300                    LuDocumentInfo *dinfo = doc->getDocumentInfo( ev );
1301                    DocInfoDlg *d = new DocInfoDlg( hWndFrame, dinfo );
1302                    d->doDialog();
1303                    LuDocument::freeDocumentInfo( ev, dinfo );
1304                    return (MRESULT)FALSE;
1305                }
1306
1307                case CM_FONTSINFO:
1308                {
1309                    FontsInfoDlg *d = new FontsInfoDlg( hWndFrame, doc );
1310                    d->doDialog();
1311                    return (MRESULT)FALSE;
1312                }
1313
1314                case CM_PLUGINSLIST:
1315                {
1316                    PluginViewDlg *d = new PluginViewDlg( hWndFrame,
1317                                                pluginMan->getPluginsList() );
1318                    d->doDialog();
1319                    return (MRESULT)FALSE;
1320                }
1321
1322                case CM_COPY:
1323                    docViewer->copyToClipbrd();
1324                    return (MRESULT)FALSE;
1325
1326                case CM_SELECTALL:
1327                    docViewer->selectAll();
1328                    return (MRESULT)FALSE;
1329
1330                case CM_FIND:
1331                    if ( findDlg->showDialog() == DID_OK ) {
1332                        if ( strlen( findDlg->getSearchString() ) > 0 )
1333                        {
1334                            docViewer->searchDocument( findDlg->getSearchString(),
1335                                            findDlg->isCaseSensitive(), false );
1336
1337                            WinEnableMenuItem( hWndMenu, CM_FINDAGAIN, TRUE );
1338                            WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FINDAGAIN), (MPARAM)TRUE );
1339                        }
1340                    }
1341                    return (MRESULT)FALSE;
1342
1343                case CM_FINDAGAIN:
1344                    docViewer->searchDocument( findDlg->getSearchString(),
1345                                               findDlg->isCaseSensitive(), true );
1346                    return (MRESULT)FALSE;
1347
1348                case CM_SETTINGS:
1349                {
1350                    SettingsDlg *d = new SettingsDlg( hWndFrame, settings );
1351                    d->doDialog();
1352                    return (MRESULT)FALSE;
1353                }
1354
1355                case CM_FIRSTPAGE:
1356                    Lucide::goToPage( 0 );
1357                    return (MRESULT)FALSE;
1358
1359                case CM_NEXTPAGE:
1360                    Lucide::goToPage( docViewer->getCurrentPage() + 1 );
1361                    return (MRESULT)FALSE;
1362
1363                case CM_PREVPAGE:
1364                    Lucide::goToPage( docViewer->getCurrentPage() - 1 );
1365                    return (MRESULT)FALSE;
1366
1367                case CM_LASTPAGE:
1368                    Lucide::goToPage( doc->getPageCount( ev ) - 1 );
1369                    return (MRESULT)FALSE;
1370
1371                case CM_GOTOPAGE:
1372                {
1373                    GotoDlg *d = new GotoDlg( hWndFrame, doc->getPageCount( ev ),
1374                                                docViewer->getCurrentPage() + 1 );
1375                    if ( d->showDialog() == DID_OK ) {
1376                        long pg = d->getPage();
1377                        if ( pg > 0 ) {
1378                            Lucide::goToPage( pg - 1 );
1379                        }
1380                    }
1381                    delete d;
1382                    return (MRESULT)FALSE;
1383                }
1384
1385                case CM_FITWINDOW:
1386                    Lucide::setZoom( -2 );
1387                    return (MRESULT)FALSE;
1388
1389                case CM_ACTSIZE:
1390                    Lucide::setZoom( 1 );
1391                    return (MRESULT)FALSE;
1392
1393                case CM_FITWIDTH:
1394                    Lucide::setZoom( -1 );
1395                    return (MRESULT)FALSE;
1396
1397                case CM_ZOOM_IN_OUT:
1398                    Lucide::toggleZoom();
1399                    return (MRESULT)FALSE;
1400
1401                case CM_ZOOM_IN:
1402                    docViewer->zoomInOut( true );
1403                    return (MRESULT)FALSE;
1404
1405                case CM_ZOOM_OUT:
1406                    docViewer->zoomInOut( false );
1407                    return (MRESULT)FALSE;
1408
1409                case CM_SINGLEPAGE:
1410                    Lucide::setPageLayout( SinglePage );
1411                    return (MRESULT)FALSE;
1412
1413                case CM_CONTINUOUS:
1414                    Lucide::setPageLayout( Continuous );
1415                    return (MRESULT)FALSE;
1416
1417                case CM_ROTATE90CW:
1418                    docViewer->setRotation( docViewer->getRotation() + 90 );
1419                    return (MRESULT)FALSE;
1420
1421                case CM_ROTATE90CCW:
1422                    docViewer->setRotation( docViewer->getRotation() - 90 );
1423                    return (MRESULT)FALSE;
1424
1425                case CM_NAVPANE:
1426                    {
1427                        Lucide::showIndex = !Lucide::showIndex;
1428                        Lucide::checkNavpane();
1429                        WinSendMsg( hVertSplitter, SBM_SETSPLITTERPOS,
1430                            MPFROMSHORT( Lucide::showIndex ? Lucide::splitterPos : 0 ), MPVOID );
1431                        if ( !Lucide::showIndex ) {
1432                            Lucide::focusDocview();
1433                        }
1434                    }
1435                    return (MRESULT)FALSE;
1436
1437                case CM_MAXVIEW:
1438                    Lucide::toggleMaxview();
1439                    return (MRESULT)FALSE;
1440
1441                case CM_FULLSCREEN:
1442                    Lucide::toggleFullscreen();
1443                    return (MRESULT)FALSE;
1444
1445                case CM_PRODINFO:
1446                    AboutBox( hWndFrame );
1447                    return (MRESULT)FALSE;
1448
1449                case CM_MINIMIZE:
1450                    Lucide::cmdMinimize();
1451                    return (MRESULT)FALSE;
1452
1453                case CM_TOFULLSCREEN:
1454                    Lucide::cmdSwitchToFullscreen();
1455                    return (MRESULT)FALSE;
1456
1457                case CM_SWITCHWINDOW:
1458                    Lucide::cmdSwitchWindow();
1459                    return (MRESULT)FALSE;
1460            }
1461        }
1462        break;
1463
1464        case WM_CLOSE:
1465            if ( !Lucide::closeDocument() )
1466                return (MRESULT)FALSE;
1467        break;
1468    }
1469    return pOldSplProc( hwnd, msg, mp1, mp2 );
1470}
1471
1472
1473char deffont[] = "9.WarpSans";
1474int deffontlen = sizeof( deffont );
1475
1476__declspec(dllexport) _System APIRET APIENTRY LucideMain( int argc, char *argv[] )
1477{
1478    HMQ   hmq;
1479    QMSG  qmsg;
1480    hab = WinInitialize( 0 );
1481    hmq = WinCreateMsgQueue( hab, 0 );
1482
1483    loadLang();
1484
1485    settings = new LuSettings;
1486    settings->load();
1487
1488    pluginMan = new PluginManager;
1489
1490    InitPMSplitterClass( hab );
1491    InitPMToolbarClass( hab );
1492
1493    ULONG ulFrameFlags = FCF_TITLEBAR | FCF_SIZEBORDER | FCF_SYSMENU |
1494                         FCF_MINMAX | FCF_TASKLIST | FCF_NOBYTEALIGN | FCF_ICON;
1495    title = newstrdupL( MSGS_MAIN_WIN_TITLE );
1496    hWndFrame = WinCreateStdWindow( HWND_DESKTOP, 0, &ulFrameFlags, NULL, title,
1497                                    WS_SYNCPAINT|WS_VISIBLE, _hmod, IDI_MAIN_ICON, NULL );
1498    pOldFrameProc = WinSubclassWindow( hWndFrame, frameProc );
1499
1500    hFrameSysmenu  = WinWindowFromID( hWndFrame, FID_SYSMENU );
1501    hFrameTitlebar = WinWindowFromID( hWndFrame, FID_TITLEBAR );
1502    hFrameMinMax   = WinWindowFromID( hWndFrame, FID_MINMAX );
1503    WinSetAccelTable( hab, WinLoadAccelTable( hab, _hmod, IDA_MAINACCEL ), hWndFrame );
1504    hWndMenu = WinLoadMenu( hWndFrame, _hmod, IDM_MAINMENU );
1505    localizeMenu( hWndMenu );
1506    WinSetWindowUShort( hWndMenu, QWS_ID, FID_MENU );
1507
1508    // Vertical splitter and his windows - Index and Document view
1509    hVertSplitter = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
1510                                     WS_VISIBLE | SBS_VSPLIT,
1511                                     0, 0, 0, 0, hWndFrame, HWND_TOP,
1512                                     ID_SPLITTER, NULL, NULL );
1513
1514    indexWin = new IndexWindow( hWndFrame );
1515
1516    DocumentViewer::registerClass();
1517
1518    docViewer = new DocumentViewer( hWndFrame );
1519
1520    WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
1521                MPFROMHWND( indexWin->getHWND() ), MPFROMHWND( docViewer->getFrameHWND() ) );
1522
1523    // Horizontal splitter and its windows - Toolbar and Vertical splitter
1524    // Horizontal splitter is client window
1525    hHorizSplitter = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
1526                                      WS_VISIBLE | SBS_HSPLIT | SBS_SECONDFIXED,
1527                                      0, 0, 0, 0, hWndFrame, HWND_TOP,
1528                                      FID_CLIENT, NULL, NULL );
1529    pOldSplProc = WinSubclassWindow( hHorizSplitter, splProc );
1530
1531    hToolBar = createToolbar( hWndFrame );
1532
1533    WinSendMsg( hHorizSplitter, SBM_SETWINDOWS,
1534                MPFROMHWND( hVertSplitter ), MPFROMHWND( hToolBar ) );
1535    // ᅵᅵ⠭ᅵᅵᅵᅵᅵ 䚪ᅵ஢ᅵᅵᅵᅵ ࠧᅵᅵᅵ ᅵᅵᅵ ᅵ㫡ᅵᅵ
1536    WinSendMsg( hHorizSplitter, SBM_SETFIXEDSIZE,
1537                MPFROMSHORT( DEFAULT_PICTSIZE + TOOLBAR_HEIGHT_ADD ), MPVOID );
1538
1539    Lucide::checkMenus( true );
1540    Lucide::setPageLayout( settings->layout );
1541    Lucide::setZoom( settings->zoom );
1542
1543    findDlg = new FindDlg( hWndFrame );
1544    recent  = new RecentFiles( hWndMenu );
1545
1546    Lucide::restorePosition();
1547
1548    Lucide::focusDocview();
1549
1550    if ( argc > 1 ) {
1551        Lucide::loadDocument( argv[1] );
1552    }
1553
1554    Lucide::checkNavpane();
1555    initPipeMon( hWndFrame );
1556
1557    // Messsage loop
1558    while ( WinGetMsg( hab, &qmsg, 0, 0, 0 ) ) {
1559        WinDispatchMsg( hab, &qmsg );
1560    }
1561
1562    Lucide::savePosition();
1563
1564    WinDestroyWindow( hWndFrame );
1565
1566    recent->save();
1567
1568    Lucide::closeDocument( true );
1569    delete docViewer;
1570    delete indexWin;
1571
1572    // must be freed _after_ document
1573    delete pluginMan;
1574
1575    delete findDlg;
1576    delete recent;
1577    delete title;
1578    delete settings;
1579    unInitPipeMon();
1580
1581    WinDestroyMsgQueue( hmq );
1582    WinTerminate( hab );
1583    return 0;
1584}
1585
Note: See TracBrowser for help on using the repository browser.