utils/configtool/src/configitem.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        configitem.cpp
   3 // Purpose:     wxWidgets Configuration Tool config item class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     2003-06-03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "configitem.h"
  14 #endif
  15
  16 // Includes other headers for precompiled compilation
  17 #include "wx/wx.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #include "wx/tokenzr.h"
  24
  25 #include "configitem.h"
  26 #include "configtree.h"
  27 #include "configtooldoc.h"
  28 #include "configtoolview.h"
  29 #include "wxconfigtool.h"
  30 #include "mainframe.h"
  31
  32 IMPLEMENT_CLASS(ctConfigItem, wxObject)
  33
  34 ctConfigItem::ctConfigItem()
  35 {
  36     m_modified = false;
  37     m_type = ctTypeBoolCheck;
  38     m_treeItemId = wxTreeItemId();
  39     m_enabled = true;
  40     m_parent = NULL;
  41     m_active = true;
  42 }
  43
  44 ctConfigItem::ctConfigItem(ctConfigItem* parent, ctConfigType type, const wxString& name)
  45 {
  46     m_modified = false;
  47     m_type = type;
  48     m_treeItemId = wxTreeItemId();
  49     m_enabled = false;
  50     m_active = true;
  51     SetName(name);
  52     m_parent = parent;
  53     if (parent)
  54         parent->AddChild(this);
  55 }
  56
  57 ctConfigItem::~ctConfigItem()
  58 {
  59     ctConfigTreeCtrl* treeCtrl = wxGetApp().GetMainFrame()->GetConfigTreeCtrl();
  60     if (m_treeItemId.IsOk() && treeCtrl)
  61     {
  62         ctTreeItemData* data = (ctTreeItemData*) treeCtrl->GetItemData(m_treeItemId);
  63         if (data)
  64             data->SetConfigItem(NULL);
  65     }
  66     if (GetParent())
  67         GetParent()->RemoveChild(this);
  68     else
  69     {
  70         if (wxGetApp().GetMainFrame()->GetDocument() &&
  71             wxGetApp().GetMainFrame()->GetDocument()->GetTopItem() == this)
  72             wxGetApp().GetMainFrame()->GetDocument()->SetTopItem(NULL);
  73     }
  74
  75     Clear();
  76 }
  77
  78 /// Can we edit this property?
  79 bool ctConfigItem::CanEditProperty(const wxString& propName) const
  80 {
  81     ctProperty* prop = m_properties.FindProperty(propName);
  82     if (prop)
  83         return !prop->GetReadOnly();
  84     else
  85         return false;
  86 }
  87
  88 /// Assignment operator.
  89 void ctConfigItem::operator= (const ctConfigItem& item)
  90 {
  91     m_properties = item.m_properties;
  92     m_modified = item.m_modified;
  93     m_defaultProperty = item.m_defaultProperty;
  94     m_type = item.m_type;
  95     m_enabled = item.m_enabled;
  96     m_active = item.m_active;
  97 }
  98
  99 /// Sets the name property.
 100 void ctConfigItem::SetName(const wxString& name )
 101 {
 102     m_properties.SetProperty(wxT("name"), name);
 103 }
 104
 105 /// Clear children
 106 void ctConfigItem::Clear()
 107 {
 108     wxObjectList::compatibility_iterator node = m_children.GetFirst();
 109     while (node)
 110     {
 111         wxObjectList::compatibility_iterator next = node->GetNext();
 112         ctConfigItem* child = (ctConfigItem*) node->GetData();
 113
 114         // This should delete 'node' too, assuming
 115         // child's m_parent points to 'this'. If not,
 116         // it'll be cleaned up by m_children.Clear().
 117         delete child;
 118
 119         node = next;
 120     }
 121     m_children.Clear();
 122 }
 123
 124 // Get the nth child
 125 ctConfigItem* ctConfigItem::GetChild(int n) const
 126 {
 127     wxASSERT ( n < GetChildCount() && n > -1 );
 128
 129     if ( n < GetChildCount() && n > -1 )
 130     {
 131         ctConfigItem* child = wxDynamicCast(m_children.Item(n)->GetData(), ctConfigItem);
 132         return child;
 133     }
 134     else
 135         return NULL;
 136 }
 137
 138 // Get the child count
 139 int ctConfigItem::GetChildCount() const
 140 {
 141     return m_children.GetCount();
 142 }
 143
 144 /// Add a child
 145 void ctConfigItem::AddChild(ctConfigItem* item)
 146 {
 147     m_children.Append(item);
 148     item->SetParent(this);
 149 }
 150
 151 /// Remove (but don't delete) a child
 152 void ctConfigItem::RemoveChild(ctConfigItem* item)
 153 {
 154     m_children.DeleteObject(item);
 155     item->SetParent(NULL);
 156 }
 157
 158 /// Initialise standard properties
 159 void ctConfigItem::InitProperties()
 160 {
 161     ctProperty* prop = m_properties.FindProperty(wxT("name"));
 162     if (!prop)
 163     {
 164         prop = new ctProperty;
 165         m_properties.AddProperty(prop);
 166     }
 167     prop->SetDescription(_("<B>Name</B><P> The name of the configuration setting."));
 168     prop->SetReadOnly(true);
 169
 170     m_properties.AddProperty(
 171         new ctProperty(
 172         wxT("<B>Description</B><P> The setting description."),
 173         wxVariant(wxT(""), wxT("description")),
 174         wxT("multiline")));
 175
 176     m_properties.AddProperty(
 177         new ctProperty(
 178         wxT("<B>Default-state</B><P> The default state."),
 179         wxVariant(true, wxT("default-state")),
 180         wxT("bool")));
 181
 182     if (GetType() == ctTypeString)
 183     {
 184         m_properties.AddProperty(
 185             new ctProperty(
 186             wxT("<B>Default-value</B><P> The default value."),
 187             wxVariant(true, wxT("default-value")),
 188             wxT("")));
 189     }
 190     else if (GetType() == ctTypeInteger)
 191     {
 192         m_properties.AddProperty(
 193             new ctProperty(
 194             wxT("<B>Default-value</B><P> The default value."),
 195             wxVariant((long) 0, wxT("default-value")),
 196             wxT("")));
 197     }
 198
 199     m_properties.AddProperty(
 200         new ctProperty(
 201         wxT("<B>Requires</B><P> When any of the given settings are 0, this setting <I>must</I> be 0. Taking wxUSE_ZIPSTREAM as an example:<P>  If wxUSE_STREAMS is 0, then wxUSE_ZIPSTREAM must be 0.<BR>If wxUSE_STREAMS is 1, then wxUSE_ZIPSTREAM may be 0 or 1."),
 202         wxVariant(wxT(""), wxT("requires")),
 203         wxT("configitems")));
 204
 205     m_properties.AddProperty(
 206         new ctProperty(
 207         wxT("<B>Precludes</B><P> When any of these settings are 1, this setting <I>must</I> be 0. Taking wxUSE_ODBC as an example:<P>  If wxUSE_UNICODE is 1, then wxUSE_ODBC must be 0.<BR>If wxUSE_UNICODE is 0, then wxUSE_ODBC may be 0 or 1."),
 208         wxVariant(wxT(""), wxT("precludes")),
 209         wxT("configitems")));
 210
 211     m_properties.AddProperty(
 212         new ctProperty(
 213         wxT("<B>Enabled-if</B><P> When any of these settings are 1, this setting <I>must</I> be 1."),
 214         wxVariant(wxT(""), wxT("enabled-if")),
 215         wxT("configitems")));
 216
 217     m_properties.AddProperty(
 218         new ctProperty(
 219         wxT("<B>Enabled-if-not</B><P> When any of these settings are 0, this setting <I>must</I> be 1. Taking wxUSE_TOOLBAR_SIMPLE as an example:<P>If wxUSE_TOOLBAR_NATIVE is 0, wxUSE_TOOLBAR_SIMPLE must be 1.<BR>If wxUSE_TOOLBAR_NATIVE is 1, wxUSE_TOOLBAR_SIMPLE may be 0 or 1."),
 220         wxVariant(wxT(""), wxT("enabled-if-not")),
 221         wxT("configitems")));
 222
 223     m_properties.AddProperty(
 224         new ctProperty(
 225         wxT("<B>Indeterminate-if</B><P> When any of these settings are 1, this setting becomes active and indeterminate. Taking wxUSE_UNICODE as an example:<P>If Custom is 1, wxUSE_UNICODE is indeterminate."),
 226         wxVariant(wxT(""), wxT("indeterminate-if")),
 227         wxT("configitems")));
 228
 229     m_properties.AddProperty(
 230         new ctProperty(
 231         wxT("<B>Exclusivity</B><P> The settings that are mutually exclusive with this one."),
 232         wxVariant(wxT(""), wxT("exclusivity")),
 233         wxT("configitems")));
 234
 235     m_properties.AddProperty(
 236         new ctProperty(
 237         wxT("<B>Context</B><P> A list of symbols (config settings), at least one of which must be enabled for this item to participate in dependency rules.<P>\nIf empty, this item will always be used in dependency rules.<P>\nMostly this will be used to specify the applicable platforms, but it can contain other symbols, for example compilers."),
 238         wxVariant(wxT(""), wxT("context")),
 239         wxT("configitems")));
 240
 241     m_properties.AddProperty(
 242         new ctProperty(
 243         wxT("<B>Configure-command</B><P> Configure command to generate if this is on."),
 244         wxVariant(wxT(""), wxT("configure-command")),
 245         wxT("multiline")));
 246
 247     m_properties.AddProperty(
 248         new ctProperty(
 249         wxT("<B>Help-topic</B><P> The help topic in the wxWidgets manual for this component or setting."),
 250         wxVariant(wxT(""), wxT("help-topic")),
 251         wxT("multiline")));
 252
 253     m_properties.AddProperty(
 254         new ctProperty(
 255         wxT("<B>Notes</B><P> User notes."),
 256         wxVariant(wxT(""), wxT("notes")),
 257         wxT("multiline")));
 258
 259     m_defaultProperty = wxT("description");
 260 }
 261
 262 /// Do additional actions to apply the property to the internal
 263 /// representation.
 264 void ctConfigItem::ApplyProperty(ctProperty* prop, const wxVariant& WXUNUSED(oldValue))
 265 {
 266     ctConfigToolDoc* doc = GetDocument();
 267     bool oldModified = doc->IsModified();
 268     doc->Modify(true);
 269
 270     wxString name = prop->GetName();
 271     if (name == wxT("requires") ||
 272         name == wxT("precludes") ||
 273         name == wxT("enabled-if") ||
 274         name == wxT("enabled-if-not") ||
 275         name == wxT("indeterminate-if") ||
 276         name == wxT("context"))
 277     {
 278         doc->RefreshDependencies();
 279     }
 280     if (doc && doc->GetFirstView() && oldModified != doc->IsModified())
 281         ((ctConfigToolView*)doc->GetFirstView())->OnChangeFilename();
 282 }
 283
 284 /// Get the associated document (currently, assumes
 285 /// there's only ever one document active)
 286 ctConfigToolDoc* ctConfigItem::GetDocument()
 287 {
 288     ctConfigToolDoc* doc = wxGetApp().GetMainFrame()->GetDocument();
 289     return doc;
 290 }
 291
 292 /// Convert string containing config item names to
 293 /// an array of config item names
 294 void ctConfigItem::StringToArray(const wxString& items, wxArrayString& itemsArray)
 295 {
 296     wxStringTokenizer tokenizer(items, wxT(","));
 297     while (tokenizer.HasMoreTokens())
 298     {
 299         wxString token = tokenizer.GetNextToken();
 300         itemsArray.Add(token);
 301     }
 302 }
 303
 304 /// Convert array containing config item names to
 305 /// a string
 306 void ctConfigItem::ArrayToString(const wxArrayString& itemsArray, wxString& items)
 307 {
 308     items = wxEmptyString;
 309     size_t i;
 310     for (i = 0; i < itemsArray.GetCount(); i++)
 311     {
 312         items += itemsArray[i];
 313         if (i < (itemsArray.GetCount() - 1))
 314             items += wxT(",");
 315     }
 316 }
 317
 318 /// Populate a list of items found in the string.
 319 void ctConfigItem::StringToItems(ctConfigItem* topItem, const wxString& items, wxList& list)
 320 {
 321     wxArrayString strArray;
 322     StringToArray(items, strArray);
 323     size_t i;
 324     for (i = 0; i < strArray.GetCount(); i++)
 325     {
 326         wxString str(strArray[i]);
 327         ctConfigItem* item = topItem->FindItem(str);
 328         if (item)
 329             list.Append(item);
 330     }
 331 }
 332
 333 /// Find an item in this hierarchy
 334 ctConfigItem* ctConfigItem::FindItem(const wxString& name)
 335 {
 336     if (GetName() == name)
 337         return this;
 338
 339     for ( wxObjectList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() )
 340     {
 341         ctConfigItem* child = (ctConfigItem*) node->GetData();
 342         ctConfigItem* found = child->FindItem(name);
 343         if (found)
 344             return found;
 345     }
 346     return NULL;
 347 }
 348
 349 /// Find the next sibling
 350 ctConfigItem* ctConfigItem::FindNextSibling()
 351 {
 352     if (!GetParent())
 353         return NULL;
 354     wxObjectList::compatibility_iterator node = GetParent()->GetChildren().Member(this);
 355     if (node && node->GetNext())
 356     {
 357         return (ctConfigItem*) node->GetNext()->GetData();
 358     }
 359     return NULL;
 360 }
 361
 362 /// Find the previous sibling
 363 ctConfigItem* ctConfigItem::FindPreviousSibling()
 364 {
 365     if (!GetParent())
 366         return NULL;
 367     wxObjectList::compatibility_iterator node = GetParent()->GetChildren().Member(this);
 368     if (node && node->GetPrevious())
 369     {
 370         return (ctConfigItem*) node->GetPrevious()->GetData();
 371     }
 372     return NULL;
 373 }
 374
 375 /// Sync appearance
 376 void ctConfigItem::Sync()
 377 {
 378     if (GetDocument())
 379     {
 380         ctConfigToolView* view = (ctConfigToolView*) GetDocument()->GetFirstView();
 381         if (view)
 382         {
 383             view->SyncItem(wxGetApp().GetMainFrame()->GetConfigTreeCtrl(), this);
 384         }
 385     }
 386 }
 387
 388 /// Create a clone of this and children
 389 ctConfigItem* ctConfigItem::DeepClone()
 390 {
 391     ctConfigItem* newItem = Clone();
 392
 393     for ( wxObjectList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() )
 394     {
 395         ctConfigItem* child = (ctConfigItem*) node->GetData();
 396         ctConfigItem* newChild = child->DeepClone();
 397         newItem->AddChild(newChild);
 398     }
 399     return newItem;
 400 }
 401
 402 /// Detach: remove from parent, and remove tree items
 403 void ctConfigItem::Detach()
 404 {
 405     if (GetParent())
 406         GetParent()->RemoveChild(this);
 407     else
 408         GetDocument()->SetTopItem(NULL);
 409     SetParent(NULL);
 410
 411     wxTreeItemId treeItem = GetTreeItemId();
 412
 413     DetachFromTree();
 414
 415     // Will delete the branch, but not the config items.
 416     wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->Delete(treeItem);
 417 }
 418
 419 /// Hide from tree: make sure tree deletions won't delete
 420 /// the config items
 421 void ctConfigItem::DetachFromTree()
 422 {
 423     wxTreeItemId item = GetTreeItemId();
 424
 425     ctTreeItemData* data = (ctTreeItemData*) wxGetApp().GetMainFrame()->GetConfigTreeCtrl()->GetItemData(item);
 426     data->SetConfigItem(NULL);
 427     m_treeItemId = wxTreeItemId();
 428
 429     for ( wxObjectList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() )
 430     {
 431         ctConfigItem* child = (ctConfigItem*) node->GetData();
 432         child->DetachFromTree();
 433     }
 434 }
 435
 436 /// Attach: insert after the given position
 437 void ctConfigItem::Attach(ctConfigItem* parent, ctConfigItem* insertBefore)
 438 {
 439     if (parent)
 440     {
 441         SetParent(parent);
 442         wxObjectList::compatibility_iterator node = (wxObjectList::compatibility_iterator)NULL;
 443         if (insertBefore)
 444             node = parent->GetChildren().Member(insertBefore);
 445
 446         if (node)
 447             parent->GetChildren().Insert(node, this);
 448         else
 449             parent->GetChildren().Append(this);
 450     }
 451     else
 452     {
 453         GetDocument()->SetTopItem(this);
 454     }
 455 }
 456
 457 /// Can have children?
 458 bool ctConfigItem::CanHaveChildren() const
 459 {
 460     return (GetType() == ctTypeGroup ||
 461             GetType() == ctTypeCheckGroup ||
 462             GetType() == ctTypeRadioGroup);
 463 }
 464
 465 // An item is in the active context if:
 466 // The context field is empty; or
 467 // The context field contains a symbol that is currently enabled.
 468 bool ctConfigItem::IsInActiveContext()
 469 {
 470     wxString context = GetPropertyString(wxT("context"));
 471     if (context.IsEmpty())
 472         return true;
 473
 474     wxList contextItems;
 475     StringToItems(GetDocument()->GetTopItem(), context, contextItems);
 476
 477     for ( wxObjectList::compatibility_iterator node = contextItems.GetFirst(); node; node = node->GetNext() )
 478     {
 479         ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 480         if (otherItem->IsEnabled())
 481             return true;
 482     }
 483     return false;
 484 }
 485
 486 /// Evaluate the requires properties:
 487 /// if any of the 'requires' items are disabled,
 488 /// then this one is disabled (and inactive).
 489 void ctConfigItem::EvaluateDependencies()
 490 {
 491     // For debugging purposes
 492     wxString name = GetName();
 493     wxList items;
 494     wxString requires = GetPropertyString(wxT("requires"));
 495     wxString precludes = GetPropertyString(wxT("precludes"));
 496     wxString enabledIf = GetPropertyString(wxT("enabled-if"));
 497     wxString enabledIfNot = GetPropertyString(wxT("enabled-if-not"));
 498     wxString indeterminateIf = GetPropertyString(wxT("indeterminate-if"));
 499
 500     bool active = true;
 501     bool enabled = IsEnabled();
 502     bool oldEnabled = enabled;
 503     bool oldActive = IsActive();
 504     bool explicitlyEnabled = false;
 505     bool explicitlyDisabled = false;
 506     bool inActiveContext = IsInActiveContext();
 507
 508     // Add the parent to the list of dependencies, if the
 509     // parent is a check or radio group.
 510     ctConfigItem* parent = GetParent();
 511     if (parent &&
 512         (parent->GetType() == ctTypeCheckGroup ||
 513         parent->GetType() == ctTypeRadioGroup))
 514         items.Append(parent);
 515
 516     wxList tempItems;
 517     StringToItems(GetDocument()->GetTopItem(), requires, tempItems);
 518
 519     wxObjectList::compatibility_iterator node;
 520     for ( node = tempItems.GetFirst(); node; node = node->GetNext() )
 521     {
 522         // Only consider the dependency if both items are in
 523         // an active context.
 524         // Each is in the active context if:
 525         // The context field is empty; or
 526         // The context field contains a symbol that is currently enabled.
 527         ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 528         if (inActiveContext && otherItem->IsInActiveContext())
 529             items.Append(otherItem);
 530     }
 531
 532     {
 533         int enabledCount = 0;
 534         for ( node = items.GetFirst(); node; node = node->GetNext() )
 535         {
 536             ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 537
 538             if (otherItem->IsEnabled())
 539             {
 540                 enabledCount ++;
 541             }
 542         }
 543         if (items.GetCount() > 0 && enabledCount == 0)
 544         {
 545             // None of the items were enabled
 546             enabled = false;
 547             active = false;
 548             explicitlyDisabled = true;
 549         }
 550     }
 551
 552     items.Clear();
 553     if (!enabledIfNot.IsEmpty())
 554     {
 555         StringToItems(GetDocument()->GetTopItem(), enabledIfNot, items);
 556         int disabledCount = 0;
 557         int inContextCount = 0;
 558
 559         for ( wxObjectList::compatibility_iterator node = items.GetFirst(); node; node = node->GetNext() )
 560         {
 561             ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 562
 563             if (inActiveContext && otherItem->IsInActiveContext())
 564             {
 565                 // Make this enabled and inactive, _unless_ it's
 566                 // already been explicitly disabled in the previous
 567                 // requires evaluation (it really _has_ to be off)
 568                 if (!otherItem->IsEnabled())
 569                 {
 570                     disabledCount ++;
 571                 }
 572                 inContextCount ++;
 573             }
 574         }
 575         // Enable if there were no related items that were enabled
 576         if (inContextCount > 0 && (disabledCount == inContextCount) && !explicitlyDisabled)
 577         {
 578             explicitlyEnabled = true;
 579             enabled = true;
 580             active = false;
 581         }
 582     }
 583
 584     items.Clear();
 585     if (!enabledIf.IsEmpty())
 586     {
 587         StringToItems(GetDocument()->GetTopItem(), enabledIf, items);
 588         int enabledCount = 0;
 589         int inContextCount = 0;
 590
 591         for ( wxObjectList::compatibility_iterator node = items.GetFirst(); node; node = node->GetNext() )
 592         {
 593             ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 594             wxString otherName = otherItem->GetName();
 595
 596             if (inActiveContext && otherItem->IsInActiveContext())
 597             {
 598                 // Make this enabled and inactive, _unless_ it's
 599                 // already been explicitly disabled in the previous
 600                 // requires evaluation (it really _has_ to be off)
 601                 if (otherItem->IsEnabled())
 602                 {
 603                     enabledCount ++;
 604                 }
 605                 inContextCount ++;
 606             }
 607         }
 608         // Enable if there were no related items that were disabled
 609         if (inContextCount > 0 && (enabledCount > 0) && !explicitlyDisabled)
 610         {
 611             explicitlyEnabled = true;
 612             enabled = true;
 613             active = false;
 614         }
 615     }
 616
 617     items.Clear();
 618     if (!precludes.IsEmpty())
 619     {
 620         StringToItems(GetDocument()->GetTopItem(), precludes, items);
 621         int enabledCount = 0;
 622         // int disabledCount = 0;
 623         int inContextCount = 0;
 624
 625         for ( wxObjectList::compatibility_iterator node = items.GetFirst(); node; node = node->GetNext() )
 626         {
 627             ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 628
 629             if (inActiveContext && otherItem->IsInActiveContext())
 630             {
 631                 // Make this disabled and inactive, _unless_ it's
 632                 // already been explicitly enabled in the previous
 633                 // requires evaluation (it really _has_ to be on)
 634 //                if (!otherItem->IsEnabled())
 635                 if (otherItem->IsEnabled())
 636                 {
 637                     enabledCount ++;
 638                     // disabledCount ++;
 639                 }
 640                 inContextCount ++;
 641             }
 642         }
 643         // Disable if there were no related items that were disabled
 644         if (inContextCount > 0 && (enabledCount > 0) && !explicitlyEnabled)
 645 //        if (inContextCount > 0 && (disabledCount > 0) && !explicitlyEnabled)
 646         {
 647             enabled = false;
 648             active = false;
 649             explicitlyDisabled = true;
 650         }
 651     }
 652
 653     // Indeterminate overrides the others, and
 654     // makes the item active.
 655     items.Clear();
 656     if (!indeterminateIf.IsEmpty())
 657     {
 658         StringToItems(GetDocument()->GetTopItem(), indeterminateIf, items);
 659         int enabledCount = 0;
 660         int inContextCount = 0;
 661
 662         for ( wxObjectList::compatibility_iterator node = items.GetFirst(); node; node = node->GetNext() )
 663         {
 664             ctConfigItem* otherItem = (ctConfigItem*) node->GetData();
 665
 666             if (inActiveContext && otherItem->IsInActiveContext())
 667             {
 668                 if (otherItem->IsEnabled())
 669                 {
 670                     enabledCount ++;
 671                 }
 672                 inContextCount ++;
 673             }
 674         }
 675         if (inContextCount > 0 && enabledCount > 0)
 676         {
 677             active = true;
 678             explicitlyEnabled = false;
 679             explicitlyDisabled = false;
 680         }
 681     }
 682
 683     // Finally check a sort of dependency: whether our
 684     // context is active. If not, make this inactive.
 685     if (!IsInActiveContext())
 686         active = false;
 687     else
 688     {
 689         // If we didn't explicitly enable or disable it,
 690         // then we should make it active.
 691         if (!explicitlyEnabled && !explicitlyDisabled)
 692             active = true;
 693     }
 694
 695     SetActive(active);
 696
 697     // If going active, set enabled state to the default state
 698     if (active &&
 699         oldActive != active &&
 700         (GetType() == ctTypeBoolCheck || GetType() == ctTypeCheckGroup) &&
 701         m_properties.FindProperty(wxT("default-state")))
 702     {
 703         bool defaultState = m_properties.FindProperty(wxT("default-state"))->GetVariant().GetBool();
 704         enabled = defaultState;
 705     }
 706     Enable(enabled);
 707
 708     // Deal with setting a radio button
 709     if (enabled && enabled != oldEnabled &&
 710         (GetType() == ctTypeBoolRadio || GetType() == ctTypeRadioGroup))
 711     {
 712         wxList considered;
 713         PropagateRadioButton(considered);
 714     }
 715 }
 716
 717 /// Get description, which may be dynamically
 718 /// generated depending on the property.
 719 wxString ctConfigItem::GetDescription(ctProperty* property)
 720 {
 721     if (property->GetName() == wxT("description"))
 722     {
 723         wxString value(property->GetValue());
 724         if (value.IsEmpty())
 725             return wxT("Double-click on <B>description</B> to write a brief explanation of the setting.<P>");
 726         else
 727             return value;
 728     }
 729     else if (property->GetName() == wxT("notes"))
 730     {
 731         wxString value(property->GetValue());
 732         if (value.IsEmpty())
 733             return wxT("Double-click on <B>notes</B> to write notes about this setting.<P>");
 734         else
 735             return value;
 736     }
 737     return property->GetDescription();
 738 }
 739
 740 /// Get the title for the property editor
 741 wxString ctConfigItem::GetTitle()
 742 {
 743     wxString title(GetName());
 744     if (GetType() == ctTypeCheckGroup ||
 745         GetType() == ctTypeRadioGroup ||
 746         GetType() == ctTypeBoolCheck ||
 747         GetType() == ctTypeBoolRadio)
 748     {
 749         if (IsEnabled())
 750             title = title + _T(" - enabled");
 751         else
 752             title = title + _T(" - disabled");
 753     }
 754     return title;
 755 }
 756
 757 /// Propagate a change in enabled/disabled status
 758 void ctConfigItem::PropagateChange(wxList& considered)
 759 {
 760     if (GetType() == ctTypeCheckGroup ||
 761         GetType() == ctTypeRadioGroup ||
 762         GetType() == ctTypeBoolCheck ||
 763         GetType() == ctTypeBoolRadio)
 764     {
 765         // TODO: what about string, integer? Can they have
 766         // dependencies?
 767
 768         for ( wxObjectList::compatibility_iterator node = GetDependents().GetFirst(); node; node = node->GetNext() )
 769         {
 770             ctConfigItem* child = (ctConfigItem*) node->GetData();
 771
 772             // Avoid loops
 773             if (!considered.Member(child))
 774             {
 775                 considered.Append(child);
 776
 777                 child->EvaluateDependencies();
 778                 child->Sync();
 779
 780                 child->PropagateChange(considered);
 781             }
 782         }
 783     }
 784 }
 785
 786 /// Process radio button selection
 787 void ctConfigItem::PropagateRadioButton(wxList& considered)
 788 {
 789     if ((GetType() == ctTypeBoolRadio || GetType() == ctTypeRadioGroup) && IsEnabled())
 790     {
 791         wxString mutuallyExclusive(GetPropertyString(wxT("exclusivity")));
 792
 793         wxList list;
 794         StringToItems(GetDocument()->GetTopItem(), mutuallyExclusive, list);
 795
 796         for ( wxObjectList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
 797         {
 798             ctConfigItem* child = (ctConfigItem*) node->GetData();
 799             if (child->IsEnabled() && child != this)
 800             {
 801                 child->Enable(false);
 802                 child->Sync();
 803
 804                 if (!considered.Member(child))
 805                     child->PropagateChange(considered);
 806             }
 807         }
 808     }
 809 }