utils/framelayout/src/cbstore.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        No names yet.
   3 // Purpose:     Contrib. demo
   4 // Author:      Aleksandras Gluchovas
   5 // Modified by:
   6 // Created:     27/10/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Aleksandras Gluchovas
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "cbstore.h"
  14 // #pragma interface
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25 #include "wx/wx.h"
  26 #endif
  27
  28 #include "cbstore.h"
  29
  30 /***** Implementation for class wxFrameLayoutSerializer *****/
  31
  32 IMPLEMENT_SERIALIZER_CLASS( wxFrameLayout,
  33                                                         wxFrameLayoutSerializer,
  34                                                         wxFrameLayoutSerializer::Serialize,
  35                                                         wxFrameLayoutSerializer::Initialize )
  36
  37 void wxFrameLayoutSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
  38 {
  39         // wxFrameLayout is a "kind of" wxEvtHandler - perform
  40         // serialization of the base class first
  41
  42         info.SerializeInherited( pObj, store );
  43
  44         wxFrameLayout* pLayout = (wxFrameLayout*)pObj;
  45
  46         store.XchgObjPtr( (wxObject**) &pLayout->mpFrame       );
  47         store.XchgObjPtr( (wxObject**) &pLayout->mpFrameClient );
  48
  49         for( int i = 0; i != MAX_PANES; ++i )
  50
  51                 store.XchgObjPtr( (wxObject**) &(pLayout->mPanes[i]) );
  52
  53         // plugins are serialized _after_ panes
  54
  55         store.XchgObjPtr( (wxObject**) &(pLayout->mpTopPlugin) );
  56
  57         // and the rest will follow...
  58
  59         store.XchgObjArray( pLayout->mAllBars );
  60
  61         store.XchgObjList( pLayout->mBarSpyList );
  62
  63         store.XchgObjList( pLayout->mFloatedFrames );
  64
  65         store.XchgObjPtr( (wxObject**) &(pLayout->mpUpdatesMgr) );
  66
  67         store.XchgBool( pLayout->mFloatingOn );
  68
  69         store.XchgWxPoint( pLayout->mNextFloatedWndPos );
  70
  71         store.XchgWxSize( pLayout->mFloatingPosStep );
  72
  73         store.XchgObj( (wxObject*) &pLayout->mDarkPen   );
  74         store.XchgObj( (wxObject*) &pLayout->mLightPen  );
  75         store.XchgObj( (wxObject*) &pLayout->mGrayPen   );
  76         store.XchgObj( (wxObject*) &pLayout->mBlackPen  );
  77         store.XchgObj( (wxObject*) &pLayout->mBorderPen );
  78 }
  79
  80 void wxFrameLayoutSerializer::Initialize( wxObject* pObj )
  81 {
  82         wxFrameLayout* pLayout = (wxFrameLayout*)pObj;
  83
  84         // wxFrameLayout is a "kind of" wxEvtHandler - perform
  85         // wxEvtHandler-specific initialization first
  86
  87         info.InitializeInherited( pObj );
  88
  89         //pLayout->RecalcLayout( TRUE );
  90 }
  91
  92 /***** Implementation for class wxFrameLayoutSerializer *****/
  93
  94 IMPLEMENT_SERIALIZER_CLASS( cbBarSpy,
  95                                                         cbBarSpySerializer,
  96                                                         cbBarSpySerializer::Serialize,
  97                                                         cbBarSpySerializer::Initialize )
  98
  99 void cbBarSpySerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 100 {
 101         // cbBarSpy is a "kind of" wxEvtHandler - perform
 102         // serialization of the base class first
 103
 104         info.SerializeInherited( pObj, store );
 105
 106         cbBarSpy* pSpy = (cbBarSpy*)pObj;
 107
 108         store.XchgObjPtr( (wxObject**) &(pSpy->mpLayout) );
 109         store.XchgObjPtr( (wxObject**) &(pSpy->mpBarWnd) );
 110 }
 111
 112 void cbBarSpySerializer::Initialize( wxObject* pObj )
 113 {
 114         // cbBarSpySerializer is a "kind of" wxEvtHandler - perform
 115         // wxEvtHandler-specific initialization first
 116
 117         info.InitializeInherited( pObj );
 118
 119         cbBarSpy* pSpy = (cbBarSpy*)pObj;
 120
 121         // is done by wxEventHandler's serializer already!
 122
 123         //pSpy->mpBarWnd->PushEventHandler( pSpy );
 124 }
 125
 126 /***** Implementation for class cbBarDimHandlerBaseSerializer *****/
 127
 128 IMPLEMENT_SERIALIZER_CLASS( cbBarDimHandlerBase,
 129                                                         cbBarDimHandlerBaseSerializer,
 130                                                         cbBarDimHandlerBaseSerializer::Serialize,
 131                                                         NO_CLASS_INIT )
 132
 133 void cbBarDimHandlerBaseSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 134 {
 135         cbBarDimHandlerBase* pHandler = (cbBarDimHandlerBase*)pObj;
 136
 137         store.XchgInt( pHandler->mRefCount );
 138 }
 139
 140 /***** Implementation for class cbDimInfoSerializer *****/
 141
 142 IMPLEMENT_SERIALIZER_CLASS( cbDimInfo,
 143                                                         cbDimInfoSerializer,
 144                                                         cbDimInfoSerializer::Serialize,
 145                                                         NO_CLASS_INIT )
 146
 147 void cbDimInfoSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 148 {
 149         cbDimInfo* pInfo = (cbDimInfo*)pObj;
 150
 151         int i = 0;
 152
 153         for( i = 0; i != MAX_BAR_STATES; ++i )
 154
 155                 store.XchgWxSize( pInfo->mSizes[i] );
 156
 157         for( i = 0; i != MAX_BAR_STATES; ++i )
 158
 159                 store.XchgWxRect( pInfo->mBounds[i] );
 160
 161         store.XchgInt   ( pInfo->mLRUPane  );
 162         store.XchgInt   ( pInfo->mHorizGap );
 163         store.XchgInt   ( pInfo->mVertGap  );
 164
 165         store.XchgBool  ( pInfo->mIsFixed );
 166         store.XchgObjPtr( (wxObject**) &(pInfo->mpHandler) );
 167 }
 168
 169 /***** Implementation for class cbRowInfoSerializer *****/
 170
 171 IMPLEMENT_SERIALIZER_CLASS( cbRowInfo,
 172                                                         cbRowInfoSerializer,
 173                                                         cbRowInfoSerializer::Serialize,
 174                                                         NO_CLASS_INIT )
 175
 176 void cbRowInfoSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 177 {
 178         cbRowInfo* pInfo = (cbRowInfo*)pObj;
 179
 180         store.XchgObjArray( pInfo->mBars );
 181
 182         store.XchgLongArray( pInfo->mSavedRatios );
 183
 184         store.XchgObjPtr( (wxObject**) &pInfo->mpNext );
 185         store.XchgObjPtr( (wxObject**) &pInfo->mpPrev );
 186         store.XchgObjPtr( (wxObject**) &pInfo->mpExpandedBar );
 187
 188         store.XchgBool  ( pInfo->mHasUpperHandle   );
 189         store.XchgBool  ( pInfo->mHasLowerHandle   );
 190         store.XchgBool  ( pInfo->mHasOnlyFixedBars );
 191         store.XchgInt   ( pInfo->mNotFixedBarsCnt  );
 192
 193         // other properties of the row are transient, since
 194         // they are reclaculated each time the frame is resized/activated
 195 }
 196
 197 /***** Implementation for class cbBarInfoSerializer *****/
 198
 199 IMPLEMENT_SERIALIZER_CLASS( cbBarInfo,
 200                                                         cbBarInfoSerializer,
 201                                                         cbBarInfoSerializer::Serialize,
 202                                                         NO_CLASS_INIT )
 203
 204 void cbBarInfoSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 205 {
 206         cbBarInfo* pInfo = (cbBarInfo*)pObj;
 207
 208         store.XchgWxStr ( pInfo->mName );
 209
 210         store.XchgWxRect( pInfo->mBounds );
 211
 212         store.XchgObjPtr( (wxObject**) &(pInfo->mpRow) );
 213
 214         store.XchgBool  ( pInfo->mHasLeftHandle  );
 215         store.XchgBool  ( pInfo->mHasRightHandle );
 216
 217         store.XchgObj   ( (wxObject*) &(pInfo->mDimInfo ) );
 218
 219         store.XchgInt   ( pInfo->mState     );
 220         store.XchgInt   ( pInfo->mAlignment );
 221         store.XchgInt   ( pInfo->mRowNo     );
 222
 223         store.XchgObjPtr( (wxObject**) &(pInfo->mpBarWnd) );
 224
 225         store.XchgDouble( pInfo->mLenRatio );
 226
 227         store.XchgWxPoint( pInfo->mPosIfFloated );
 228
 229         store.XchgObjPtr( (wxObject**) &(pInfo->mpNext) );
 230         store.XchgObjPtr( (wxObject**) &(pInfo->mpPrev) );
 231
 232         // other properties of the bar are transient, since
 233         // they are reclaculated each time the frame is resized/activated
 234 }
 235
 236 /***** Implementation for class cbCommonPanePropertiesSerializer *****/
 237
 238 IMPLEMENT_SERIALIZER_CLASS( cbCommonPaneProperties,
 239                                                         cbCommonPanePropertiesSerializer,
 240                                                         cbCommonPanePropertiesSerializer::Serialize,
 241                                                         NO_CLASS_INIT )
 242
 243 void cbCommonPanePropertiesSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 244 {
 245         cbCommonPaneProperties* pProps = (cbCommonPaneProperties*)pObj;
 246
 247         store.XchgBool ( pProps->mRealTimeUpdatesOn     );
 248         store.XchgBool ( pProps->mOutOfPaneDragOn       );
 249         store.XchgBool ( pProps->mExactDockPredictionOn );
 250         store.XchgBool ( pProps->mNonDestructFirctionOn );
 251
 252         store.XchgBool ( pProps->mShow3DPaneBorderOn );
 253
 254         store.XchgBool ( pProps->mBarFloatingOn      );
 255         store.XchgBool ( pProps->mRowProportionsOn   );
 256         store.XchgBool ( pProps->mColProportionsOn   );
 257         store.XchgBool ( pProps->mBarCollapseIconsOn );
 258         store.XchgBool ( pProps->mBarDragHintsOn     );
 259
 260         store.XchgWxSize( pProps->mMinCBarDim );
 261
 262         store.XchgInt( pProps->mResizeHandleSize );
 263 }
 264
 265 /***** Implementation for class *****/
 266
 267 IMPLEMENT_SERIALIZER_CLASS( cbDockPane,
 268                                                         cbDockPaneSerializer,
 269                                                         cbDockPaneSerializer::Serialize,
 270                                                         NO_CLASS_INIT )
 271
 272 void cbDockPaneSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 273 {
 274         cbDockPane* pPane = (cbDockPane*)pObj;
 275
 276         store.XchgObj( (wxObject*) &(pPane->mProps) );
 277
 278         store.XchgInt( pPane->mLeftMargin   );
 279         store.XchgInt( pPane->mRightMargin  );
 280         store.XchgInt( pPane->mTopMargin    );
 281         store.XchgInt( pPane->mBottomMargin );
 282
 283         store.XchgInt( pPane->mAlignment );
 284
 285         store.XchgObjArray( pPane->mRows );
 286         store.XchgObjPtr  ( (wxObject**) &(pPane->mpLayout) );
 287 }
 288
 289 /***** Implementation for class cbUpdatesManagerBaseSerializer *****/
 290
 291 IMPLEMENT_SERIALIZER_CLASS( cbUpdatesManagerBase,
 292                                                         cbUpdatesManagerBaseSerializer,
 293                                                         cbUpdatesManagerBaseSerializer::Serialize,
 294                                                         NO_CLASS_INIT )
 295
 296 void cbUpdatesManagerBaseSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 297 {
 298         cbUpdatesManagerBase* pMgr = (cbUpdatesManagerBase*)pObj;
 299
 300         // only back-reference to layout "engine"
 301         store.XchgObjPtr( (wxObject**) &(pMgr->mpLayout) );
 302 }
 303
 304 /***** Implementation for class cbPluginBaseSerializer *****/
 305
 306 IMPLEMENT_SERIALIZER_CLASS( cbPluginBase,
 307                                                         cbPluginBaseSerializer,
 308                                                         cbPluginBaseSerializer::Serialize,
 309                                                         cbPluginBaseSerializer::Initialize )
 310
 311 void cbPluginBaseSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 312 {
 313         // plugin is "a kind" of wxEvtHandler - perform
 314         // serialization of the base class first
 315
 316         info.SerializeInherited( pObj, store );
 317
 318         cbPluginBase* pPlugin = (cbPluginBase*)pObj;
 319
 320         store.XchgObjPtr( (wxObject**) &(pPlugin->mpLayout) );
 321
 322         store.XchgInt( pPlugin->mPaneMask );
 323 }
 324
 325 void cbPluginBaseSerializer::Initialize( wxObject* pObj )
 326 {
 327         // plugins need extra-initialization, after they are
 328         // attached to the frame-layout and pane mask is set
 329
 330         ( (cbPluginBase*)pObj )->OnInitPlugin();
 331 }
 332
 333 /***** Implementation for class cbRowDragPluginSerializer *****/
 334
 335 IMPLEMENT_SERIALIZER_CLASS( cbRowDragPlugin,
 336                                                         cbRowDragPluginSerializer,
 337                                                         cbRowDragPluginSerializer::Serialize,
 338                                                         cbRowDragPluginSerializer::Initialize )
 339
 340 void cbRowDragPluginSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 341 {
 342         // plugin is "a kind" of cbPluginBaseSerializer - perform
 343         // serialization of the base class first
 344
 345         info.SerializeInherited( pObj, store );
 346
 347         cbRowDragPlugin* pPlugin = (cbRowDragPlugin*)pObj;
 348
 349         store.XchgInt( pPlugin->mSvTopMargin );
 350         store.XchgInt( pPlugin->mSvBottomMargin );
 351         store.XchgInt( pPlugin->mSvLeftMargin );
 352         store.XchgInt( pPlugin->mSvRightMargin );
 353
 354         store.XchgObjList( pPlugin->mHiddenBars );
 355 }
 356
 357 void cbRowDragPluginSerializer::Initialize( wxObject* pObj )
 358 {
 359         // plugins need extra-initialization, after they are
 360         // attached to the frame-layout and pane mask is set
 361
 362         ( (cbPluginBase*)pObj )->OnInitPlugin();
 363 }
 364
 365 /***** Implementation for class cbHiddenBarInfoSerializer *****/
 366
 367 IMPLEMENT_SERIALIZER_CLASS( cbHiddenBarInfo,
 368                                                         cbHiddenBarInfoSerializer,
 369                                                         cbHiddenBarInfoSerializer::Serialize,
 370                                                         NO_CLASS_INIT )
 371
 372 void cbHiddenBarInfoSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 373 {
 374         cbHiddenBarInfo* pInfo = (cbHiddenBarInfo*)pObj;
 375
 376         store.XchgObjPtr( (wxObject**) &(pInfo->mpBar) );
 377         store.XchgInt( pInfo->mRowNo );
 378         store.XchgInt( pInfo->mIconNo );
 379         store.XchgInt( pInfo->mAlignment );
 380 }
 381
 382 /***** Implementation for class cbFloatedBarWindowSerializer *****/
 383
 384 IMPLEMENT_SERIALIZER_CLASS( cbFloatedBarWindow,
 385                                                         cbFloatedBarWindowSerializer,
 386                                                         cbFloatedBarWindowSerializer::Serialize,
 387                                                         cbFloatedBarWindowSerializer::Initialize )
 388
 389 static wxString __gTmpFrameTitle;
 390
 391 void cbFloatedBarWindowSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 392 {
 393         cbFloatedBarWindow* pWnd = (cbFloatedBarWindow*)pObj;
 394
 395         if ( store.IsLoading() == FALSE )
 396
 397                 __gTmpFrameTitle = pWnd->GetTitle();
 398
 399         store.XchgWxStr( __gTmpFrameTitle );
 400
 401         // cbFloatedBarWindow is "a kind" of wxWindow - perform
 402         // serialization of the base class first
 403
 404         wxWindowSerializer::DoSerialize( pObj, store,
 405                                                                         (wndCreationFn)cbFloatedBarWindowSerializer::CreateFloatedBarWindowFn );
 406
 407         store.XchgObjPtr( (wxObject**) &(pWnd->mpBar)       );
 408         store.XchgObjPtr( (wxObject**) &(pWnd->mpLayout)    );
 409         store.XchgObjPtr( (wxObject**) &(pWnd->mpClientWnd) );
 410 }
 411
 412 void cbFloatedBarWindowSerializer::CreateFloatedBarWindowFn( cbFloatedBarWindow* fbar, wxWindow* parent, const wxWindowID id,
 413                                                                                                                          const wxPoint& pos, const wxSize& size, long style ,
 414                                                                                                                  const wxString& name )
 415 {
 416         fbar->Create( parent, id, __gTmpFrameTitle, pos, size, style );
 417 }
 418
 419 void cbFloatedBarWindowSerializer::Initialize( wxObject* pObj )
 420 {
 421         // FOR NOW:: nothing
 422 }
 423
 424 /***** Implementation for class wxNewBitmapButtonSerializer *****/
 425
 426 IMPLEMENT_SERIALIZER_CLASS( wxNewBitmapButton,
 427                                                         wxNewBitmapButtonSerializer,
 428                                                         wxNewBitmapButtonSerializer::Serialize,
 429                                                         wxNewBitmapButtonSerializer::Initialize )
 430
 431 void wxNewBitmapButtonSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 432 {
 433         wxNewBitmapButton* pBtn = (wxNewBitmapButton*)pObj;
 434
 435         store.XchgInt ( pBtn->mTextToLabelGap );
 436         store.XchgInt ( pBtn->mMarginX );
 437         store.XchgInt ( pBtn->mMarginY );
 438         store.XchgInt ( pBtn->mTextAlignment );
 439         store.XchgBool( pBtn->mIsFlat );
 440         store.XchgBool( pBtn->mIsSticky );
 441
 442         store.XchgWxStr( pBtn->mLabelText );
 443         store.XchgWxStr( pBtn->mImageFileName );
 444         store.XchgInt  ( pBtn->mImageFileType );
 445
 446         store.XchgInt( pBtn->mFiredEventType );
 447
 448         // cbFloatedBarWindow is "a kind" of wxWindow - perform
 449         // serialization of the base class
 450
 451         wxWindowSerializer::DoSerialize( pObj, store,
 452                                                                         (wndCreationFn)wxNewBitmapButtonSerializer::CreateNewBmpBtnWindowFn );
 453 }
 454
 455 void wxNewBitmapButtonSerializer::CreateNewBmpBtnWindowFn( wxNewBitmapButton* btn, wxWindow* parent, const wxWindowID id,
 456                                                                                                                    const wxPoint& pos, const wxSize& size, long style ,
 457                                                                                                                const wxString& name )
 458 {
 459         btn->Create( parent, id, pos, size, style, name );
 460
 461         //btn->Reshape();
 462         btn->mIsCreated = FALSE;
 463         btn->Reshape();
 464 }
 465
 466 void wxNewBitmapButtonSerializer::Initialize( wxObject* pObj )
 467 {
 468         // FOR NOW:: nothing
 469         wxNewBitmapButton* pBtn = (wxNewBitmapButton*)pObj;
 470
 471         //pBtn->Reshape();
 472 }
 473
 474 /***** Implementation for class wxDynamicToolBarSerializer *****/
 475
 476 IMPLEMENT_SERIALIZER_CLASS( wxDynamicToolBar,
 477                                                         wxDynamicToolBarSerializer,
 478                                                         wxDynamicToolBarSerializer::Serialize,
 479                                                         wxDynamicToolBarSerializer::Initialize )
 480
 481 void wxDynamicToolBarSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 482 {
 483         // cbFloatedBarWindow is "a kind" of wxWindow - perform
 484         // serialization of the base class first
 485
 486         wxWindowSerializer::DoSerialize( pObj, store,
 487                                                                         (wndCreationFn)wxDynamicToolBarSerializer::CreateDynTBarWindowFn );
 488
 489         wxDynamicToolBar* pTBar = (wxDynamicToolBar*)pObj;
 490
 491         store.XchgObjArray( pTBar->mTools );
 492 }
 493
 494 void wxDynamicToolBarSerializer::CreateDynTBarWindowFn( wxDynamicToolBar* tbar, wxWindow* parent, const wxWindowID id,
 495                                                                                                                 const wxPoint& pos, const wxSize& size, long style ,
 496                                                                                                             const wxString& name )
 497 {
 498         tbar->Create( parent, id, pos, size, style );
 499 }
 500
 501 void wxDynamicToolBarSerializer::Initialize( wxObject* pObj )
 502 {
 503         // FOR NOW:: nothing
 504 }
 505
 506 /***** Implementation for class wxDynToolInfoSerializer *****/
 507
 508 IMPLEMENT_SERIALIZER_CLASS( wxDynToolInfo,
 509                                                         wxDynToolInfoSerializer,
 510                                                         wxDynToolInfoSerializer::Serialize,
 511                                                         NO_CLASS_INIT )
 512
 513 void wxDynToolInfoSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 514 {
 515         // cbFloatedBarWindow is "a kind" of wxWindow - perform
 516         // serialization of the base class first
 517
 518         wxDynToolInfo* pInfo = (wxDynToolInfo*)pObj;
 519
 520         store.XchgWxRect( pInfo->mRect );
 521         store.XchgBool  ( pInfo->mIsSeparator );
 522
 523         store.XchgObjPtr( (wxObject**) &pInfo->mpToolWnd );
 524         store.XchgInt   ( pInfo->mIndex );
 525         store.XchgWxSize( pInfo->mRealSize );
 526 }
 527
 528 #include "objstore.h"     // tabbed window is serialiable
 529
 530 /***** Implementation for class wxTabbedWindowSerializer ****/
 531
 532 IMPLEMENT_SERIALIZER_CLASS( wxTabbedWindow,
 533                                                         wxTabbedWindowSerializer,
 534                                                         wxTabbedWindowSerializer::Serialize,
 535                                                         wxTabbedWindowSerializer::Initialize)
 536
 537 void wxTabbedWindowSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 538 {
 539         wxTabbedWindow* pWnd = (wxTabbedWindow*)pObj;
 540
 541         // we're kind of window - serialize it first
 542
 543         if ( store.IsLoading() )
 544
 545                 // FOR NOW::workaround for the mistery
 546
 547                 pWnd->mpTabScroll = (wxScrollBar*)(-1);
 548
 549         wxWindowSerializer::DoSerialize( pObj, store,
 550                                                                         (wndCreationFn)wxWindowSerializer::CreateWindowFn,
 551                                                                         FALSE );
 552
 553         store.XchgObjList( pWnd->mTabs );
 554
 555         store.XchgInt( pWnd->mActiveTab   );
 556         store.XchgInt( pWnd->mTitleHeight );
 557         store.XchgInt( pWnd->mLayoutType  );
 558         store.XchgInt( pWnd->mTitleHeight );
 559
 560         store.XchgObj( (wxObject*) &(pWnd->mWhitePen) );
 561         store.XchgObj( (wxObject*) &(pWnd->mGrayPen)  );
 562         store.XchgObj( (wxObject*) &(pWnd->mDarkPen)  );
 563         store.XchgObj( (wxObject*) &(pWnd->mBlackPen) );
 564
 565         store.XchgObjPtr( (wxObject**) &(pWnd->mpTabScroll  ) );
 566         store.XchgObjPtr( (wxObject**) &(pWnd->mpHorizScroll) );
 567         store.XchgObjPtr( (wxObject**) &(pWnd->mpVertScroll ) );
 568
 569         store.XchgInt( pWnd->mVertGap );
 570         store.XchgInt( pWnd->mHorizGap );
 571         store.XchgInt( pWnd->mTitleVertGap );
 572         store.XchgInt( pWnd->mTitleHorizGap );
 573         store.XchgInt( pWnd->mImageTextGap );
 574         store.XchgInt( pWnd->mFirstTitleGap );
 575         store.XchgInt( pWnd->mBorderOnlyWidth );
 576 }
 577
 578 void wxTabbedWindowSerializer::Initialize( wxObject* pObj )
 579 {
 580         wxTabbedWindow* pWnd = (wxTabbedWindow*)pObj;
 581
 582         pWnd->RecalcLayout(TRUE);
 583 }
 584
 585 /***** Implementation for class twTabInfoSerializer ****/
 586
 587 IMPLEMENT_SERIALIZER_CLASS( twTabInfo,
 588                                                         twTabInfoSerializer,
 589                                                         twTabInfoSerializer::Serialize,
 590                                                         NO_CLASS_INIT )
 591
 592 void twTabInfoSerializer::Serialize( wxObject* pObj, wxObjectStorage& store )
 593 {
 594         twTabInfo* pInfo = (twTabInfo*)pObj;
 595
 596         store.XchgObjPtr( (wxObject**) &(pInfo->mpContent) );
 597
 598         // NOTE:: wxSize is NOT a dynamic class unfortunately ...
 599
 600         store.XchgWxSize( pInfo->mDims );
 601
 602         store.XchgWxStr ( pInfo->mText );
 603         store.XchgWxStr( pInfo->mImageFile );
 604
 605         store.XchgLong( pInfo->mImageType );
 606
 607         if ( store.IsLoading() && wxFileExists( pInfo->mImageFile ) )
 608
 609                  pInfo->mBitMap.LoadFile(  pInfo->mImageFile, pInfo->mImageType );
 610 }
 611