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

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

pipe commands

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