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

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

UI improvements, save files, ability to compile plugins with gcc, saveAs for djvu plugin, djvu plugin compiled with gcc, get rid of ddjvuapi.dll

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