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

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

custom file dialog with preview

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