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

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

Renamed "Full screen" mode to "Presentation" mode (activated by F5 now) and renamed "Maximized view" mode to "Full screen" mode (same F11 shortcut), for clarity and similarity with other applications (fixes ticket:176).

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