samples/propgrid/tests.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/propgrid/tests.cpp
   3 // Purpose:     wxPropertyGrid tests
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2007-05-16
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/wx.h"
  20 #endif
  21
  22 #include <wx/propgrid/propgrid.h>
  23 #include <wx/propgrid/advprops.h>
  24 #include <wx/propgrid/manager.h>
  25
  26 #include "propgrid.h"
  27 #include "sampleprops.h"
  28
  29
  30 // -----------------------------------------------------------------------
  31 // wxTestCustomFlagsProperty
  32 // -----------------------------------------------------------------------
  33
  34 //
  35 // Test customizing wxColourProperty via subclassing
  36 //
  37 // * Includes custom colour entry.
  38 // * Includes extra custom entry.
  39 //
  40 class MyColourProperty : public wxColourProperty
  41 {
  42 public:
  43     MyColourProperty( const wxString& label = wxPG_LABEL,
  44                        const wxString& name = wxPG_LABEL,
  45                        const wxColour& value = *wxWHITE )
  46         : wxColourProperty(label, name, value)
  47     {
  48         wxPGChoices colours;
  49         colours.Add(wxT("White"));
  50         colours.Add(wxT("Black"));
  51         colours.Add(wxT("Red"));
  52         colours.Add(wxT("Green"));
  53         colours.Add(wxT("Blue"));
  54         colours.Add(wxT("Custom"));
  55         colours.Add(wxT("None"));
  56         m_choices = colours;
  57         SetIndex(0);
  58         wxVariant variant;
  59         variant << value;
  60         SetValue(variant);
  61     }
  62
  63     virtual ~MyColourProperty()
  64     {
  65     }
  66
  67     virtual wxColour GetColour( int index ) const
  68     {
  69         switch (index)
  70         {
  71             case 0: return *wxWHITE;
  72             case 1: return *wxBLACK;
  73             case 2: return *wxRED;
  74             case 3: return *wxGREEN;
  75             case 4: return *wxBLUE;
  76             case 5:
  77                 // Return current colour for the custom entry
  78                 wxColour col;
  79                 if ( GetIndex() == GetCustomColourIndex() )
  80                 {
  81                     if ( m_value.IsNull() )
  82                         return col;
  83                     col << m_value;
  84                     return col;
  85                 }
  86                 return *wxWHITE;
  87         };
  88         return wxColour();
  89     }
  90
  91     virtual wxString ColourToString( const wxColour& col, int index ) const
  92     {
  93         if ( index == (int)(m_choices.GetCount()-1) )
  94             return wxT("");
  95
  96         return wxColourProperty::ColourToString(col, index);
  97     }
  98
  99     virtual int GetCustomColourIndex() const
 100     {
 101         return m_choices.GetCount()-2;
 102     }
 103 };
 104
 105
 106 void FormMain::AddTestProperties( wxPropertyGridPage* pg )
 107 {
 108     pg->Append( new MyColourProperty(wxT("CustomColourProperty"), wxPG_LABEL, *wxGREEN) );
 109     pg->GetProperty(wxT("CustomColourProperty"))->SetAutoUnspecified(true);
 110     pg->SetPropertyEditor( wxT("CustomColourProperty"), wxPGEditor_ComboBox );
 111
 112     pg->SetPropertyHelpString(wxT("CustomColourProperty"),
 113         wxT("This is a MyColourProperty from the sample app. ")
 114         wxT("It is built by subclassing wxColourProperty."));
 115 }
 116
 117 // -----------------------------------------------------------------------
 118
 119 void FormMain::OnDumpList( wxCommandEvent& WXUNUSED(event) )
 120 {
 121     wxVariant values = m_pPropGridManager->GetPropertyValues(wxT("list"), wxNullProperty, wxPG_INC_ATTRIBUTES);
 122     wxString text = wxT("This only tests that wxVariant related routines do not crash.");
 123     wxString t;
 124
 125     wxDialog* dlg = new wxDialog(this,-1,wxT("wxVariant Test"),
 126         wxDefaultPosition,wxDefaultSize,wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER);
 127
 128     unsigned int i;
 129     for ( i = 0; i < (unsigned int)values.GetCount(); i++ )
 130     {
 131         wxVariant& v = values[i];
 132
 133         wxString strValue = v.GetString();
 134
 135 #if wxCHECK_VERSION(2,8,0)
 136         if ( v.GetName().EndsWith(wxT("@attr")) )
 137 #else
 138         if ( v.GetName().Right(5) == wxT("@attr") )
 139 #endif
 140         {
 141             text += wxString::Format(wxT("Attributes:\n"));
 142
 143             unsigned int n;
 144             for ( n = 0; n < (unsigned int)v.GetCount(); n++ )
 145             {
 146                 wxVariant& a = v[n];
 147
 148                 t.Printf(wxT("  atribute %i: name=\"%s\"  (type=\"%s\"  value=\"%s\")\n"),(int)n,
 149                     a.GetName().c_str(),a.GetType().c_str(),a.GetString().c_str());
 150                 text += t;
 151             }
 152         }
 153         else
 154         {
 155             t.Printf(wxT("%i: name=\"%s\"  type=\"%s\"  value=\"%s\"\n"),(int)i,
 156                 v.GetName().c_str(),v.GetType().c_str(),strValue.c_str());
 157             text += t;
 158         }
 159     }
 160
 161     // multi-line text editor dialog
 162     const int spacing = 8;
 163     wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
 164     wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
 165     wxTextCtrl* ed = new wxTextCtrl(dlg, 11, text,
 166                                     wxDefaultPosition, wxDefaultSize,
 167                                     wxTE_MULTILINE);
 168     rowsizer->Add( ed, 1, wxEXPAND|wxALL, spacing );
 169     topsizer->Add( rowsizer, 1, wxEXPAND, 0 );
 170     rowsizer = new wxBoxSizer( wxHORIZONTAL );
 171     const int butSzFlags =
 172         wxALIGN_CENTRE_HORIZONTAL|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
 173     rowsizer->Add( new wxButton(dlg,wxID_OK,wxT("Ok")),
 174         0, butSzFlags, spacing );
 175     topsizer->Add( rowsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL, 0 );
 176
 177     dlg->SetSizer( topsizer );
 178     topsizer->SetSizeHints( dlg );
 179
 180     dlg->SetSize(400,300);
 181     dlg->Centre();
 182     dlg->ShowModal();
 183 }
 184
 185 // -----------------------------------------------------------------------
 186
 187 class TestRunner
 188 {
 189 public:
 190
 191     TestRunner( const wxString& name, wxPropertyGridManager* man, wxTextCtrl* ed, wxArrayString* errorMessages )
 192     {
 193         m_name = name;
 194         m_man = man;
 195         m_ed = ed;
 196         m_errorMessages = errorMessages;
 197 #ifdef __WXDEBUG__
 198         m_preWarnings = wxPGGlobalVars->m_warnings;
 199 #endif
 200
 201         if ( name != wxT("none") )
 202             Msg(name+wxT("\n"));
 203     }
 204
 205     ~TestRunner()
 206     {
 207 #ifdef __WXDEBUG__
 208         int warningsOccurred = wxPGGlobalVars->m_warnings - m_preWarnings;
 209         if ( warningsOccurred )
 210         {
 211             wxString s = wxString::Format(wxT("%i warnings occurred during test '%s'"), warningsOccurred, m_name.c_str());
 212             m_errorMessages->push_back(s);
 213             Msg(s);
 214         }
 215 #endif
 216     }
 217
 218     void Msg( const wxString& text )
 219     {
 220         if ( m_ed )
 221         {
 222             m_ed->AppendText(text);
 223             m_ed->AppendText(wxT("\n"));
 224         }
 225         wxLogDebug(text);
 226     }
 227
 228 protected:
 229     wxPropertyGridManager* m_man;
 230     wxTextCtrl* m_ed;
 231     wxArrayString* m_errorMessages;
 232     wxString m_name;
 233 #ifdef __WXDEBUG__
 234     int m_preWarnings;
 235 #endif
 236 };
 237
 238
 239 #define RT_START_TEST(TESTNAME) \
 240     TestRunner tr(wxT(#TESTNAME), pgman, ed, &errorMessages);
 241
 242 #define RT_MSG(S) \
 243     tr.Msg(S);
 244
 245 #define RT_FAILURE() \
 246     { \
 247         wxString s1 = wxString::Format(wxT("Test failure in tests.cpp, line %i."),__LINE__-1); \
 248         errorMessages.push_back(s1); \
 249         wxLogDebug(s1); \
 250         failures++; \
 251     }
 252
 253 #define RT_ASSERT(COND) \
 254     if (!(COND)) \
 255         RT_FAILURE()
 256
 257 #define RT_FAILURE_MSG(MSG) \
 258     { \
 259         wxString s1 = wxString::Format(wxT("Test failure in tests.cpp, line %i."),__LINE__-1); \
 260         errorMessages.push_back(s1); \
 261         wxLogDebug(s1); \
 262         wxString s2 = wxString::Format(wxT("Message: %s"),MSG); \
 263         errorMessages.push_back(s2); \
 264         wxLogDebug(s2); \
 265         failures++; \
 266     }
 267
 268 #define RT_VALIDATE_VIRTUAL_HEIGHT(PROPS, EXTRATEXT) \
 269     { \
 270         unsigned int h1_ = PROPS->GetVirtualHeight(); \
 271         unsigned int h2_ = PROPS->GetActualVirtualHeight(); \
 272         if ( h1_ != h2_ ) \
 273         { \
 274             wxString s_ = wxString::Format(wxT("VirtualHeight = %i, should be %i (%s)"), h1_, h2_, EXTRATEXT.c_str()); \
 275             RT_FAILURE_MSG(s_.c_str()); \
 276             _failed_ = true; \
 277         } \
 278         else \
 279         { \
 280             _failed_ = false; \
 281         } \
 282     }
 283
 284
 285 int gpiro_cmpfunc(const void* a, const void* b)
 286 {
 287     const wxPGProperty* p1 = (const wxPGProperty*) a;
 288     const wxPGProperty* p2 = (const wxPGProperty*) b;
 289     return (int) (((size_t)p1->GetClientData()) - ((size_t)p2->GetClientData()));
 290 }
 291
 292 wxArrayPGProperty GetPropertiesInRandomOrder( wxPropertyGridInterface* props, int iterationFlags = wxPG_ITERATE_ALL )
 293 {
 294     wxArrayPGProperty arr;
 295
 296     wxPropertyGridIterator it;
 297
 298     for ( it = props->GetIterator(iterationFlags);
 299           !it.AtEnd();
 300           it++ )
 301     {
 302         wxPGProperty* p = *it;
 303         size_t randomNumber = rand();
 304         p->SetClientData(reinterpret_cast<void*>(randomNumber));
 305         arr.push_back(p);
 306     }
 307
 308     wxPGProperty** firstEntry = &arr[0];
 309     qsort(firstEntry, arr.size(), sizeof(wxPGProperty*), gpiro_cmpfunc);
 310
 311     return arr;
 312 }
 313
 314 // Callback for testing property sorting
 315 int MyPropertySortFunction(wxPropertyGrid* WXUNUSED(propGrid),
 316                            wxPGProperty* p1,
 317                            wxPGProperty* p2)
 318 {
 319     // Reverse alphabetical order
 320     return p2->GetLabel().CmpNoCase( p1->GetBaseName() );
 321 }
 322
 323 bool FormMain::RunTests( bool fullTest, bool interactive )
 324 {
 325     wxString t;
 326
 327     wxPropertyGridManager* pgman = m_pPropGridManager;
 328     wxPropertyGrid* pg;
 329
 330     size_t i;
 331
 332     pgman->ClearSelection();
 333
 334     int failures = 0;
 335     bool _failed_ = false;
 336     wxArrayString errorMessages;
 337     wxDialog* dlg = NULL;
 338
 339     dlg = new wxDialog(this,-1,wxT("wxPropertyGrid Regression Tests"),
 340         wxDefaultPosition,wxDefaultSize,wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER);
 341
 342     // multi-line text editor dialog
 343     const int spacing = 8;
 344     wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
 345     wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
 346     wxTextCtrl* ed = new wxTextCtrl(dlg, 11, wxEmptyString,
 347                                     wxDefaultPosition, wxDefaultSize,
 348                                     wxTE_MULTILINE);
 349     rowsizer->Add( ed, 1, wxEXPAND|wxALL, spacing );
 350     topsizer->Add( rowsizer, 1, wxEXPAND, 0 );
 351     rowsizer = new wxBoxSizer( wxHORIZONTAL );
 352     const int butSzFlags =
 353         wxALIGN_CENTRE_HORIZONTAL|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
 354     rowsizer->Add( new wxButton(dlg,wxID_OK,wxT("Ok")),
 355         0, butSzFlags, spacing );
 356     topsizer->Add( rowsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL, 0 );
 357
 358     dlg->SetSizer( topsizer );
 359     topsizer->SetSizeHints( dlg );
 360
 361     dlg->SetSize(400,300);
 362     dlg->Move(wxSystemSettings::GetMetric(wxSYS_SCREEN_X)-dlg->GetSize().x,
 363               wxSystemSettings::GetMetric(wxSYS_SCREEN_Y)-dlg->GetSize().y);
 364     dlg->Show();
 365
 366     {
 367         //
 368         // Basic iterator tests
 369         RT_START_TEST(GetIterator)
 370
 371         wxPGVIterator it;
 372         int count;
 373
 374         count = 0;
 375         for ( it = pgman->GetVIterator(wxPG_ITERATE_PROPERTIES);
 376               !it.AtEnd();
 377               it.Next() )
 378         {
 379             wxPGProperty* p = it.GetProperty();
 380             if ( p->IsCategory() )
 381                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is a category (non-private child property expected)"),p->GetLabel().c_str()).c_str())
 382             else if ( p->GetParent()->HasFlag(wxPG_PROP_AGGREGATE) )
 383                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is a private child (non-private child property expected)"),p->GetLabel().c_str()).c_str())
 384             count++;
 385         }
 386
 387         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_PROPERTIES) -> %i entries"), count));
 388
 389         count = 0;
 390         for ( it = pgman->GetVIterator(wxPG_ITERATE_CATEGORIES);
 391               !it.AtEnd();
 392               it.Next() )
 393         {
 394             wxPGProperty* p = it.GetProperty();
 395             if ( !p->IsCategory() )
 396                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is not a category (only category was expected)"),p->GetLabel().c_str()).c_str())
 397             count++;
 398         }
 399
 400         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_CATEGORIES) -> %i entries"), count));
 401
 402         count = 0;
 403         for ( it = pgman->GetVIterator(wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_CATEGORIES);
 404               !it.AtEnd();
 405               it.Next() )
 406         {
 407             wxPGProperty* p = it.GetProperty();
 408             if ( p->GetParent()->HasFlag(wxPG_PROP_AGGREGATE) )
 409                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is a private child (non-private child property or category expected)"),p->GetLabel().c_str()).c_str())
 410             count++;
 411         }
 412
 413         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_CATEGORIES) -> %i entries"), count));
 414
 415         count = 0;
 416         for ( it = pgman->GetVIterator(wxPG_ITERATE_VISIBLE);
 417               !it.AtEnd();
 418               it.Next() )
 419         {
 420             wxPGProperty* p = it.GetProperty();
 421             if ( (p->GetParent() != p->GetParentState()->DoGetRoot() && !p->GetParent()->IsExpanded()) )
 422                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' had collapsed parent (only visible properties expected)"),p->GetLabel().c_str()).c_str())
 423             else if ( p->HasFlag(wxPG_PROP_HIDDEN) )
 424                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' was hidden (only visible properties expected)"),p->GetLabel().c_str()).c_str())
 425             count++;
 426         }
 427
 428         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_VISIBLE) -> %i entries"), count));
 429     }
 430
 431     if ( fullTest )
 432     {
 433         // Test that setting focus to properties does not crash things
 434         RT_START_TEST(SelectProperty)
 435
 436         wxPropertyGridIterator it;
 437         size_t ind;
 438
 439         for ( ind=0; ind<pgman->GetPageCount(); ind++ )
 440         {
 441             wxPropertyGridPage* page = pgman->GetPage(ind);
 442             pgman->SelectPage(page);
 443
 444             for ( it = page->GetIterator(wxPG_ITERATE_VISIBLE);
 445                   !it.AtEnd();
 446                   it++ )
 447             {
 448                 wxPGProperty* p = *it;
 449                 RT_MSG(p->GetLabel());
 450                 pgman->GetGrid()->SelectProperty(p, true);
 451                 ::wxMilliSleep(150);
 452                 Update();
 453             }
 454         }
 455     }
 456
 457     {
 458         //
 459         // Delete everything in reverse order
 460         RT_START_TEST(DeleteProperty)
 461
 462         wxPGVIterator it;
 463         wxArrayPGProperty array;
 464
 465         for ( it = pgman->GetVIterator(wxPG_ITERATE_ALL&~(wxPG_IT_CHILDREN(wxPG_PROP_AGGREGATE)));
 466               !it.AtEnd();
 467               it.Next() )
 468             array.push_back(it.GetProperty());
 469
 470         wxArrayPGProperty::reverse_iterator it2;
 471
 472         for ( it2 = array.rbegin(); it2 != array.rend(); it2++ )
 473         {
 474             wxPGProperty* p = (wxPGProperty*)*it2;
 475             RT_MSG(wxString::Format(wxT("Deleting '%s' ('%s')"),p->GetLabel().c_str(),p->GetName().c_str()));
 476             pgman->DeleteProperty(p);
 477         }
 478
 479         // Recreate grid
 480         CreateGrid( -1, -1 );
 481         pgman = m_pPropGridManager;
 482     }
 483
 484     {
 485         //
 486         // Test property default values
 487         RT_START_TEST(Default_Values)
 488
 489         wxPGVIterator it;
 490
 491         for ( it = pgman->GetVIterator(wxPG_ITERATE_PROPERTIES);
 492               !it.AtEnd();
 493               it.Next() )
 494         {
 495             wxPGProperty* p = it.GetProperty();
 496             pgman->SetPropertyValue(p, p->GetDefaultValue());
 497         }
 498
 499         // Recreate grid
 500         CreateGrid( -1, -1 );
 501         pgman = m_pPropGridManager;
 502     }
 503
 504     {
 505         //
 506         // Test wxAny<->wxVariant conversion
 507         RT_START_TEST(WXVARIANT_TO_WXANY_CONVERSION)
 508
 509         wxPGProperty* prop;
 510         wxAny any;
 511
 512 #if wxUSE_DATETIME
 513         prop = pgman->GetProperty("DateProperty");
 514         wxDateTime testTime = wxDateTime::Now();
 515         any = testTime;
 516         prop->SetValue(any);
 517         if ( wxANY_AS(prop->GetValue().GetAny(), wxDateTime) != testTime )
 518             RT_FAILURE();
 519 #endif
 520
 521         prop = pgman->GetProperty("IntProperty");
 522         int testInt = 25537983;
 523         any = testInt;
 524         prop->SetValue(any);
 525         if ( wxANY_AS(prop->GetValue().GetAny(), int) != testInt )
 526             RT_FAILURE();
 527 #ifdef wxLongLong_t
 528         if ( wxANY_AS(prop->GetValue().GetAny(), wxLongLong_t) != testInt )
 529             RT_FAILURE();
 530 #endif
 531
 532         prop = pgman->GetProperty("StringProperty");
 533         wxString testString = "asd934jfyn3";
 534         any = testString;
 535         prop->SetValue(any);
 536         if ( wxANY_AS(prop->GetValue().GetAny(), wxString) != testString )
 537             RT_FAILURE();
 538
 539         // Test with a type generated with IMPLEMENT_VARIANT_OBJECT()
 540         prop = pgman->GetProperty("ColourProperty");
 541         wxColour testCol = *wxCYAN;
 542         any = testCol;
 543         prop->SetValue(any);
 544         if ( wxANY_AS(prop->GetValue().GetAny(), wxColour) != testCol )
 545             RT_FAILURE();
 546
 547         // Test with a type with custom wxVariantData defined by
 548         // wxPG headers.
 549         prop = pgman->GetProperty("Position");
 550         wxPoint testPoint(199, 199);
 551         any = testPoint;
 552         prop->SetValue(any);
 553         if ( wxANY_AS(prop->GetValue().GetAny(), wxPoint) != testPoint )
 554             RT_FAILURE();
 555     }
 556
 557     {
 558         RT_START_TEST(GetPropertyValues)
 559
 560         for ( i=0; i<3; i++ )
 561         {
 562             wxString text;
 563
 564             wxPropertyGridPage* page = pgman->GetPage(i);
 565
 566             wxVariant values = page->GetPropertyValues();
 567
 568             unsigned int i;
 569             for ( i = 0; i < (unsigned int)values.GetCount(); i++ )
 570             {
 571                 wxVariant& v = values[i];
 572
 573                 t.Printf(wxT("%i: name=\"%s\"  type=\"%s\"\n"),(int)i,
 574                     v.GetName().c_str(),v.GetType().c_str());
 575
 576                 text += t;
 577             }
 578             ed->AppendText(text);
 579         }
 580     }
 581
 582     {
 583         RT_START_TEST(SetPropertyValue_and_GetPropertyValue)
 584
 585         // In this section, mixed up usage of wxT("propname") and "propname"
 586         // in wxPropertyGridInterface functions is intentional.
 587         // Purpose is to test wxPGPropArgCls ctors.
 588
 589         //pg = (wxPropertyGrid*) NULL;
 590
 591         wxArrayString test_arrstr_1;
 592         test_arrstr_1.Add(wxT("Apple"));
 593         test_arrstr_1.Add(wxT("Orange"));
 594         test_arrstr_1.Add(wxT("Lemon"));
 595
 596         wxArrayString test_arrstr_2;
 597         test_arrstr_2.Add(wxT("Potato"));
 598         test_arrstr_2.Add(wxT("Cabbage"));
 599         test_arrstr_2.Add(wxT("Cucumber"));
 600
 601         wxArrayInt test_arrint_1;
 602         test_arrint_1.Add(1);
 603         test_arrint_1.Add(2);
 604         test_arrint_1.Add(3);
 605
 606         wxArrayInt test_arrint_2;
 607         test_arrint_2.Add(0);
 608         test_arrint_2.Add(1);
 609         test_arrint_2.Add(4);
 610
 611 #if wxUSE_DATETIME
 612         wxDateTime dt1 = wxDateTime::Now();
 613         dt1.SetYear(dt1.GetYear()-1);
 614
 615         wxDateTime dt2 = wxDateTime::Now();
 616         dt2.SetYear(dt2.GetYear()-10);
 617 #endif
 618
 619         wxColour colWithAlpha(1, 128, 254, 100);
 620         wxString colWithAlphaStr(colWithAlpha.GetAsString(wxC2S_CSS_SYNTAX));
 621
 622 #define FLAG_TEST_SET1 (wxCAPTION|wxCLOSE_BOX|wxSYSTEM_MENU|wxRESIZE_BORDER)
 623 #define FLAG_TEST_SET2 (wxSTAY_ON_TOP|wxCAPTION|wxICONIZE|wxSYSTEM_MENU)
 624
 625         pgman->SetPropertyValue(wxT("StringProperty"),wxT("Text1"));
 626         pgman->SetPropertyValue(wxT("IntProperty"),1024);
 627         pgman->SetPropertyValue(wxT("FloatProperty"),1024.0000000001);
 628         pgman->SetPropertyValue(wxT("BoolProperty"),FALSE);
 629         pgman->SetPropertyValue(wxT("EnumProperty"),120);
 630         pgman->SetPropertyValue(wxT("ArrayStringProperty"),test_arrstr_1);
 631         wxColour emptyCol;
 632         pgman->SetPropertyValue(wxT("ColourProperty"),emptyCol);
 633         pgman->SetPropertyValue(wxT("ColourProperty"),(wxObject*)wxBLACK);
 634         pgman->SetPropertyValue(wxT("Size"),WXVARIANT(wxSize(150,150)));
 635         pgman->SetPropertyValue(wxT("Position"),WXVARIANT(wxPoint(150,150)));
 636         pgman->SetPropertyValue(wxT("MultiChoiceProperty"),test_arrint_1);
 637 #if wxUSE_DATETIME
 638         pgman->SetPropertyValue(wxT("DateProperty"),dt1);
 639 #endif
 640
 641         pgman->SelectPage(2);
 642         pg = pgman->GetGrid();
 643
 644         if ( pg->GetPropertyValueAsString(wxT("StringProperty")) != wxT("Text1") )
 645             RT_FAILURE();
 646         if ( pg->GetPropertyValueAsInt(wxT("IntProperty")) != 1024 )
 647             RT_FAILURE();
 648         if ( pg->GetPropertyValueAsDouble(wxT("FloatProperty")) != 1024.0000000001 )
 649             RT_FAILURE();
 650         if ( pg->GetPropertyValueAsBool(wxT("BoolProperty")) != FALSE )
 651             RT_FAILURE();
 652         if ( pg->GetPropertyValueAsLong(wxT("EnumProperty")) != 120 )
 653             RT_FAILURE();
 654         if ( pg->GetPropertyValueAsArrayString(wxT("ArrayStringProperty")) != test_arrstr_1 )
 655             RT_FAILURE();
 656         wxColour col;
 657         col << pgman->GetPropertyValue(wxT("ColourProperty"));
 658         if ( col != *wxBLACK )
 659             RT_FAILURE();
 660         wxVariant varSize(pg->GetPropertyValue(wxT("Size")));
 661         if ( wxSizeRefFromVariant(varSize) != wxSize(150,150) )
 662             RT_FAILURE();
 663         wxVariant varPos(pg->GetPropertyValue(wxT("Position")));
 664         if ( wxPointRefFromVariant(varPos) != wxPoint(150,150) )
 665             RT_FAILURE();
 666         if ( !(pg->GetPropertyValueAsArrayInt(wxT("MultiChoiceProperty")) == test_arrint_1) )
 667             RT_FAILURE();
 668 #if wxUSE_DATETIME
 669         if ( !(pg->GetPropertyValueAsDateTime(wxT("DateProperty")) == dt1) )
 670             RT_FAILURE();
 671 #endif
 672
 673         pgman->SetPropertyValue(wxT("IntProperty"),wxLL(10000000000));
 674         if ( pg->GetPropertyValueAsLongLong(wxT("IntProperty")) != wxLL(10000000000) )
 675             RT_FAILURE();
 676
 677         pg->SetPropertyValue(wxT("StringProperty"),wxT("Text2"));
 678         pg->SetPropertyValue(wxT("IntProperty"),512);
 679         pg->SetPropertyValue(wxT("FloatProperty"),512.0);
 680         pg->SetPropertyValue(wxT("BoolProperty"),TRUE);
 681         pg->SetPropertyValue(wxT("EnumProperty"),80);
 682         pg->SetPropertyValue(wxT("ArrayStringProperty"),test_arrstr_2);
 683         pg->SetPropertyValue(wxT("ColourProperty"),(wxObject*)wxWHITE);
 684         pg->SetPropertyValue(wxT("Size"),WXVARIANT(wxSize(300,300)));
 685         pg->SetPropertyValue(wxT("Position"),WXVARIANT(wxPoint(300,300)));
 686         pg->SetPropertyValue(wxT("MultiChoiceProperty"),test_arrint_2);
 687 #if wxUSE_DATETIME
 688         pg->SetPropertyValue(wxT("DateProperty"),dt2);
 689 #endif
 690
 691         //pg = (wxPropertyGrid*) NULL;
 692
 693         pgman->SelectPage(0);
 694
 695         if ( pgman->GetPropertyValueAsString(wxT("StringProperty")) != wxT("Text2") )
 696             RT_FAILURE();
 697         if ( pgman->GetPropertyValueAsInt(wxT("IntProperty")) != 512 )
 698             RT_FAILURE();
 699         if ( pgman->GetPropertyValueAsDouble(wxT("FloatProperty")) != 512.0 )
 700             RT_FAILURE();
 701         if ( pgman->GetPropertyValueAsBool(wxT("BoolProperty")) != TRUE )
 702             RT_FAILURE();
 703         if ( pgman->GetPropertyValueAsLong(wxT("EnumProperty")) != 80 )
 704             RT_FAILURE();
 705         if ( pgman->GetPropertyValueAsArrayString(wxT("ArrayStringProperty")) != test_arrstr_2 )
 706             RT_FAILURE();
 707         col << pgman->GetPropertyValue(wxT("ColourProperty"));
 708         if ( col != *wxWHITE )
 709             RT_FAILURE();
 710         varSize = pgman->GetPropertyValue(wxT("Size"));
 711         if ( wxSizeRefFromVariant(varSize) != wxSize(300,300) )
 712             RT_FAILURE();
 713         varPos = pgman->GetPropertyValue(wxT("Position"));
 714         if ( wxPointRefFromVariant(varPos) != wxPoint(300,300) )
 715             RT_FAILURE();
 716         if ( !(pgman->GetPropertyValueAsArrayInt(wxT("MultiChoiceProperty")) == test_arrint_2) )
 717             RT_FAILURE();
 718 #if wxUSE_DATETIME
 719         if ( !(pgman->GetPropertyValueAsDateTime(wxT("DateProperty")) == dt2) )
 720             RT_FAILURE();
 721 #endif
 722
 723         pgman->SetPropertyValue(wxT("IntProperty"),wxLL(-80000000000));
 724         if ( pgman->GetPropertyValueAsLongLong(wxT("IntProperty")) != wxLL(-80000000000) )
 725             RT_FAILURE();
 726
 727         // Make sure children of composite parent get updated as well
 728         // Original string value: "Lamborghini Diablo SV; 5707; [300; 3.9; 8.6] 300000; Not Convertible"
 729
 730         //
 731         // This updates children as well
 732         wxString nvs = "Lamborghini Diablo XYZ; 5707; [100; 3.9; 8.6] 3000002; Convertible";
 733         pgman->SetPropertyValue("Car", nvs);
 734
 735         if ( pgman->GetPropertyValueAsString("Car.Model") != "Lamborghini Diablo XYZ" )
 736         {
 737             wxLogDebug("Did not match: Car.Model=%s", pgman->GetPropertyValueAsString("Car.Model").c_str());
 738             RT_FAILURE();
 739         }
 740
 741         if ( pgman->GetPropertyValueAsInt("Car.Speeds.Max. Speed (mph)") != 100 )
 742         {
 743             wxLogDebug("Did not match: Car.Speeds.Max. Speed (mph)=%s", pgman->GetPropertyValueAsString("Car.Speeds.Max. Speed (mph)").c_str());
 744             RT_FAILURE();
 745         }
 746
 747         if ( pgman->GetPropertyValueAsInt("Car.Price ($)") != 3000002 )
 748         {
 749             wxLogDebug("Did not match: Car.Price ($)=%s", pgman->GetPropertyValueAsString("Car.Price ($)").c_str());
 750             RT_FAILURE();
 751         }
 752
 753         if ( !pgman->GetPropertyValueAsBool("Car.Convertible") )
 754         {
 755             wxLogDebug("Did not match: Car.Convertible=%s", pgman->GetPropertyValueAsString("Car.Convertible").c_str());
 756             RT_FAILURE();
 757         }
 758
 759         // SetPropertyValueString for special cases such as wxColour
 760         pgman->SetPropertyValueString("ColourProperty", "(123,4,255)");
 761         col << pgman->GetPropertyValue("ColourProperty");
 762         if ( col != wxColour(123, 4, 255) )
 763             RT_FAILURE();
 764         pgman->SetPropertyValueString("ColourProperty", "#FE860B");
 765         col << pgman->GetPropertyValue("ColourProperty");
 766         if ( col != wxColour(254, 134, 11) )
 767             RT_FAILURE();
 768
 769         pgman->SetPropertyValueString("ColourPropertyWithAlpha",
 770                                       "(10, 20, 30, 128)");
 771         col << pgman->GetPropertyValue("ColourPropertyWithAlpha");
 772         if ( col != wxColour(10, 20, 30, 128) )
 773             RT_FAILURE();
 774         if ( pgman->GetPropertyValueAsString("ColourPropertyWithAlpha")
 775                 != "(10,20,30,128)" )
 776             RT_FAILURE();
 777     }
 778
 779     {
 780         RT_START_TEST(SetPropertyValueUnspecified)
 781
 782         // Null variant setter tests
 783         pgman->SetPropertyValueUnspecified(wxT("StringProperty"));
 784         pgman->SetPropertyValueUnspecified(wxT("IntProperty"));
 785         pgman->SetPropertyValueUnspecified(wxT("FloatProperty"));
 786         pgman->SetPropertyValueUnspecified(wxT("BoolProperty"));
 787         pgman->SetPropertyValueUnspecified(wxT("EnumProperty"));
 788         pgman->SetPropertyValueUnspecified(wxT("ArrayStringProperty"));
 789         pgman->SetPropertyValueUnspecified(wxT("ColourProperty"));
 790         pgman->SetPropertyValueUnspecified(wxT("Size"));
 791         pgman->SetPropertyValueUnspecified(wxT("Position"));
 792         pgman->SetPropertyValueUnspecified(wxT("MultiChoiceProperty"));
 793 #if wxUSE_DATETIME
 794         pgman->SetPropertyValueUnspecified(wxT("DateProperty"));
 795 #endif
 796     }
 797
 798     {
 799         //
 800         // Test multiple selection
 801         RT_START_TEST(MULTIPLE_SELECTION)
 802         if ( !(pgman->GetExtraStyle() & wxPG_EX_MULTIPLE_SELECTION) )
 803             CreateGrid( -1, wxPG_EX_MULTIPLE_SELECTION);
 804         pgman = m_pPropGridManager;
 805
 806         wxPropertyGrid* pg = pgman->GetGrid();
 807
 808         wxPGProperty* prop1 = pg->GetProperty(wxT("Label"));
 809         wxPGProperty* prop2 = pg->GetProperty(wxT("Cell Text Colour"));
 810         wxPGProperty* prop3 = pg->GetProperty(wxT("Height"));
 811         wxPGProperty* catProp = pg->GetProperty(wxT("Appearance"));
 812
 813         RT_ASSERT( prop1 && prop2 && prop3 );
 814
 815         pg->ClearSelection();
 816         pg->AddToSelection(prop1);
 817         pg->AddToSelection(prop2);
 818         pg->AddToSelection(prop3);
 819
 820         // Adding category to selection should fail silently
 821         pg->AddToSelection(catProp);
 822
 823         wxArrayPGProperty selectedProperties = pg->GetSelectedProperties();
 824
 825         RT_ASSERT( selectedProperties.size() == 3 )
 826         RT_ASSERT( pg->IsPropertySelected(prop1) )
 827         RT_ASSERT( pg->IsPropertySelected(prop2) )
 828         RT_ASSERT( pg->IsPropertySelected(prop3) )
 829         RT_ASSERT( !pg->IsPropertySelected(catProp) )
 830
 831         pg->RemoveFromSelection(prop1);
 832         wxArrayPGProperty selectedProperties2 = pg->GetSelectedProperties();
 833
 834         RT_ASSERT( selectedProperties2.size() == 2 )
 835         RT_ASSERT( !pg->IsPropertySelected(prop1) )
 836         RT_ASSERT( pg->IsPropertySelected(prop2) )
 837         RT_ASSERT( pg->IsPropertySelected(prop3) )
 838
 839         pg->ClearSelection();
 840
 841         wxArrayPGProperty selectedProperties3 = pg->GetSelectedProperties();
 842
 843         RT_ASSERT( selectedProperties3.size() == 0 )
 844         RT_ASSERT( !pg->IsPropertySelected(prop1) )
 845         RT_ASSERT( !pg->IsPropertySelected(prop2) )
 846         RT_ASSERT( !pg->IsPropertySelected(prop3) )
 847
 848         pg->SelectProperty(prop2);
 849
 850         RT_ASSERT( !pg->IsPropertySelected(prop1) )
 851         RT_ASSERT( pg->IsPropertySelected(prop2) )
 852         RT_ASSERT( !pg->IsPropertySelected(prop3) )
 853     }
 854
 855     {
 856         //
 857         // Test label editing
 858         RT_START_TEST(LABEL_EDITING)
 859
 860         wxPropertyGrid* pg = pgman->GetGrid();
 861
 862         // Just mostly test that these won't crash
 863         pg->MakeColumnEditable(0, true);
 864         pg->MakeColumnEditable(2, true);
 865         pg->MakeColumnEditable(0, false);
 866         pg->MakeColumnEditable(2, false);
 867         pg->SelectProperty(wxT("Height"));
 868         pg->BeginLabelEdit(0);
 869         pg->BeginLabelEdit(0);
 870         pg->EndLabelEdit(0);
 871         pg->EndLabelEdit(0);
 872
 873         // Recreate grid
 874         CreateGrid( -1, -1 );
 875         pgman = m_pPropGridManager;
 876     }
 877
 878     {
 879         RT_START_TEST(Attributes)
 880
 881         wxPGProperty* prop = pgman->GetProperty(wxT("StringProperty"));
 882         prop->SetAttribute(wxT("Dummy Attribute"), (long)15);
 883
 884         if ( prop->GetAttribute(wxT("Dummy Attribute")).GetLong() != 15 )
 885             RT_FAILURE();
 886
 887         prop->SetAttribute(wxT("Dummy Attribute"), wxVariant());
 888
 889         if ( !prop->GetAttribute(wxT("Dummy Attribute")).IsNull() )
 890             RT_FAILURE();
 891     }
 892
 893     {
 894         RT_START_TEST(DoubleToString)
 895
 896         // Locale-specific decimal separator
 897         wxString sep = wxString::Format("%g", 1.1)[1];
 898
 899         wxString s;
 900
 901         if ( wxPropertyGrid::DoubleToString(s, 123.123, 2, true) !=
 902                 wxString::Format("123%s12", sep.c_str()) )
 903             RT_FAILURE();
 904         if ( wxPropertyGrid::DoubleToString(s, -123.123, 4, false) !=
 905                 wxString::Format("-123%s1230", sep.c_str()) )
 906             RT_FAILURE();
 907         if ( wxPropertyGrid::DoubleToString(s, -0.02, 1, false) !=
 908                 wxString::Format("0%s0", sep) )
 909             RT_FAILURE();
 910         if ( wxPropertyGrid::DoubleToString(s, -0.000123, 3, true) != "0" )
 911             RT_FAILURE();
 912     }
 913
 914     {
 915         wxPropertyGridPage* page1;
 916         wxPropertyGridPage* page2;
 917         wxPropertyGridPage* page3;
 918         wxVariant pg1_values;
 919         wxVariant pg2_values;
 920         wxVariant pg3_values;
 921
 922         {
 923             RT_START_TEST(GetPropertyValues)
 924
 925             page1 = pgman->GetPage(0);
 926             pg1_values = page1->GetPropertyValues(wxT("Page1"),NULL,wxPG_KEEP_STRUCTURE);
 927             page2 = pgman->GetPage(1);
 928             pg2_values = page2->GetPropertyValues(wxT("Page2"),NULL,wxPG_KEEP_STRUCTURE);
 929             page3 = pgman->GetPage(2);
 930             pg3_values = page3->GetPropertyValues(wxT("Page3"),NULL,wxPG_KEEP_STRUCTURE);
 931         }
 932
 933         {
 934             RT_START_TEST(SetPropertyValues)
 935
 936             page1->SetPropertyValues(pg3_values);
 937             page2->SetPropertyValues(pg1_values);
 938             page3->SetPropertyValues(pg2_values);
 939         }
 940     }
 941
 942     if ( !(pgman->GetWindowStyleFlag()&wxPG_HIDE_CATEGORIES) )
 943     {
 944         RT_START_TEST(Collapse_and_GetFirstCategory_and_GetNextCategory)
 945
 946         for ( i=0; i<3; i++ )
 947         {
 948             wxPropertyGridPage* page = pgman->GetPage(i);
 949
 950             wxPropertyGridIterator it;
 951
 952             for ( it = page->GetIterator( wxPG_ITERATE_CATEGORIES );
 953                   !it.AtEnd();
 954                   it++ )
 955             {
 956                 wxPGProperty* p = *it;
 957
 958                 if ( !page->IsPropertyCategory(p) )
 959                     RT_FAILURE();
 960
 961                 page->Collapse( p );
 962
 963                 t.Printf(wxT("Collapsing: %s\n"),page->GetPropertyLabel(p).c_str());
 964                 ed->AppendText(t);
 965             }
 966         }
 967     }
 968
 969     {
 970         RT_START_TEST(Save_And_RestoreEditableState)
 971
 972         for ( i=0; i<3; i++ )
 973         {
 974             pgman->SelectPage(i);
 975
 976             wxString stringState = pgman->SaveEditableState();
 977             bool res = pgman->RestoreEditableState(stringState);
 978             if ( !res )
 979                 RT_FAILURE();
 980         }
 981     }
 982
 983     //if ( !(pgman->GetWindowStyleFlag()&wxPG_HIDE_CATEGORIES) )
 984     {
 985         RT_START_TEST(Expand_and_GetFirstCategory_and_GetNextCategory)
 986
 987         for ( i=0; i<3; i++ )
 988         {
 989             wxPropertyGridPage* page = pgman->GetPage(i);
 990
 991             wxPropertyGridIterator it;
 992
 993             for ( it = page->GetIterator( wxPG_ITERATE_CATEGORIES );
 994                   !it.AtEnd();
 995                   it++ )
 996             {
 997                 wxPGProperty* p = *it;
 998
 999                 if ( !page->IsPropertyCategory(p) )
1000                     RT_FAILURE();
1001
1002                 page->Expand( p );
1003
1004                 t.Printf(wxT("Expand: %s\n"),page->GetPropertyLabel(p).c_str());
1005                 ed->AppendText(t);
1006             }
1007         }
1008     }
1009
1010     {
1011         RT_START_TEST(Choice_Manipulation)
1012
1013         wxPGProperty* enumProp = pgman->GetProperty(wxT("EnumProperty"));
1014
1015         pgman->SelectPage(2);
1016         pgman->SelectProperty(enumProp);
1017         wxASSERT(pgman->GetGrid()->GetSelection() == enumProp);
1018
1019         const wxPGChoices& choices = enumProp->GetChoices();
1020         int ind = enumProp->InsertChoice(wxT("New Choice"), choices.GetCount()/2);
1021         enumProp->DeleteChoice(ind);
1022
1023         // Recreate the original grid
1024         CreateGrid( -1, -1 );
1025         pgman = m_pPropGridManager;
1026     }
1027
1028     //if ( !(pgman->GetWindowStyleFlag()&wxPG_HIDE_CATEGORIES) )
1029     {
1030         RT_START_TEST(RandomCollapse)
1031
1032         // Select the most error prone page as visible.
1033         pgman->SelectPage(1);
1034
1035         for ( i=0; i<3; i++ )
1036         {
1037             wxArrayPtrVoid arr;
1038
1039             wxPropertyGridPage* page = pgman->GetPage(i);
1040
1041             wxPropertyGridIterator it;
1042
1043             for ( it = page->GetIterator( wxPG_ITERATE_CATEGORIES );
1044                   !it.AtEnd();
1045                   it++ )
1046             {
1047                 arr.Add((void*)*it);
1048             }
1049
1050             if ( arr.GetCount() )
1051             {
1052                 size_t n;
1053
1054                 pgman->Collapse( (wxPGProperty*)arr.Item(0) );
1055
1056                 for ( n=arr.GetCount()-1; n>0; n-- )
1057                 {
1058                     pgman->Collapse( (wxPGProperty*)arr.Item(n) );
1059                 }
1060             }
1061
1062         }
1063     }
1064
1065     {
1066         RT_START_TEST(EnsureVisible)
1067         pgman->EnsureVisible(wxT("Cell Colour"));
1068     }
1069
1070     {
1071         RT_START_TEST(RemoveProperty)
1072
1073         wxPGProperty* p;
1074
1075         wxPGProperty* origParent =
1076             pgman->GetProperty("Window Styles")->GetParent();
1077
1078         // For testing purposes, let's set some custom cell colours
1079         p = pgman->GetProperty("Window Styles");
1080         p->SetCell(2, wxPGCell("style"));
1081         p = pgman->RemoveProperty("Window Styles");
1082         pgman->Refresh();
1083         pgman->Update();
1084
1085         pgman->AppendIn(origParent, p);
1086         wxASSERT( p->GetCell(2).GetText() == "style");
1087         pgman->Refresh();
1088         pgman->Update();
1089     }
1090
1091     {
1092         RT_START_TEST(SortFunction)
1093
1094         wxPGProperty* p;
1095
1096         // Make sure indexes are as supposed
1097
1098         p = pgman->GetProperty(wxT("User Name"));
1099         if ( p->GetIndexInParent() != 3 )
1100             RT_FAILURE();
1101
1102         p = pgman->GetProperty(wxT("User Id"));
1103         if ( p->GetIndexInParent() != 2 )
1104             RT_FAILURE();
1105
1106         p = pgman->GetProperty(wxT("User Home"));
1107         if ( p->GetIndexInParent() != 1 )
1108             RT_FAILURE();
1109
1110         p = pgman->GetProperty(wxT("Operating System"));
1111         if ( p->GetIndexInParent() != 0 )
1112             RT_FAILURE();
1113
1114         pgman->GetGrid()->SetSortFunction(MyPropertySortFunction);
1115
1116         pgman->GetGrid()->SortChildren(wxT("Environment"));
1117
1118         // Make sure indexes have been reversed
1119         p = pgman->GetProperty(wxT("User Name"));
1120         if ( p->GetIndexInParent() != 0 )
1121             RT_FAILURE();
1122
1123         p = pgman->GetProperty(wxT("User Id"));
1124         if ( p->GetIndexInParent() != 1 )
1125             RT_FAILURE();
1126
1127         p = pgman->GetProperty(wxT("User Home"));
1128         if ( p->GetIndexInParent() != 2 )
1129             RT_FAILURE();
1130
1131         p = pgman->GetProperty(wxT("Operating System"));
1132         if ( p->GetIndexInParent() != 3 )
1133             RT_FAILURE();
1134     }
1135
1136     {
1137         RT_START_TEST(SetPropertyBackgroundColour)
1138         wxCommandEvent evt;
1139         evt.SetInt(1); // IsChecked() will return TRUE.
1140         evt.SetId(ID_COLOURSCHEME4);
1141         OnCatColours(evt);
1142         OnColourScheme(evt);
1143     }
1144
1145     {
1146         RT_START_TEST(Clear)
1147
1148         // Manager clear
1149         pgman->SelectProperty("Label");
1150         pgman->Clear();
1151
1152         if ( pgman->GetPageCount() )
1153             RT_FAILURE();
1154
1155         if ( pgman->GetGrid()->GetRoot()->GetChildCount() )
1156             RT_FAILURE();
1157
1158         // Recreate the original grid
1159         CreateGrid( -1, -1 );
1160         pgman = m_pPropGridManager;
1161
1162         // Grid clear
1163         pgman->SelectProperty("Label");
1164         pgman->GetGrid()->Clear();
1165
1166         if ( pgman->GetGrid()->GetRoot()->GetChildCount() )
1167             RT_FAILURE();
1168
1169         // Recreate the original grid
1170         CreateGrid( -1, -1 );
1171         pgman = m_pPropGridManager;
1172     }
1173
1174     /*{
1175         // TODO: This test fails.
1176         RT_START_TEST(SetSplitterPosition)
1177
1178         InitPanel();
1179
1180         const int trySplitterPos = 50;
1181
1182         int style = wxPG_AUTO_SORT;  // wxPG_SPLITTER_AUTO_CENTER;
1183         pgman = m_pPropGridManager =
1184             new wxPropertyGridManager(m_panel, wxID_ANY,
1185                                       wxDefaultPosition,
1186                                       wxDefaultSize,
1187                                       style );
1188
1189         PopulateGrid();
1190         pgman->SetSplitterPosition(trySplitterPos);
1191
1192         if ( pgman->GetGrid()->GetSplitterPosition() != trySplitterPos )
1193             RT_FAILURE_MSG(wxString::Format(wxT("Splitter position was %i (should have been %i)"),(int)pgman->GetGrid()->GetSplitterPosition(),trySplitterPos).c_str());
1194
1195         m_topSizer->Add( m_pPropGridManager, 1, wxEXPAND );
1196         FinalizePanel();
1197
1198         wxSize sz = GetSize();
1199         wxSize origSz = sz;
1200         sz.x += 5;
1201         sz.y += 5;
1202
1203         if ( pgman->GetGrid()->GetSplitterPosition() != trySplitterPos )
1204             RT_FAILURE_MSG(wxString::Format(wxT("Splitter position was %i (should have been %i)"),(int)pgman->GetGrid()->GetSplitterPosition(),trySplitterPos).c_str());
1205
1206         SetSize(origSz);
1207
1208         // Recreate the original grid
1209         CreateGrid( -1, -1 );
1210         pgman = m_pPropGridManager;
1211     }*/
1212
1213     {
1214         RT_START_TEST(HideProperty)
1215
1216         wxPropertyGridPage* page = pgman->GetPage(0);
1217
1218         srand(0x1234);
1219
1220         wxArrayPGProperty arr1;
1221
1222         arr1 = GetPropertiesInRandomOrder(page);
1223
1224         if ( !_failed_ )
1225         {
1226             for ( i=0; i<arr1.size(); i++ )
1227             {
1228                 wxPGProperty* p = arr1[i];
1229                 page->HideProperty(p, true);
1230
1231                 wxString s = wxString::Format(wxT("HideProperty(%i, %s)"), i, p->GetLabel().c_str());
1232                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1233                 if ( _failed_ )
1234                     break;
1235             }
1236         }
1237
1238         if ( !_failed_ )
1239         {
1240             wxArrayPGProperty arr2 = GetPropertiesInRandomOrder(page);
1241
1242             for ( i=0; i<arr2.size(); i++ )
1243             {
1244                 wxPGProperty* p = arr2[i];
1245                 page->HideProperty(p, false);
1246
1247                 wxString s = wxString::Format(wxT("ShowProperty(%i, %s)"), i, p->GetLabel().c_str());
1248                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1249                 if ( _failed_ )
1250                     break;
1251             }
1252         }
1253
1254         //
1255         // Let's do some more, for better consistency
1256         arr1 = GetPropertiesInRandomOrder(page);
1257
1258         if ( !_failed_ )
1259         {
1260             for ( i=0; i<arr1.size(); i++ )
1261             {
1262                 wxPGProperty* p = arr1[i];
1263                 page->HideProperty(p, true);
1264
1265                 wxString s = wxString::Format(wxT("HideProperty(%i, %s)"), i, p->GetLabel().c_str());
1266                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1267                 if ( _failed_ )
1268                     break;
1269             }
1270         }
1271
1272         if ( !_failed_ )
1273         {
1274             wxArrayPGProperty arr2 = GetPropertiesInRandomOrder(page);
1275
1276             for ( i=0; i<arr2.size(); i++ )
1277             {
1278                 wxPGProperty* p = arr2[i];
1279                 page->HideProperty(p, false);
1280
1281                 wxString s = wxString::Format(wxT("ShowProperty(%i, %s)"), i, p->GetLabel().c_str());
1282                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1283                 if ( _failed_ )
1284                     break;
1285             }
1286         }
1287
1288         //
1289         // Ok, this time only hide half of them
1290         arr1 = GetPropertiesInRandomOrder(page);
1291         arr1.resize(arr1.size()/2);
1292
1293         if ( !_failed_ )
1294         {
1295             for ( i=0; i<arr1.size(); i++ )
1296             {
1297                 wxPGProperty* p = arr1[i];
1298                 page->HideProperty(p, true);
1299
1300                 wxString s = wxString::Format(wxT("HideProperty(%i, %s)"), i, p->GetLabel().c_str());
1301                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1302                 if ( _failed_ )
1303                     break;
1304             }
1305         }
1306
1307         if ( !_failed_ )
1308         {
1309             wxArrayPGProperty arr2 = GetPropertiesInRandomOrder(page);
1310
1311             for ( i=0; i<arr2.size(); i++ )
1312             {
1313                 wxPGProperty* p = arr2[i];
1314                 page->HideProperty(p, false);
1315
1316                 wxString s = wxString::Format(wxT("ShowProperty(%i, %s)"), i, p->GetLabel().c_str());
1317                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1318                 if ( _failed_ )
1319                     break;
1320             }
1321         }
1322
1323         // Recreate the original grid
1324         CreateGrid( -1, -1 );
1325         pgman = m_pPropGridManager;
1326     }
1327
1328     if ( fullTest )
1329     {
1330         RT_START_TEST(MultipleColumns)
1331
1332         // Test with multiple columns
1333         // FIXME: Does not display changes.
1334         for ( i=3; i<12; i+=2 )
1335         {
1336             RT_MSG(wxString::Format(wxT("%i columns"),i));
1337             CreateGrid( -1, -1 );
1338             pgman = m_pPropGridManager;
1339             pgman->SetColumnCount(i);
1340             Refresh();
1341             Update();
1342             wxMilliSleep(500);
1343         }
1344     }
1345
1346     if ( fullTest )
1347     {
1348         RT_START_TEST(WindowStyles)
1349
1350         // Recreate grid with all possible (single) flags
1351         wxASSERT(wxPG_AUTO_SORT == 0x000000010);
1352
1353         for ( i=4; i<16; i++ )
1354         {
1355             int flag = 1<<i;
1356             RT_MSG(wxString::Format(wxT("Style: 0x%X"),flag));
1357             CreateGrid( flag, -1 );
1358             pgman = m_pPropGridManager;
1359             Update();
1360             wxMilliSleep(500);
1361         }
1362
1363         wxASSERT(wxPG_EX_INIT_NOCAT == 0x00001000);
1364
1365         for ( i=12; i<27; i++ )
1366         {
1367             int flag = 1<<i;
1368             RT_MSG(wxString::Format(wxT("ExStyle: 0x%X"),flag));
1369             CreateGrid( -1, flag );
1370             pgman = m_pPropGridManager;
1371             Update();
1372             wxMilliSleep(500);
1373         }
1374
1375         // Recreate the original grid
1376         CreateGrid( -1, -1 );
1377         pgman = m_pPropGridManager;
1378     }
1379
1380     RT_START_TEST(none)
1381
1382     bool retVal;
1383
1384     if ( failures || errorMessages.size() )
1385     {
1386         retVal = false;
1387
1388         wxString s;
1389 #ifdef __WXDEBUG__
1390         if ( failures )
1391 #endif
1392             s = wxString::Format(wxT("%i tests failed!!!"), failures);
1393 #ifdef __WXDEBUG__
1394         else
1395             s = wxString::Format(wxT("All tests were successful, but there were %i warnings!"), wxPGGlobalVars->m_warnings);
1396 #endif
1397         RT_MSG(s)
1398         for ( i=0; i<errorMessages.size(); i++ )
1399             RT_MSG(errorMessages[i])
1400         wxMessageBox(s, wxT("Some Tests Failed"));
1401     }
1402     else
1403     {
1404         RT_MSG(wxT("All tests successfull"))
1405         retVal = true;
1406
1407         if ( !interactive )
1408             dlg->Close();
1409     }
1410
1411     pgman->SelectPage(0);
1412
1413     // Test may screw up the toolbar, so we need to refresh it.
1414     wxToolBar* toolBar = pgman->GetToolBar();
1415     if ( toolBar )
1416         toolBar->Refresh();
1417
1418     return retVal;
1419 }
1420
1421 // -----------------------------------------------------------------------