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

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

added 'zoom mode' to zoom in/out with mouse click/ctrl+click (no toolbar button yet)

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