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

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

Reworked the switch to fullscreen code so that all accelerators that work in normal mode (like Ctrl-Ins, Ctrl-C, Ctrl-O etc) now work in fullscreen too. This also fixes various weird behavior such as the phantom Lucide main frame when pressing the Alt in fullscreen.

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