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

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

checkmenu calls cleanup

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