← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to contrib/src/fl/updatesmgr.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/src/fl/updatesmgr.cpp
 
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.6 2004/06/07 16:02:23 ABX 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* WXUNUSED(pRow), cbDockPane* WXUNUSED(pInPane) )
 
106
{
 
107
    // -/-
 
108
}
 
109
 
 
110
void cbSimpleUpdatesMgr::OnBarWillChange( cbBarInfo* WXUNUSED(pBar), 
 
111
                                          cbRowInfo* WXUNUSED(pInRow), cbDockPane* WXUNUSED(pInPane) )
 
112
{
 
113
    // -/-
 
114
}
 
115
 
 
116
void cbSimpleUpdatesMgr::OnPaneMarginsWillChange( cbDockPane* WXUNUSED(pPane) )
 
117
{
 
118
    // -/-
 
119
}
 
120
 
 
121
void cbSimpleUpdatesMgr::OnPaneWillChange( cbDockPane* WXUNUSED(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.GetFirst();
 
253
    wxNode* pPaneNode = mPanesList.GetFirst();
 
254
 
 
255
    while( pNode )
 
256
    {
 
257
        cbBarInfo*  pBar  = (cbBarInfo*) pNode->GetData();
 
258
        cbDockPane* pPane = (cbDockPane*)pPaneNode->GetData();
 
259
 
 
260
        pPane->SizeBar( pBar );
 
261
 
 
262
        pNode     = pNode->GetNext();
 
263
        pPaneNode = pPaneNode->GetNext();
 
264
    }
 
265
 
 
266
    pNode = mBarsToRefresh.GetFirst();
 
267
 
 
268
    while( pNode )
 
269
    {
 
270
        cbBarInfo* pBar = (cbBarInfo*)pNode->GetData();
 
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->GetNext();
 
282
    }
 
283
 
 
284
    if ( clientWindowChanged )
 
285
    {
 
286
        // FIXME:: excessive?
 
287
 
 
288
        mpLayout->GetFrameClient()->Refresh();
 
289
    }
 
290
}
 
291
 
 
292