source: trunk/Lucide/SOURCE/gui/lucide.cpp @ 234

Last change on this file since 234 was 234, checked in by Eugene Romanenko, 14 years ago

return dot to wildcard, small interface fixes

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