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

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

Merged bramches/kmk (r294:365) to trunk.

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