home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / contrib / src / fl / updatesmgr.cpp < prev   
C/C++ Source or Header  |  2002-01-21  |  8KB  |  293 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        updatesmgr.cpp
  3. // Purpose:     cbSimpleUpdatesMgr implementation.
  4. // Author:      Aleksandras Gluchovas
  5. // Modified by:
  6. // Created:     19/10/98
  7. // RCS-ID:      $Id: updatesmgr.cpp,v 1.3 2002/01/21 22:34:42 JS Exp $
  8. // Copyright:   (c) Aleksandras Gluchovas 
  9. // Licence:     wxWindows licence
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifdef __GNUG__
  13.     #pragma implementation "updatesmgr.h"
  14. #endif
  15.  
  16. // For compilers that support precompilation, includes "wx.h".
  17. #include "wx/wxprec.h"
  18.  
  19. #ifdef __BORLANDC__
  20. #pragma hdrstop
  21. #endif
  22.  
  23. #ifndef WX_PRECOMP
  24. #include "wx/wx.h"
  25. #endif
  26.  
  27. #include "wx/fl/updatesmgr.h"
  28.  
  29. // helper function
  30.  
  31. static inline bool rect_hits_rect( const wxRect& r1, const wxRect& r2 )
  32. {
  33.     if ( ( r2.x >= r1.x && r2.x <= r1.x + r1.width ) ||
  34.          ( r1.x >= r2.x && r1.x <= r2.x + r2.width ) )
  35.  
  36.         if ( ( r2.y >= r1.y && r2.y <= r1.y + r1.height ) ||
  37.              ( r1.y >= r2.y && r1.y <= r2.y + r2.height ) )
  38.              
  39.             return 1;
  40.  
  41.     return 0;
  42. }
  43.  
  44. /***** Implementation for class cbSimpleUpdatesMgr *****/
  45.  
  46. IMPLEMENT_DYNAMIC_CLASS( cbSimpleUpdatesMgr, cbUpdatesManagerBase )
  47.  
  48. cbSimpleUpdatesMgr::cbSimpleUpdatesMgr( wxFrameLayout* pPanel )
  49.     : cbUpdatesManagerBase( pPanel )
  50. {}
  51.  
  52. bool cbSimpleUpdatesMgr::WasChanged( cbUpdateMgrData& data, wxRect& currentBounds )
  53. {
  54.     return (   data.IsDirty() ||
  55.  
  56.              ( data.mPrevBounds.x      != currentBounds.x     ||
  57.                data.mPrevBounds.y      != currentBounds.y     ||
  58.                data.mPrevBounds.width  != currentBounds.width ||
  59.                data.mPrevBounds.height != currentBounds.height  )
  60.            );
  61. }
  62.  
  63. void cbSimpleUpdatesMgr::OnStartChanges()
  64. {
  65.     // memorize states of ALL items in the layout -
  66.     // this is quite excessive, but OK for the simple 
  67.     // implementation of updates manager
  68.  
  69.     mpLayout->GetPrevClientRect() = mpLayout->GetClientRect();
  70.  
  71.     cbDockPane** panes = mpLayout->GetPanesArray();
  72.  
  73.     for( int n = 0; n != MAX_PANES; ++n )
  74.     {
  75.         cbDockPane& pane = *panes[n];
  76.         // store pane state
  77.         pane.mUMgrData.StoreItemState( pane.mBoundsInParent );
  78.         pane.mUMgrData.SetDirty( FALSE );
  79.  
  80.         for( size_t i = 0; i != pane.GetRowList().Count(); ++i )
  81.         {
  82.             cbRowInfo& row = *pane.GetRowList()[ i ];
  83.  
  84.             // store row state
  85.             row.mUMgrData.StoreItemState( row.mBoundsInParent );
  86.             row.mUMgrData.SetDirty( FALSE );
  87.  
  88.             for( size_t k = 0; k != row.mBars.Count(); ++k )
  89.             {
  90.                 cbBarInfo& bar = *row.mBars[ k ];
  91.  
  92.                 // store bar state
  93.                 bar.mUMgrData.StoreItemState( bar.mBoundsInParent );
  94.                 bar.mUMgrData.SetDirty( FALSE );
  95.             }
  96.         }
  97.     }
  98. }
  99.  
  100. void cbSimpleUpdatesMgr::OnFinishChanges()
  101. {
  102.     // nothing here, could be overriden by more sophisticated updates-managers
  103. }
  104.  
  105. void cbSimpleUpdatesMgr::OnRowWillChange( cbRowInfo* pRow, cbDockPane* pInPane )
  106. {
  107.     // -/-
  108. }
  109.  
  110. void cbSimpleUpdatesMgr::OnBarWillChange( cbBarInfo* pBar, 
  111.                                           cbRowInfo* pInRow, cbDockPane* pInPane )
  112. {
  113.     // -/-
  114. }
  115.  
  116. void cbSimpleUpdatesMgr::OnPaneMarginsWillChange( cbDockPane* pPane )
  117. {
  118.     // -/-
  119. }
  120.  
  121. void cbSimpleUpdatesMgr::OnPaneWillChange( cbDockPane* pPane )
  122. {
  123.     // -/-
  124. }
  125.  
  126. void cbSimpleUpdatesMgr::UpdateNow()
  127. {
  128.     cbDockPane** panes = mpLayout->GetPanesArray();
  129.  
  130.     wxRect& r1 = mpLayout->GetClientRect();
  131.     wxRect& r2 = mpLayout->GetPrevClientRect();
  132.  
  133.     // detect changes in client window's area
  134.  
  135.     bool clientWindowChanged = ( r1.x      != r2.x     ||
  136.                                  r1.y      != r2.y     ||
  137.                                  r1.width  != r2.width ||
  138.                                  r1.height != r2.height );
  139.  
  140.     // step #1 - detect changes in each row of each pane,
  141.     //           and repaint decorations around changed windows
  142.  
  143.     wxList mBarsToRefresh;
  144.     wxList mPanesList;
  145.  
  146.     for( int n = 0; n != MAX_PANES; ++n )
  147.     {
  148.         cbDockPane& pane = *(panes[n]);
  149.  
  150.         bool paneChanged = WasChanged( pane.mUMgrData, pane.mBoundsInParent );
  151.  
  152.         if ( paneChanged )
  153.         {
  154.             wxClientDC dc( &mpLayout->GetParentFrame() );
  155.             pane.PaintPaneBackground( dc );
  156.         }
  157.  
  158.         wxRect realBounds;
  159.  
  160.         for( size_t i = 0; i != pane.GetRowList().Count(); ++i )
  161.         {
  162.             cbRowInfo& row = *pane.GetRowList()[ i ];
  163.  
  164.             wxDC* pDc = NULL;
  165.  
  166.             bool rowChanged = FALSE;
  167.  
  168.             // FIXME:: the below should not be fixed
  169.             cbBarInfo* barsToRepaint[256];
  170.  
  171.             // number of bars, that were changed in the current row
  172.             int nBars = 0; 
  173.  
  174.             if ( WasChanged( row.mUMgrData, row.mBoundsInParent ) )
  175.             
  176.                 rowChanged = TRUE;
  177.             else
  178.                 for( size_t k = 0; k != row.mBars.Count(); ++k )
  179.  
  180.                     if ( WasChanged( row.mBars[k]->mUMgrData, 
  181.                          row.mBars[k]->mBoundsInParent ) 
  182.                        )
  183.                     
  184.                         barsToRepaint[nBars++] = row.mBars[k];
  185.  
  186.             if ( nBars || rowChanged )
  187.             {
  188.                 realBounds = row.mBoundsInParent;
  189.  
  190.                 // include 1-pixel thick shades around the row
  191.                 realBounds.x -= 1;
  192.                 realBounds.y -= 1;
  193.                 realBounds.width  += 2;
  194.                 realBounds.height += 2;
  195.  
  196.                 pDc = pane.StartDrawInArea( realBounds );
  197.             }
  198.  
  199.             if ( rowChanged )
  200.             {
  201.                 // postphone the resizing and refreshing the changed
  202.                 // bar windows
  203.  
  204.                 for( size_t k = 0; k != row.mBars.Count(); ++k )
  205.                 {
  206.                     mBarsToRefresh.Append( (wxObject*)row.mBars[k] );
  207.                     mPanesList.Append( &pane );
  208.                 }
  209.  
  210.                 // draw only their decorations now
  211.  
  212.                 pane.PaintRow( &row, *pDc );
  213.             }
  214.             else
  215.             if ( nBars != 0 )
  216.             {
  217.                 for( int i = 0; i != nBars; ++i )
  218.                 {
  219.                     // postphone the resizement and refreshing the changed
  220.                     // bar windows
  221.  
  222.                     mBarsToRefresh.Append( (wxObject*)barsToRepaint[i] );
  223.                     mPanesList.Append( &pane );
  224.                 }
  225.  
  226.                 // redraw decorations of entire row, regardless of how much
  227.                 // of the bars were changed
  228.                 pane.PaintRow( &row, *pDc );
  229.             }
  230.  
  231.             if ( pDc )
  232.         
  233.                 pane.FinishDrawInArea( realBounds );
  234.         } // end of while
  235.  
  236.         if ( paneChanged )
  237.         {
  238.             wxClientDC dc( &mpLayout->GetParentFrame() );
  239.             pane.PaintPaneDecorations( dc );
  240.         }
  241.  
  242.     } // end of for
  243.  
  244.     if ( clientWindowChanged )
  245.     {
  246.         mpLayout->PositionClientWindow();
  247.         // ptr to client-window object is "marked" as 0
  248.     }
  249.  
  250.     // step #2 - do ordered refreshing and resizing of bar window objects now
  251.  
  252.     wxNode* pNode     = mBarsToRefresh.First();
  253.     wxNode* pPaneNode = mPanesList.First();
  254.  
  255.     while( pNode )
  256.     {
  257.         cbBarInfo*  pBar  = (cbBarInfo*) pNode->Data();
  258.         cbDockPane* pPane = (cbDockPane*)pPaneNode->Data();
  259.  
  260.         pPane->SizeBar( pBar );
  261.  
  262.         pNode     = pNode->Next();
  263.         pPaneNode = pPaneNode->Next();
  264.     }
  265.  
  266.     pNode = mBarsToRefresh.First();
  267.  
  268.     while( pNode )
  269.     {
  270.         cbBarInfo* pBar = (cbBarInfo*)pNode->Data();
  271.  
  272.         if ( pBar->mpBarWnd ) 
  273.         {
  274.             pBar->mpBarWnd->Refresh();
  275.  
  276.             // FIXME::
  277.             //info.mpBarWnd->Show(FALSE);
  278.             //info.mpBarWnd->Show(TRUE);
  279.         }
  280.  
  281.         pNode  = pNode->Next();
  282.     }
  283.  
  284.     if ( clientWindowChanged )
  285.     {
  286.         // FIXME:: excessive?
  287.  
  288.         mpLayout->GetFrameClient()->Refresh();
  289.     }
  290. }
  291.  
  292.  
  293.