Changeset 18 for trunk/Lucide


Ignore:
Timestamp:
May 7, 2006, 11:24:03 AM (15 years ago)
Author:
Eugene Romanenko
Message:

implemented continuous view (synch/asynch), text search and selection doesn't work yet in continuous view

Location:
trunk/Lucide
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Lucide/BIN/tj.cmd

    r2 r18  
    1 lucide D:\Projects\libdjvu\doc\djvu2spec.djvu
     1lucide D:\Projects\lucide\trunk\Lucide\djvu2spec.djvu
  • trunk/Lucide/BIN/tj1.cmd

    r2 r18  
    1 lucide D:\Projects\libdjvu\doc\lizard2003-navm.djvu
     1lucide D:\Projects\lucide\trunk\Lucide\lizard2003-navm.djvu
  • trunk/Lucide/SOURCE/gui/docViewer.cpp

    r17 r18  
    6464    realVscrollMax = 0;
    6565    VScrollStep = 1;
     66    WinSetRectEmpty( hab, &savedRcl );
    6667    // asynch draw
    6768    abortAsynch = false;
     
    165166        memset( links, 0, sizeof( PLuLinkMapSequence ) * totalpages );
    166167        enableAsynchDraw = doc->isAsynchRenderingSupported( ev );
     168        goToPage( 0 );
     169    }
     170}
     171
     172
     173// sets the view mode
     174void DocumentViewer::setViewMode( ViewMode mode )
     175{
     176    continuous = ( mode == Continuous );
     177    if ( doc != NULL ) {
     178        long pg = currentpage;
    167179        drawPage();
     180        if ( continuous ) {
     181            goToPage( pg );
     182        }
    168183    }
    169184}
     
    581596            DosRequestMutexSem( _this->todrawAccess, SEM_INDEFINITE_WAIT );
    582597
    583             for ( int i = 0; i < _this->drawareas->size(); i++ )
     598            for ( _this->drawareaIndex = 0;
     599                  _this->drawareaIndex < _this->drawareas->size();
     600                  _this->drawareaIndex++ )
    584601            {
    585                 PageDrawArea *pda = &(*_this->drawareas)[ i ];
     602                PageDrawArea *pda = &(*_this->drawareas)[ _this->drawareaIndex ];
    586603
    587604                LONG rclx = pda->drawrect.xRight - pda->drawrect.xLeft;
     
    603620                HPS hps = WinGetPS( _this->hWndDoc );
    604621                if ( hps != NULLHANDLE ) {
    605                     //_this->drawSelection( hps, &_this->drawRect );
    606                     //_this->drawFound( hps, &_this->drawRect );
     622                    if ( !_this->continuous )   // TODO: continuous
     623                    {
     624                        for ( int i = 0; i < _this->drawareas->size(); i++ )
     625                        {
     626                            PageDrawArea *pda = &(*_this->drawareas)[ i ];
     627
     628                            _this->drawSelection( hps, &pda->drawrect );
     629                            _this->drawFound( hps, &pda->drawrect );
     630                        }
     631                    }
    607632                    WinReleasePS( hps );
    608633                }
     634                WinSetRectEmpty( _this->hab, &_this->savedRcl );
    609635                delete _this->drawareas;
    610636                _this->drawareas = NULL;
     
    642668        rclPage.yTop = cyClient;
    643669    }
    644     RECTL rclDraw = { 0, 0, 0, 0 };
     670    RECTL rclDraw = { 0 };
    645671    if ( WinIntersectRect( hab, &rclDraw, &rcl, &rclPage ) )
    646672    {
     
    694720
    695721
     722// handles WM_PAINT if continuous asynchronous rendering used
     723void DocumentViewer::wmPaintContAsynch( HWND hwnd )
     724{
     725    RECTL rcl, rclWin, rclDraw = { 0 };
     726    HPS hps = WinBeginPaint( hwnd, 0L, &rcl );
     727    if ( hps != NULLHANDLE ) {
     728        GpiErase( hpsBuffer );
     729        BlitGraphicsBuffer( hps, hpsBuffer, &rcl );
     730        WinEndPaint( hps );
     731    }
     732
     733    /*if ( isSubrect( &savedRcl, &rcl ) && ( sVscrollInc == 0 ) && ( sHscrollInc == 0 ) ) {
     734        return;
     735    } */
     736
     737    abortAsynch = true;
     738    DosRequestMutexSem( todrawAccess, SEM_INDEFINITE_WAIT );
     739
     740    WinQueryWindowRect( hwnd, &rclWin );
     741    WinUnionRect( hab, &rcl, &rcl, &savedRcl );
     742
     743    if ( sVscrollInc > 0 ) {
     744        rcl.yTop    += sVscrollInc;
     745    } else if ( sVscrollInc < 0 ) {
     746        rcl.yBottom += sVscrollInc;
     747    }
     748    if ( sHscrollInc > 0 ) {
     749        rcl.xLeft  -= sHscrollInc;
     750    } else if ( sHscrollInc < 0 ) {
     751        rcl.xRight -= sHscrollInc;
     752    }
     753
     754    WinIntersectRect( hab, &rclDraw, &rcl, &rclWin );
     755    WinCopyRect( hab, &rcl, &rclDraw );
     756    WinCopyRect( hab, &savedRcl, &rcl );
     757
     758    delete drawareas;
     759    drawareas = foundDrawAreas( &rcl );
     760
     761    for ( int i = 0; i < drawareas->size(); i++ )
     762    {
     763        PageDrawArea *pda = &(*drawareas)[ i ];
     764
     765        // load links for page if not loaded before
     766        if ( links[ pda->pagenum ] == NULL ) {
     767            links[ pda->pagenum ] = doc->getLinkMapping( ev, pda->pagenum );
     768        }
     769
     770        pda->startpos.x = sHscrollPos + pda->drawrect.xLeft;
     771    }
     772    DosReleaseMutexSem( todrawAccess );
     773    DosPostEventSem( haveDraw );
     774
     775    determineCurrentPage();
     776}
     777
     778
    696779// handles WM_PAINT if single-page synchronous rendering used
    697780void DocumentViewer::wmPaint( HWND hwnd )
     
    707790        rclPage.yTop = cyClient;
    708791    }
    709     RECTL rclDraw = { 0, 0, 0, 0 };
     792    RECTL rclDraw = { 0 };
    710793    if ( WinIntersectRect( hab, &rclDraw, &rcl, &rclPage ) )
    711794    {
     
    773856
    774857// founds pages and it's areas to draw
     858// for continuous view only
    775859DrawAreas *DocumentViewer::foundDrawAreas( PRECTL r )
    776860{
     
    788872                PageDrawArea pda;
    789873                pda.pagenum = pg;
    790                 pda.drawrect.xLeft   = r->xLeft;
     874                pda.drawrect.xLeft   = __min( pagesizes[ pg ].x * realzoom, r->xLeft );
    791875                pda.drawrect.yBottom = __max( i - pageRest, r->yBottom );
    792                 pda.drawrect.xRight  = r->xRight;
     876                pda.drawrect.xRight  = __min( pagesizes[ pg ].x * realzoom, r->xRight );
    793877                pda.drawrect.yTop    = i;
    794878
     
    799883                foundpage = pg;
    800884                i -= pageRest;
    801                 //somPrintf( "PGSIZE: %f, (yBottom: %d, yTop: %d)  PG: %d/%f  STPOS: %f\n",
    802                 //  pagesizes[ pg ].y, pda.drawrect.yBottom, pda.drawrect.yTop,
    803                 //         pg, pageRest, pda.startpos.y );
    804885            }
    805886        }
     
    856937        }
    857938
    858         RECTL rclDraw = { __min( pagesizes[ pda->pagenum ].x * realzoom,
    859                                  pda->drawrect.xLeft ),
    860                           pda->drawrect.yBottom,
    861                           __min( pagesizes[ pda->pagenum ].x * realzoom,
    862                                  pda->drawrect.xRight ),
    863                           pda->drawrect.yTop };
    864 
    865         spos_x = sHscrollPos + rclDraw.xLeft;
    866         //spos_y = ( cyClient - rclDraw.yTop ) + ( sVscrollPos * VScrollStep );
     939        spos_x = sHscrollPos + pda->drawrect.xLeft;
     940        //spos_y = ( cyClient - pda->drawrect.yTop ) + ( sVscrollPos * VScrollStep );
    867941        spos_y = pda->startpos.y;
    868         LONG rclx = rclDraw.xRight - rclDraw.xLeft;
    869         LONG rcly = rclDraw.yTop - rclDraw.yBottom;
     942        LONG rclx = pda->drawrect.xRight - pda->drawrect.xLeft;
     943        LONG rcly = pda->drawrect.yTop - pda->drawrect.yBottom;
    870944
    871945        pixbuf = new LuPixbuf( ev, rclx, rcly );
    872         POINTL aptlPoints[4]={ rclDraw.xLeft, rclDraw.yBottom,
    873                                rclDraw.xRight-1, rclDraw.yTop-1,
     946        POINTL aptlPoints[4]={ pda->drawrect.xLeft, pda->drawrect.yBottom,
     947                               pda->drawrect.xRight-1, pda->drawrect.yTop-1,
    874948                               0, 0, rclx, rcly };
    875949
     
    886960                     aptlPoints, lRop, BBO_IGNORE );
    887961
     962        // TODO
    888963        //drawSelection( hpsBuffer, &rclDraw );
    889964        //drawFound( hpsBuffer, &rclDraw );
     
    10321107    if ( mousePressed && ( doc != NULL ) )
    10331108    {
     1109        // TODO: continuous
     1110        if ( continuous ) {
     1111            return FALSE;
     1112        }
     1113
    10341114        selectionEnd.x = xpos;
    10351115        selectionEnd.y = ypos;
     
    12221302        case WM_PAINT:
    12231303            if ( _this->enableAsynchDraw ) {
    1224                 _this->wmPaintAsynch( hwnd );
     1304                if ( _this->continuous ) {
     1305                    _this->wmPaintContAsynch( hwnd );
     1306                } else {
     1307                    _this->wmPaintAsynch( hwnd );
     1308                }
    12251309            } else {
    12261310                if ( _this->continuous ) {
  • trunk/Lucide/SOURCE/gui/docViewer.h

    r17 r18  
    55
    66#include <ludoc.xh>
     7#include "lucide.h"
    78
    89class ProgressDlg;
     
    1920typedef std::vector<PageDrawArea> DrawAreas;
    2021
    21 
    2222class DocumentViewer
    2323{
     
    2525        DocumentViewer( HAB _hab, HWND hWndFrame );
    2626        virtual ~DocumentViewer();
     27
     28        void setViewMode( ViewMode mode );
    2729
    2830        HWND getHWND() { return hWndDocFrame; }
     
    5254        void wmPaintCont( HWND hwnd );
    5355        void wmPaintAsynch( HWND hwnd );
     56        void wmPaintContAsynch( HWND hwnd );
    5457        BOOL wmMouseMove( HWND hwnd, SHORT xpos, SHORT ypos );
    5558        BOOL wmClick( HWND hwnd, SHORT xpos, SHORT ypos );
     
    107110        LuSize *pagesizes;
    108111        SHORT VScrollStep;
     112        RECTL savedRcl;
    109113
    110114        // asynch draw
  • trunk/Lucide/SOURCE/gui/lucide.cpp

    r2 r18  
    147147void Lucide::checkMenus()
    148148{
    149     // currently only "single page" mode
    150     WinSendMsg( hWndMenu, MM_SETITEMATTR,
    151                 MPFROM2SHORT( CM_SINGLEPAGE, TRUE ),
    152                 MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED ) );
    153 
    154149    // pre-set "Actual size"
    155150    setZoomChecks( CM_ACTSIZE, 0, 0 );
     
    157152    if ( doc == NULL )
    158153    {
     154        // "single page" mode by default
     155        WinSendMsg( hWndMenu, MM_SETITEMATTR,
     156                    MPFROM2SHORT( CM_SINGLEPAGE, TRUE ),
     157                    MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED ) );
     158
    159159        WinEnableMenuItem( hWndMenu, CM_SAVEAS, FALSE );
    160160        WinEnableMenuItem( hWndMenu, CM_EXPORTTOPS, FALSE );
     
    212212    WinEnableMenuItem( hWndMenu, CM_FIND, haveText );
    213213    WinSendMsg( hToolBar, TBM_ENABLEITEM, MPFROMSHORT(CM_FIND), (MPARAM)haveText );
     214
     215    WinEnableMenuItem( hWndMenu, CM_SINGLEPAGE, TRUE );
     216    WinEnableMenuItem( hWndMenu, CM_CONTINUOUS, TRUE );
    214217}
    215218
     
    234237    indexWin->setDocument( _doc );
    235238    Lucide::checkMenus();
     239}
     240
     241void Lucide::setViewMode( ViewMode mode )
     242{
     243    if ( mode == SinglePage )
     244    {
     245        WinSendMsg( hWndMenu, MM_SETITEMATTR,
     246                    MPFROM2SHORT( CM_SINGLEPAGE, TRUE ),
     247                    MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED ) );
     248        WinSendMsg( hWndMenu, MM_SETITEMATTR,
     249                    MPFROM2SHORT( CM_CONTINUOUS, TRUE ),
     250                    MPFROM2SHORT( MIA_CHECKED, FALSE ) );
     251    }
     252    else
     253    {
     254        WinSendMsg( hWndMenu, MM_SETITEMATTR,
     255                    MPFROM2SHORT( CM_SINGLEPAGE, TRUE ),
     256                    MPFROM2SHORT( MIA_CHECKED, FALSE ) );
     257        WinSendMsg( hWndMenu, MM_SETITEMATTR,
     258                    MPFROM2SHORT( CM_CONTINUOUS, TRUE ),
     259                    MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED ) );
     260    }
     261
     262    docViewer->setViewMode( mode );
    236263}
    237264
     
    387414                    return (MRESULT)FALSE;
    388415
     416                case CM_SINGLEPAGE:
     417                    Lucide::setViewMode( SinglePage );
     418                    return (MRESULT)FALSE;
     419
     420                case CM_CONTINUOUS:
     421                    Lucide::setViewMode( Continuous );
     422                    return (MRESULT)FALSE;
    389423            }
    390424        }
  • trunk/Lucide/SOURCE/gui/lucide.h

    r2 r18  
    88
    99class LuDocument;
     10
     11enum ViewMode { SinglePage, Continuous };
    1012
    1113class Lucide
     
    2123                static void setZoom( double zoom );
    2224                static void enableCopy( bool enable );
     25        static void setViewMode( ViewMode mode );
    2326};
    2427
Note: See TracChangeset for help on using the changeset viewer.