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

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

List of recent files

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