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

Last change on this file since 150 was 138, checked in by Eugene Romanenko, 15 years ago

Better solution for #78, move GUI to DLL, executor sets BeginLibPath? and loads GUI DLL (closes #78)

File size: 33.3 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 <stdio.h>
44#include <process.h>
45
46#include <ludoc.xh>
47
48#include "Lucide.h"
49#include "pluginman.h"
50#include "pluginViewDlg.h"
51#include "fontsInfoDlg.h"
52#include "docInfoDlg.h"
53#include "findDlg.h"
54#include "printDlg.h"
55#include "progressDlg.h"
56#include "settingsDlg.h"
57#include "docViewer.h"
58#include "indexWindow.h"
59#include "lusettings.h"
60#include "luutils.h"
61#include "tb_spl.h"
62#include "Lucide_res.h"
63#include "messages.h"
64
65
66#define ID_SPLITTER 1
67
68const char *appName    = "Lucide";
69const char *appVersion = VERSION;
70const char *fwp        = "FrameWindowPos";
71const char *lvd        = "LastViewedDir";
72const char *splpos     = "SplitterPos";
73const char *showind    = "ShowIndex";
74
75HWND createToolbar( HWND hwnd );
76void AboutBox( HWND hWndFrame );
77
78HAB   hab            = NULLHANDLE;
79HWND  hWndFrame      = NULLHANDLE;
80HWND  hWndMenu       = NULLHANDLE;
81HWND  hToolBar       = NULLHANDLE;
82HWND  hVertSplitter  = NULLHANDLE;
83HWND  hFrameSysmenu  = NULLHANDLE;
84HWND  hFrameTitlebar = NULLHANDLE;
85HWND  hFrameMinMax   = NULLHANDLE;
86
87Environment    *ev        = somGetGlobalEnvironment();
88LuDocument     *doc       = NULL;
89PluginManager  *pluginMan = NULL;
90DocumentViewer *docViewer = NULL;
91IndexWindow    *indexWin  = NULL;
92FindDlg        *findDlg   = NULL;
93LuSettings     *settings  = NULL;
94char           *title     = NULL;
95
96
97bool         Lucide::dontSwitchPage                = false;
98SHORT        Lucide::splitterPos                   = 100;
99bool         Lucide::showIndex                     = true;
100bool         Lucide::isMaxview                     = false;
101bool         Lucide::isFullscreen                  = false;
102LuWindowPos  Lucide::winPos                        = {0};
103char         Lucide::docFullName[ CCHMAXPATH ]     = "";
104char         Lucide::docFileName[ CCHMAXPATHCOMP ] = "";
105// static data for asynch loading document
106ProgressDlg *Lucide::loadProgressDlg               = NULL;
107bool         Lucide::docLoaded                     = false;;
108char        *Lucide::loadError                     = NULL;
109
110HMODULE _hmod = NULLHANDLE;
111
112unsigned APIENTRY LibMain( unsigned hmod, unsigned termination )
113{
114    if ( termination ) {
115        /* DLL is detaching from process */
116    } else {
117        /* DLL is attaching to process */
118        _hmod = hmod;
119    }
120    return( 1 );
121}
122
123
124PFNWP pOldSplProc;
125
126void Lucide::enableCopy( bool enable )
127{
128    WinEnableMenuItem( hWndMenu, CM_COPY, enable );
129}
130
131void Lucide::setOfPages( long pages )
132{
133    char *pgfrm = newstrdupL( TB_PAGENUM );
134    char pgnum[ 32 ];
135    snprintf( pgnum, sizeof( pgnum ), pgfrm, pages );
136    delete pgfrm;
137    WinSetDlgItemText( hToolBar, TBID_OFPAGES, pgnum );
138    WinSendDlgItemMsg( hToolBar, TBID_PAGENUM, SPBM_SETLIMITS,
139                       MPFROMLONG( pages ), MPFROMLONG( 1 ) );
140}
141
142void Lucide::checkNavigationMenus()
143{
144    WinEnableMenuItem( hWndMenu, CM_GOTOPAGE, TRUE );
145    BOOL enfirst = ( docViewer->getCurrentPage() != 0 );
146    BOOL enlast = ( docViewer->getCurrentPage() != ( doc->getPageCount( ev ) - 1 ) );
147    WinEnableMenuItem( hWndMenu, CM_FIRSTPAGE, enfirst );
148    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIRSTPAGE), (MPARAM)enfirst );
149    WinEnableMenuItem( hWndMenu, CM_PREVPAGE, enfirst );
150    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PREVPAGE), (MPARAM)enfirst );
151    WinEnableMenuItem( hWndMenu, CM_NEXTPAGE, enlast );
152    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_NEXTPAGE), (MPARAM)enlast );
153    WinEnableMenuItem( hWndMenu, CM_LASTPAGE, enlast );
154    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_LASTPAGE), (MPARAM)enlast );
155
156    bool tmp = dontSwitchPage;
157    dontSwitchPage = true;
158    WinSendDlgItemMsg( hToolBar, TBID_PAGENUM, SPBM_SETCURRENTVALUE,
159                       MPFROMLONG( docViewer->getCurrentPage() + 1 ), MPVOID );
160    dontSwitchPage = tmp;
161    indexWin->goToPage( NULL, docViewer->getCurrentPage() );
162}
163
164void Lucide::enableZoomMenus()
165{
166    BOOL scalable = doc->isScalable( ev );
167    WinEnableMenuItem( hWndMenu, CM_FITWINDOW, scalable );
168    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWINDOW), (MPARAM)scalable );
169    WinEnableMenuItem( hWndMenu, CM_ACTSIZE, scalable );
170    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ACTSIZE), (MPARAM)scalable );
171    WinEnableMenuItem( hWndMenu, CM_FITWIDTH, scalable );
172    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWIDTH), (MPARAM)scalable );
173    WinEnableMenuItem( hWndMenu, CM_ZOOM_IN_OUT, scalable );
174    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ZOOM_IN_OUT), (MPARAM)scalable );
175    WinEnableControl( hToolBar, TBID_ZOOM, scalable );
176    BOOL rotable = doc->isRotable( ev );
177    WinEnableMenuItem( hWndMenu, CM_ROTATE90CW, rotable );
178    WinEnableMenuItem( hWndMenu, CM_ROTATE90CCW, rotable );
179}
180
181
182void Lucide::setZoomChecks( SHORT cmd, SHORT cbind, double zoom )
183{
184    if ( cmd != -1 )
185    {
186        WinCheckMenuItem( hWndMenu, cmd, TRUE );
187        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( cmd ), (MPARAM)TRUE );
188    }
189
190    if ( cbind != -1 )
191    {
192        char buf[ 255 ] = "";
193        WinSendDlgItemMsg( hToolBar, TBID_ZOOM, LM_QUERYITEMTEXT,
194                           MPFROM2SHORT( cbind, sizeof( buf ) ), MPFROMP( buf ) );
195        WinSetDlgItemText( hToolBar, TBID_ZOOM, buf );
196    }
197
198    if ( zoom != 0 )
199    {
200        std::string z = str( zoom * 100.0 ) + "%";
201        WinSetDlgItemText( hToolBar, TBID_ZOOM, z.c_str() );
202    }
203}
204
205void Lucide::checkZoomMenus()
206{
207    double zoom = docViewer->getZoom();
208
209    WinCheckMenuItem( hWndMenu, CM_FITWINDOW, FALSE );
210    WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT(CM_FITWINDOW), (MPARAM)FALSE );
211    WinCheckMenuItem( hWndMenu, CM_ACTSIZE, FALSE );
212    WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT(CM_ACTSIZE), (MPARAM)FALSE );
213    WinCheckMenuItem( hWndMenu, CM_FITWIDTH, FALSE );
214    WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT(CM_FITWIDTH), (MPARAM)FALSE );
215
216    if ( zoom == -2 ) {
217        setZoomChecks( CM_FITWINDOW, 1, 0 );
218    } else if ( zoom == -1 ) {
219        setZoomChecks( CM_FITWIDTH, 2, 0 );
220    } else if ( zoom == 1 ) {
221        setZoomChecks( CM_ACTSIZE, 0, 0 );
222    } else {
223        setZoomChecks( -1, -1, zoom );
224    }
225}
226
227void Lucide::checkMenus()
228{
229    // pre-set "Actual size"
230    setZoomChecks( CM_ACTSIZE, 0, 0 );
231
232    if ( doc == NULL )
233    {
234        // "single page" mode by default
235        WinCheckMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
236
237        WinEnableMenuItem( hWndMenu, CM_SAVEAS, FALSE );
238        WinEnableMenuItem( hWndMenu, CM_PRINT, FALSE );
239        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PRINT), (MPARAM)FALSE );
240        WinEnableMenuItem( hWndMenu, CM_DOCINFO, FALSE );
241        WinEnableMenuItem( hWndMenu, CM_FONTSINFO, FALSE );
242
243        WinEnableMenuItem( hWndMenu, CM_COPY, FALSE );
244        WinEnableMenuItem( hWndMenu, CM_SELECTALL, FALSE );
245        WinEnableMenuItem( hWndMenu, CM_FIND, FALSE );
246        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIND), (MPARAM)FALSE );
247        WinEnableMenuItem( hWndMenu, CM_FINDAGAIN, FALSE );
248        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FINDAGAIN), (MPARAM)FALSE );
249
250        WinEnableMenuItem( hWndMenu, CM_FIRSTPAGE, FALSE );
251        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIRSTPAGE), (MPARAM)FALSE );
252        WinEnableMenuItem( hWndMenu, CM_PREVPAGE, FALSE );
253        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PREVPAGE), (MPARAM)FALSE );
254        WinEnableMenuItem( hWndMenu, CM_NEXTPAGE, FALSE );
255        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_NEXTPAGE), (MPARAM)FALSE );
256        WinEnableMenuItem( hWndMenu, CM_LASTPAGE, FALSE );
257        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_LASTPAGE), (MPARAM)FALSE );
258        WinEnableMenuItem( hWndMenu, CM_GOTOPAGE, FALSE );
259
260        WinEnableMenuItem( hWndMenu, CM_FITWINDOW, FALSE );
261        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWINDOW), (MPARAM)FALSE );
262        WinEnableMenuItem( hWndMenu, CM_ACTSIZE, FALSE );
263        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ACTSIZE), (MPARAM)FALSE );
264        WinEnableMenuItem( hWndMenu, CM_FITWIDTH, FALSE );
265        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FITWIDTH), (MPARAM)FALSE );
266        WinEnableMenuItem( hWndMenu, CM_ZOOM_IN_OUT, FALSE );
267        WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_ZOOM_IN_OUT), (MPARAM)FALSE );
268        WinEnableControl( hToolBar, TBID_ZOOM, FALSE );
269
270        WinEnableMenuItem( hWndMenu, CM_ROTATE90CW, FALSE );
271        WinEnableMenuItem( hWndMenu, CM_ROTATE90CCW, FALSE );
272        WinEnableMenuItem( hWndMenu, CM_SINGLEPAGE, FALSE );
273        WinEnableMenuItem( hWndMenu, CM_CONTINUOUS, FALSE );
274
275        setOfPages( 0 );
276        return;
277    }
278
279
280    checkNavigationMenus();
281    enableZoomMenus();
282    checkZoomMenus();
283
284    WinEnableMenuItem( hWndMenu, CM_PRINT, TRUE );
285    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_PRINT), (MPARAM)TRUE );
286    WinEnableMenuItem( hWndMenu, CM_SAVEAS, doc->isSaveable( ev ) );
287    setOfPages( doc->getPageCount( ev ) );
288    WinEnableMenuItem( hWndMenu, CM_FONTSINFO, doc->isHaveFontInfo( ev ) );
289    WinEnableMenuItem( hWndMenu, CM_DOCINFO, TRUE );
290
291    BOOL haveText = doc->isHaveText( ev );
292    WinEnableMenuItem( hWndMenu, CM_FIND, haveText );
293    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIND), (MPARAM)haveText );
294    WinEnableMenuItem( hWndMenu, CM_SELECTALL, haveText );
295
296    WinEnableMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
297    WinEnableMenuItem( hWndMenu, CM_CONTINUOUS, TRUE );
298}
299
300void Lucide::goToPage( long page )
301{
302    if ( docViewer != NULL ) {
303        docViewer->goToPage( page );
304    }
305}
306
307void Lucide::setZoom( double zoom )
308{
309    if ( docViewer != NULL ) {
310        docViewer->setZoom( zoom );
311        checkZoomMenus();
312    }
313}
314
315void Lucide::setDocument( LuDocument *_doc )
316{
317    docViewer->setDocument( _doc );
318    indexWin->setDocument( _doc );
319    checkMenus();
320}
321
322void Lucide::setPageLayout( PgLayout layout )
323{
324    if ( layout == SinglePage ) {
325        WinCheckMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
326        WinCheckMenuItem( hWndMenu, CM_CONTINUOUS, FALSE );
327    }
328    else {
329        WinCheckMenuItem( hWndMenu, CM_SINGLEPAGE, FALSE );
330        WinCheckMenuItem( hWndMenu, CM_CONTINUOUS, TRUE );
331    }
332
333    docViewer->setPageLayout( layout );
334}
335
336
337void Lucide::loadthread( void *p )
338{
339    HAB thab = WinInitialize( 0 );
340    HMQ thmq = WinCreateMsgQueue( thab, 0 );
341
342    docLoaded = doc->loadFile( ev, docFullName, NULL, &loadError );
343    loadProgressDlg->hide();
344
345    WinDestroyMsgQueue( thmq );
346    WinTerminate( thab );
347    _endthread();
348}
349
350void Lucide::loadDocument( const char *fn )
351{
352    char *msg = newstrdupL( MSGS_NO_SUIT_PLUG );
353
354    // find extension
355    char *ext = strrchr( fn, '.' );
356    if ( ext == NULL ) {
357        WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
358                       NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
359    }
360    else
361    {
362        // test if extension supported and then close previous opened document
363        if ( pluginMan->createDocumentForExt( ext + 1, true ) == NULL )
364        {
365            WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
366                           NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
367        }
368        else
369        {
370            docViewer->close();
371            delete doc;
372            doc = NULL;
373            WinSetWindowText( hWndFrame, title );
374
375            doc = pluginMan->createDocumentForExt( ext + 1, false );
376            if ( doc == NULL ) {
377                WinMessageBox( HWND_DESKTOP, hWndFrame, msg,
378                               NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
379            }
380            else
381            {
382                strcpy( docFullName, fn );
383                docLoaded = false;;
384                loadError = NULL;
385
386                // Load document asynchronously
387                loadProgressDlg = new ProgressDlg( hWndFrame );
388                char *ldmsg = newstrdupL( MSGS_LOADING_DOCUMENT );
389                loadProgressDlg->setText( ldmsg );
390                delete ldmsg;
391                loadProgressDlg->show( loadthread, NULL ); // doc will be loaded
392                delete loadProgressDlg;
393
394                if ( docLoaded )
395                {
396                    char *t = new char[ 2048 ];
397                    char _fn[ _MAX_FNAME ];
398                    char _ex[ _MAX_EXT ];
399                    _splitpath( fn, NULL, NULL, _fn, _ex );
400                    strcpy( docFileName, _fn );
401                    strcat( docFileName, _ex );
402                    snprintf( t, 2048, "%s - %s", docFileName, title );
403                    WinSetWindowText( hWndFrame, t );
404                    delete t;
405                    setDocument( doc );
406                }
407                else
408                {
409                    if ( loadError == NULL )
410                    {
411                        char *m = newstrdupL( MSGS_FILE_LOAD_ERROR );
412                        WinMessageBox( HWND_DESKTOP, hWndFrame, m,
413                                       NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
414                        delete m;
415                    }
416                    else
417                    {
418                        WinMessageBox( HWND_DESKTOP, hWndFrame, loadError,
419                                       NULL, 0, MB_OK | MB_ICONEXCLAMATION | MB_MOVEABLE );
420                        SOMFree( loadError );
421                    }
422
423                    delete doc;
424                    doc = NULL;
425                }
426            }
427
428        }
429
430    }
431    delete msg;
432}
433
434void Lucide::openDocument()
435{
436    char dirbuf[ CCHMAXPATH ];
437    PFILEDLG fd = new FILEDLG;
438    memset( fd, 0, sizeof( FILEDLG ) );
439    fd->cbSize = sizeof( FILEDLG );
440    fd->fl = FDS_CENTER | FDS_OPEN_DIALOG;
441    PrfQueryProfileString( HINI_USERPROFILE, appName, lvd, "",
442                           dirbuf, sizeof( dirbuf ) );
443    snprintf( fd->szFullFile, sizeof( fd->szFullFile ),
444              "%s%s", dirbuf, pluginMan->getExtsMask().c_str() );
445    WinFileDlg( HWND_DESKTOP, hWndFrame, fd );
446    if ( fd->lReturn == DID_OK )
447    {
448        char drv[ _MAX_DRIVE ] = "";
449        char dir[ _MAX_PATH ] = "";
450        char buf[ _MAX_PATH ] = "";
451        _splitpath( fd->szFullFile, drv, dir, NULL, NULL );
452        _makepath( buf, drv, dir, NULL, NULL );
453        PrfWriteProfileString( HINI_USERPROFILE, appName, lvd, buf );
454
455        loadDocument( fd->szFullFile );
456    }
457    delete fd;
458}
459
460void Lucide::saveDocumentAs()
461{
462    char dirbuf[ CCHMAXPATH ];
463    PFILEDLG fd = new FILEDLG;
464    memset( fd, 0, sizeof( FILEDLG ) );
465    fd->cbSize = sizeof( FILEDLG );
466    fd->fl = FDS_CENTER | FDS_SAVEAS_DIALOG;
467    PrfQueryProfileString( HINI_USERPROFILE, appName, lvd, "",
468                           dirbuf, sizeof( dirbuf ) );
469    char fil[ _MAX_FNAME ] = "";
470    char ext[ _MAX_EXT ] = "";
471    _splitpath( docFullName, NULL, NULL, fil, ext );
472    snprintf( fd->szFullFile, sizeof( fd->szFullFile ),
473                "%s%s%s", dirbuf, fil, ext );
474    WinFileDlg( HWND_DESKTOP, hWndFrame, fd );
475    if ( fd->lReturn == DID_OK )
476    {
477        bool doSave = true;
478        if ( access( fd->szFullFile, F_OK ) == 0 )
479        {
480            char *t = newstrdupL( MSGS_WARNING );
481            char *m = newstrdupL( MSGS_OVERWRITE_FILE );
482            ULONG response = WinMessageBox( HWND_DESKTOP, hWndFrame, m, t,
483                                            0, MB_YESNO | MB_WARNING | MB_MOVEABLE );
484            delete m;
485            delete t;
486
487            doSave = ( response == MBID_YES );
488        }
489        if ( doSave )
490        {
491            if ( !doc->saveAs( ev, fd->szFullFile ) )
492            {
493                char *m = newstrdupL( MSGS_FILE_SAVE_ERROR );
494                WinMessageBox( HWND_DESKTOP, hWndFrame, m, NULL,
495                               0, MB_OK | MB_ERROR | MB_MOVEABLE );
496                delete m;
497            }
498        }
499    }
500    delete fd;
501}
502
503void Lucide::checkNavpane()
504{
505    if ( Lucide::showIndex ) {
506        WinCheckMenuItem( hWndMenu, CM_NAVPANE, TRUE );
507        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( CM_NAVPANE ), (MPARAM)TRUE );
508    }
509    else {
510        WinCheckMenuItem( hWndMenu, CM_NAVPANE, FALSE );
511        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( CM_NAVPANE ), (MPARAM)FALSE );
512    }
513}
514
515
516void Lucide::toggleMaxview()
517{
518    ULONG ulFrameStyle = WinQueryWindowULong( hWndFrame, QWL_STYLE );
519
520    if ( isMaxview )
521    {
522        WinSetParent( hFrameSysmenu,  hWndFrame, FALSE );
523        WinSetParent( hFrameTitlebar, hWndFrame, FALSE );
524        WinSetParent( hFrameMinMax,   hWndFrame, FALSE );
525        ulFrameStyle |= FS_SIZEBORDER;
526    }
527    else
528    {
529        WinQueryWindowPos( hWndFrame, &winPos.Swp );
530        winPos.XRestore  = WinQueryWindowUShort( hWndFrame, QWS_XRESTORE );
531        winPos.YRestore  = WinQueryWindowUShort( hWndFrame, QWS_YRESTORE );
532        winPos.CXRestore = WinQueryWindowUShort( hWndFrame, QWS_CXRESTORE );
533        winPos.CYRestore = WinQueryWindowUShort( hWndFrame, QWS_CYRESTORE );
534        winPos.XMinimize = WinQueryWindowUShort( hWndFrame, QWS_XMINIMIZE );
535        winPos.YMinimize = WinQueryWindowUShort( hWndFrame, QWS_YMINIMIZE );
536
537        WinSetParent( hFrameSysmenu,  HWND_OBJECT, FALSE );
538        WinSetParent( hFrameTitlebar, HWND_OBJECT, FALSE );
539        WinSetParent( hFrameMinMax,   HWND_OBJECT, FALSE );
540        ulFrameStyle &= ~FS_SIZEBORDER;
541    }
542
543    WinSetWindowULong( hWndFrame, QWL_STYLE, ulFrameStyle );
544    WinSendMsg( hWndFrame, WM_UPDATEFRAME,
545                MPFROMLONG( FCF_TITLEBAR | FCF_SIZEBORDER | FCF_SYSMENU | FCF_MINMAX ),
546                MPVOID );
547
548    if ( isMaxview )
549    {
550        WinSetWindowUShort( hWndFrame, QWS_XRESTORE,  winPos.XRestore );
551        WinSetWindowUShort( hWndFrame, QWS_YRESTORE,  winPos.YRestore );
552        WinSetWindowUShort( hWndFrame, QWS_CXRESTORE, winPos.CXRestore );
553        WinSetWindowUShort( hWndFrame, QWS_CYRESTORE, winPos.CYRestore );
554        WinSetWindowUShort( hWndFrame, QWS_XMINIMIZE, winPos.XMinimize );
555        WinSetWindowUShort( hWndFrame, QWS_YMINIMIZE, winPos.YMinimize );
556        ULONG swpopt = SWP_MOVE | SWP_SIZE | SWP_SHOW;
557        WinSetWindowPos( hWndFrame, NULLHANDLE,
558                         winPos.Swp.x, winPos.Swp.y, winPos.Swp.cx, winPos.Swp.cy,
559                         swpopt );
560    }
561    else
562    {
563        WinSetWindowPos( hWndFrame, HWND_TOP, 0, 0,
564                         WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ),
565                         WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ),
566                         SWP_SIZE | SWP_MOVE | SWP_ZORDER );
567    }
568
569    isMaxview = !isMaxview;
570}
571
572
573void Lucide::toggleFullscreen()
574{
575    if ( isFullscreen )
576    {
577        docViewer->setFullscreen( false );
578        WinSetParent( docViewer->getFrameHWND(), hWndFrame, TRUE );
579        WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
580                    MPFROMHWND( indexWin->getHWND() ),
581                    MPFROMHWND( docViewer->getFrameHWND() ) );
582    }
583    else
584    {
585        docViewer->setFullscreen( true );
586        WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
587                    MPFROMHWND( indexWin->getHWND() ),
588                    MPFROMHWND( NULLHANDLE ) );
589        WinSetParent( docViewer->getFrameHWND(), HWND_DESKTOP, FALSE );
590        WinSetWindowPos( docViewer->getFrameHWND(), HWND_TOP, 0, 0,
591                         WinQuerySysValue( HWND_DESKTOP, SV_CXSCREEN ),
592                         WinQuerySysValue( HWND_DESKTOP, SV_CYSCREEN ),
593                         SWP_SIZE | SWP_MOVE | SWP_ZORDER );
594    }
595
596    isFullscreen = !isFullscreen;
597}
598
599void Lucide::focusDocview()
600{
601    WinSetFocus( HWND_DESKTOP, docViewer->getViewHWND() );
602}
603
604void Lucide::toggleZoom()
605{
606    if ( ( doc != NULL ) && doc->isScalable( ev ) )
607    {
608        bool isZoom = !docViewer->isZoomMode();
609
610        WinCheckMenuItem( hWndMenu, CM_ZOOM_IN_OUT, isZoom );
611        WinSendMsg( hToolBar, TBM_SETCHECK, MPFROMSHORT( CM_ZOOM_IN_OUT ), (MPARAM)isZoom );
612        docViewer->setZoomMode( isZoom );
613    }
614}
615
616static MRESULT EXPENTRY splProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
617{
618    switch ( msg )
619    {
620        case WM_CONTROL:
621        {
622            if ( ( SHORT1FROMMP( mp1 ) == ID_SPLITTER ) &&
623                 ( SHORT2FROMMP( mp1 ) == SBN_POSITIONCHANGED ) )
624            {
625                SHORT pos = SHORT1FROMMP( mp2 );
626                if ( pos > 0 ) {
627                    Lucide::splitterPos = pos;
628                    Lucide::showIndex = true;
629                }
630                else {
631                    Lucide::showIndex = false;
632                }
633                Lucide::checkNavpane();
634            }
635        }
636        break;
637
638        case WM_COMMAND:
639        {
640            switch ( SHORT1FROMMP(mp1) )
641            {
642                case CM_OPEN:
643                    Lucide::openDocument();
644                    return (MRESULT)FALSE;
645
646                case CM_SAVEAS:
647                    Lucide::saveDocumentAs();
648                    return (MRESULT)FALSE;
649
650                case CM_PRINT:
651                {
652                    PrintDlg *d = new PrintDlg( hWndFrame, doc, docViewer->getCurrentPage() + 1 );
653                    if ( d->showDialog() == DID_OK ) {
654                        // print
655                        PrintSetup *p = new PrintSetup;
656                        memset( p, 0, sizeof( PrintSetup ) );
657                        d->getPrintSetup( p );
658                        printDocument( hWndFrame, doc, Lucide::docFileName, p );
659                        delete p;
660                    }
661                    delete d;
662                    return (MRESULT)FALSE;
663                }
664
665                case CM_EXIT:
666                    WinPostMsg( hWndFrame, WM_CLOSE, NULL, NULL );
667                    return (MRESULT)FALSE;
668
669                case CM_DOCINFO:
670                {
671                    LuDocumentInfo *dinfo = doc->getDocumentInfo( ev );
672                    DocInfoDlg *d = new DocInfoDlg( hWndFrame, dinfo );
673                    d->doDialog();
674                    LuDocument::freeDocumentInfo( ev, dinfo );
675                    return (MRESULT)FALSE;
676                }
677
678                case CM_FONTSINFO:
679                {
680                    FontsInfoDlg *d = new FontsInfoDlg( hWndFrame, doc );
681                    d->doDialog();
682                    return (MRESULT)FALSE;
683                }
684
685                case CM_PLUGINSLIST:
686                {
687                    PluginViewDlg *d = new PluginViewDlg( hWndFrame,
688                                                pluginMan->getPluginsList() );
689                    d->doDialog();
690                    return (MRESULT)FALSE;
691                }
692
693                case CM_COPY:
694                    docViewer->copyToClipbrd();
695                    return (MRESULT)FALSE;
696
697                case CM_SELECTALL:
698                    docViewer->selectAll();
699                    return (MRESULT)FALSE;
700
701                case CM_FIND:
702                    if ( findDlg->showDialog() == DID_OK ) {
703                        if ( strlen( findDlg->getSearchString() ) > 0 )
704                        {
705                            docViewer->searchDocument( findDlg->getSearchString(),
706                                            findDlg->isCaseSensitive(), false );
707
708                            WinEnableMenuItem( hWndMenu, CM_FINDAGAIN, TRUE );
709                            WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FINDAGAIN), (MPARAM)TRUE );
710                        }
711                    }
712                    return (MRESULT)FALSE;
713
714                case CM_FINDAGAIN:
715                    docViewer->searchDocument( findDlg->getSearchString(),
716                                               findDlg->isCaseSensitive(), true );
717                    return (MRESULT)FALSE;
718
719                case CM_SETTINGS:
720                {
721                    SettingsDlg *d = new SettingsDlg( hWndFrame, settings );
722                    d->doDialog();
723                    return (MRESULT)FALSE;
724                }
725
726                case CM_FIRSTPAGE:
727                    Lucide::goToPage( 0 );
728                    return (MRESULT)FALSE;
729
730                case CM_NEXTPAGE:
731                    Lucide::goToPage( docViewer->getCurrentPage() + 1 );
732                    return (MRESULT)FALSE;
733
734                case CM_PREVPAGE:
735                    Lucide::goToPage( docViewer->getCurrentPage() - 1 );
736                    return (MRESULT)FALSE;
737
738                case CM_LASTPAGE:
739                    Lucide::goToPage( doc->getPageCount( ev ) - 1 );
740                    return (MRESULT)FALSE;
741
742                case CM_GOTOPAGE:
743                {
744                    GotoDlg *d = new GotoDlg( hWndFrame, doc->getPageCount( ev ),
745                                                docViewer->getCurrentPage() + 1 );
746                    if ( d->showDialog() == DID_OK ) {
747                        long pg = d->getPage();
748                        if ( pg > 0 ) {
749                            Lucide::goToPage( pg - 1 );
750                        }
751                    }
752                    delete d;
753                    return (MRESULT)FALSE;
754                }
755
756                case CM_FITWINDOW:
757                    Lucide::setZoom( -2 );
758                    return (MRESULT)FALSE;
759
760                case CM_ACTSIZE:
761                    Lucide::setZoom( 1 );
762                    return (MRESULT)FALSE;
763
764                case CM_FITWIDTH:
765                    Lucide::setZoom( -1 );
766                    return (MRESULT)FALSE;
767
768                case CM_ZOOM_IN_OUT:
769                    Lucide::toggleZoom();
770                    return (MRESULT)FALSE;
771
772                case CM_SINGLEPAGE:
773                    Lucide::setPageLayout( SinglePage );
774                    return (MRESULT)FALSE;
775
776                case CM_CONTINUOUS:
777                    Lucide::setPageLayout( Continuous );
778                    return (MRESULT)FALSE;
779
780                case CM_ROTATE90CW:
781                    docViewer->setRotation( docViewer->getRotation() + 90 );
782                    return (MRESULT)FALSE;
783
784                case CM_ROTATE90CCW:
785                    docViewer->setRotation( docViewer->getRotation() - 90 );
786                    return (MRESULT)FALSE;
787
788                case CM_NAVPANE:
789                    {
790                        Lucide::showIndex = !Lucide::showIndex;
791                        Lucide::checkNavpane();
792                        WinSendMsg( hVertSplitter, SBM_SETSPLITTERPOS,
793                            MPFROMSHORT( Lucide::showIndex ? Lucide::splitterPos : 0 ), MPVOID );
794                    }
795                    return (MRESULT)FALSE;
796
797                case CM_MAXVIEW:
798                    Lucide::toggleMaxview();
799                    return (MRESULT)FALSE;
800
801                case CM_FULLSCREEN:
802                    Lucide::toggleFullscreen();
803                    return (MRESULT)FALSE;
804
805                case CM_PRODINFO:
806                    AboutBox( hWndFrame );
807                    return (MRESULT)FALSE;
808
809            }
810        }
811        break;
812    }
813    return pOldSplProc( hwnd, msg, mp1, mp2 );
814}
815
816
817char deffont[] = "9.WarpSans";
818int deffontlen = sizeof( deffont );
819
820extern "C" APIRET APIENTRY LucideMain( int argc, char *argv[] )
821{
822    HMQ   hmq;
823    QMSG  qmsg;
824    hab = WinInitialize( 0 );
825    hmq = WinCreateMsgQueue( hab, 0 );
826
827    loadLang();
828
829    settings = new LuSettings;
830    settings->load();
831
832    pluginMan = new PluginManager;
833
834    InitPMSplitterClass( hab );
835    InitPMToolbarClass( hab );
836
837    ULONG ulFrameFlags = FCF_TITLEBAR | FCF_SIZEBORDER | FCF_SYSMENU |
838                         FCF_MINMAX | FCF_TASKLIST | FCF_NOBYTEALIGN | FCF_ICON;
839    title = newstrdupL( MSGS_MAIN_WIN_TITLE );
840    hWndFrame = WinCreateStdWindow( HWND_DESKTOP, 0, &ulFrameFlags, NULL, title,
841                                    WS_SYNCPAINT|WS_VISIBLE, _hmod, IDI_MAIN_ICON, NULL );
842    hFrameSysmenu  = WinWindowFromID( hWndFrame, FID_SYSMENU );
843    hFrameTitlebar = WinWindowFromID( hWndFrame, FID_TITLEBAR );
844    hFrameMinMax   = WinWindowFromID( hWndFrame, FID_MINMAX );
845    WinSetAccelTable( hab, WinLoadAccelTable( hab, _hmod, IDA_MAINACCEL ), hWndFrame );
846    hWndMenu = WinLoadMenu( hWndFrame, _hmod, IDM_MAINMENU );
847    localizeMenu( hWndMenu );
848    WinSetWindowUShort( hWndMenu, QWS_ID, FID_MENU );
849
850    // Vertical splitter and his windows - Index and Document view
851    hVertSplitter = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
852                                     WS_VISIBLE | SBS_VSPLIT,
853                                     0, 0, 0, 0, hWndFrame, HWND_TOP,
854                                     ID_SPLITTER, NULL, NULL );
855
856    indexWin = new IndexWindow( hWndFrame );
857
858    DocumentViewer::registerClass();
859
860    docViewer = new DocumentViewer( hWndFrame );
861
862    WinSendMsg( hVertSplitter, SBM_SETWINDOWS,
863                MPFROMHWND( indexWin->getHWND() ), MPFROMHWND( docViewer->getFrameHWND() ) );
864    Lucide::splitterPos = PrfQueryProfileInt( HINI_USERPROFILE, appName, splpos, Lucide::splitterPos );
865    Lucide::showIndex = PrfQueryProfileInt( HINI_USERPROFILE, appName, showind, Lucide::showIndex );
866    WinSendMsg( hVertSplitter, SBM_SETSPLITTERPOS,
867                MPFROMSHORT( Lucide::showIndex ? Lucide::splitterPos : 0 ), MPVOID );
868
869    // Horizontal splitter and its windows - Toolbar and Vertical splitter
870    // Horizontal splitter is client window
871    HWND hHorizSplitter = WinCreateWindow( hWndFrame, WC_ER_SPLITTER, "",
872                                           WS_VISIBLE | SBS_HSPLIT | SBS_SECONDFIXED,
873                                           0, 0, 0, 0, hWndFrame, HWND_TOP,
874                                           FID_CLIENT, NULL, NULL );
875    pOldSplProc = WinSubclassWindow( hHorizSplitter, splProc );
876
877    hToolBar = createToolbar( hWndFrame );
878
879    WinSendMsg( hHorizSplitter, SBM_SETWINDOWS,
880                MPFROMHWND( hVertSplitter ), MPFROMHWND( hToolBar ) );
881    // ãáâ ­®¢šâì 䚪ášà®¢ ­­ë© à §¬¥à €«ï âã«¡ à 
882    WinSendMsg( hHorizSplitter, SBM_SETFIXEDSIZE,
883                MPFROMSHORT( DEFAULT_PICTSIZE + TOOLBAR_HEIGHT_ADD ), MPVOID );
884
885    findDlg = new FindDlg( hWndFrame );
886    Lucide::checkMenus();
887    Lucide::setPageLayout( settings->layout );
888    Lucide::setZoom( settings->zoom );
889
890    // ®ª § âì ®ª­® ¯à®£à ¬¬ë
891    if ( !PMRestoreWindowPos( NULL, appName, fwp, hWndFrame,
892                              TRUE, TRUE, FALSE, FALSE, FALSE ) ) {
893        WinSetWindowPos( hWndFrame, HWND_TOP, 100, 100, 630, 400,
894                         SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ACTIVATE );
895    }
896
897    Lucide::focusDocview();
898
899    if ( argc > 1 ) {
900        Lucide::loadDocument( argv[1] );
901    }
902
903    Lucide::checkNavpane();
904
905    // Messsage loop
906    while ( WinGetMsg( hab, &qmsg, 0, 0, 0 ) ) {
907        WinDispatchMsg( hab, &qmsg );
908    }
909
910    if ( WinIsWindow( hab, hWndFrame ) )
911    {
912        char valbuf[ 3 ] = "";
913        PrfWriteProfileString( HINI_USERPROFILE, appName, splpos,
914                               itoa( Lucide::splitterPos, valbuf, 10 ) );
915        PrfWriteProfileString( HINI_USERPROFILE, appName, showind,
916                               itoa( Lucide::showIndex, valbuf, 10 ) );
917        PMStoreWindowPos( NULL, appName, fwp, hWndFrame );
918    }
919
920    WinDestroyWindow( hWndFrame );
921
922    delete docViewer;
923    delete indexWin;
924    // must be freed _before_ plugin manager
925    delete doc;
926    // must be freed _after_ document
927    delete pluginMan;
928
929    delete findDlg;
930    delete title;
931    delete settings;
932
933    WinDestroyMsgQueue( hmq );
934    WinTerminate( hab );
935    return 0;
936}
937
Note: See TracBrowser for help on using the repository browser.