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

Last change on this file since 385 was 385, checked in by Silvan Scherrer, 12 years ago

updated aboutdlg ticket:174

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