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

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

bitmap printing, preliminary postscript printing, export to PS for djvu plugin, other improvements

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