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

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

find/findagain bitmaps replaced (closes #71), added 'zoom in/out' toolbar button

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