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

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

UI improvements, started print dialog

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