bool ecConfigItem::SetValue(const wxString& value, CdlTransaction transaction/*=NULL*/) { wxASSERT ((m_optionType == ecString) || (m_optionType == ecEnumerated)); const CdlValuable valuable = GetCdlValuable(); wxASSERT (valuable); const std::string str = value.c_str(); if(transaction){ if (CdlValueFlavor_BoolData == valuable->get_flavor ()){ // set the user bool to the current bool when changing a booldata // value to avoid a possible change in the current bool valuable->set_enabled_and_value (transaction, valuable->is_enabled (), str, CdlValueSource_User); } else {// CdlValueFlavor_Data valuable->set_value (transaction, str, CdlValueSource_User); } } else { if (CdlValueFlavor_BoolData == valuable->get_flavor ()){ // set the user bool to the current bool when changing a booldata // value to avoid a possible change in the current bool valuable->set_enabled_and_value (valuable->is_enabled (), str, CdlValueSource_User); } else {// CdlValueFlavor_Data valuable->set_value (str, CdlValueSource_User); } } // TODO: eliminate m_value, since the value is always taken from the Cdl object. m_value = value; return TRUE; }
bool ecConfigItem::SetValue (long nValue, CdlTransaction transaction/*=NULL*/) { wxASSERT (m_optionType == ecLong); const CdlValuable valuable = GetCdlValuable(); wxASSERT (valuable); if(transaction) { if (CdlValueFlavor_BoolData == valuable->get_flavor ()) { // set the user bool to the current bool when changing a booldata // value to avoid a possible change in the current bool valuable->set_enabled_and_value (transaction, valuable->is_enabled (), (cdl_int) nValue, CdlValueSource_User); } else { // CdlValueFlavor_Data valuable->set_integer_value (transaction, nValue, CdlValueSource_User); } } else { if (CdlValueFlavor_BoolData == valuable->get_flavor ()) { // set the user bool to the current bool when changing a booldata // value to avoid a possible change in the current bool valuable->set_enabled_and_value (valuable->is_enabled (), (cdl_int) nValue, CdlValueSource_User); } else { // CdlValueFlavor_Data valuable->set_integer_value (nValue, CdlValueSource_User); } } // TODO: BoolData? m_value = nValue; return TRUE; }
const wxString ecConfigItem::StringValue (CdlValueSource source /* = CdlValueSource_Current */ ) const { // wxASSERT (!IsPackage()); // not a package item const CdlValuable valuable = GetCdlValuable(); wxASSERT (valuable); wxString strValue (wxT("")); switch (valuable->get_flavor ()) { case CdlValueFlavor_Data: case CdlValueFlavor_BoolData: case CdlValueFlavor_None: // a package if (m_optionType == ecLong) strValue = ecUtils::IntToStr (Value (), wxGetApp().GetSettings().m_bHex); else if (m_optionType == ecDouble) strValue = ecUtils::DoubleToStr (DoubleValue ()); else strValue = valuable->get_value (source).c_str (); break; default: wxASSERT (0); // specified flavor not supported } return strValue; }
bool ecConfigItem::SetEnabled(bool bEnabled, CdlTransaction current_transaction/*=NULL*/) { const CdlValuable valuable = GetCdlValuable(); wxASSERT (valuable); // use a transaction object to ensure that all config items are changed together CdlTransaction transaction = current_transaction ? current_transaction : CdlTransactionBody::make (wxGetApp().GetConfigToolDoc ()->GetCdlConfig ()); if (HasRadio () && bEnabled) { // if a new radio button has been selected for (ecConfigItem *pItem = FirstRadio(); pItem; pItem = pItem->NextRadio ()) { // for each radio button in the group if (pItem != this) { // if not the newly selected radio button pItem->SetEnabled (FALSE, transaction); // disable the radio button } } } if (CdlValueFlavor_BoolData == valuable->get_flavor ()) { // set the user value to the current data value when enabling/disabling // a booldata item to avoid a possible change in the current data value CdlSimpleValue simple_value = valuable->get_simple_value (); valuable->set_enabled_and_value (transaction, bEnabled, simple_value, CdlValueSource_User); } else { // CdlValueFlavor_Bool valuable->set_enabled (transaction, bEnabled, CdlValueSource_User); } if (! current_transaction) { // if not a recursive call to disable a radio button transaction->body (); // commit the transaction delete transaction; transaction = NULL; } return TRUE; }
void CFailingRulesDialog::AddConflictSolutions(CdlConflict conflict) { SolutionInfo &info=Info(conflict); const std::vector<std::pair<CdlValuable, CdlValue> >&Solution=conflict->get_solution(); int i=0; for (std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator soln_i = Solution.begin(); soln_i != Solution.end(); soln_i++) { CdlValuable valuable = soln_i->first; CdlValue value=soln_i->second; CdlValueFlavor flavor = valuable->get_flavor(); CString strValue; switch(flavor) { case CdlValueFlavor_None : break; case CdlValueFlavor_Bool : strValue=value.is_enabled() ? _T("Enabled") : _T("Disabled"); break; case CdlValueFlavor_BoolData : strValue.Format(_T("%s, %s"), value.is_enabled() ? _T("Enabled") : _T("Disabled"), CString(value.get_value().c_str())); break; case CdlValueFlavor_Data : strValue=value.get_value().c_str(); break; } const CString strName(soln_i->first->get_name().c_str()); LVFINDINFO fi; fi.flags=LVFI_STRING; fi.psz=strName; int nIndex=m_List.FindItem(&fi); if(-1==nIndex || strValue!=m_List.GetItemText(nIndex,1)){ // We don't have an existing solution that matches this one nIndex=m_List.GetItemCount(); m_List.InsertItem(nIndex,strName); m_List.SetItemData(nIndex,1); m_List.SetItemText(nIndex,1,strValue); ASSERT(info.arItem[i]<0); m_List.SetCheck(nIndex,SolutionInfo::CHECKED==info.arItem[i]); } else { // We do - to avoid duplicates, increment the "ref count" m_List.SetItemData(nIndex,m_List.GetItemData(nIndex)+1); } info.arItem[i++]=nIndex; } if(0==i){ SetDlgItemText(IDC_STATIC1,_T("No solution is available for this conflict")); m_List.ShowWindow(SW_HIDE); } else { SetDlgItemText(IDC_STATIC1,_T("Proposed solution:")); m_List.ShowWindow(SW_SHOW); m_List.SetColumnWidth(0,LVSCW_AUTOSIZE); CRect rect; m_List.GetClientRect(rect); m_List.SetColumnWidth(1,rect.Width()-m_List.GetColumnWidth(0)); } }
bool ecConfigItem::HasBool() const { if (!m_CdlItem) { return FALSE; } else if (IsPackage()) { return FALSE; } else { const CdlValuable valuable = GetCdlValuable(); CdlValueFlavor flavor = valuable->get_flavor (); return (flavor == CdlValueFlavor_Bool) || (flavor == CdlValueFlavor_BoolData); } }
void ecSplitterScrolledWindow::RestoreDefault(wxTreeItemId h, bool bRecurse /* = FALSE */, bool bTopLevel /* = TRUE */) { ecConfigTreeCtrl* treeCtrl = (ecConfigTreeCtrl*) FindWindow(ecID_TREE_CTRL); wxASSERT (treeCtrl != NULL) ; ecConfigItem* ti = ((ecTreeItemData*) treeCtrl->GetItemData(h))->GetConfigItem(); const CdlValuable valuable = ti->GetCdlValuable(); if (valuable && (CdlValueFlavor_None != valuable->get_flavor ())) // skip the root node and nodes without a value valuable->set_source (CdlValueSource_Default); treeCtrl->SetItemText (h, ti->GetItemNameOrMacro ()); // remove asterisk in control view if (bTopLevel && ti->HasRadio ()) // if user-specified item is a radio button { for (ecConfigItem * pItem = ti->FirstRadio (); pItem; pItem = pItem->NextRadio ()) { if (ti != pItem) { const CdlValuable valuable = pItem->GetCdlValuable(); wxASSERT (valuable); valuable->set_source (CdlValueSource_Default); // restore default for each sibling radio button treeCtrl->SetItemText (pItem->GetTreeItem(), pItem->GetItemNameOrMacro ()); // remove asterisk in control view } } } if (bRecurse) { long cookie; for (h = treeCtrl->GetFirstChild(h, cookie); h; h = treeCtrl->GetNextSibling(h)) { RestoreDefault (h, TRUE, FALSE); } } }
long ecConfigItem::Value () const { wxASSERT (!IsPackage()); // not a package item const CdlValuable valuable = GetCdlValuable(); wxASSERT (valuable); long nValue (0); switch (valuable->get_flavor ()) { // case CdlValueFlavor_Bool: // nValue = valuable->is_enabled (CdlValueSource_Current) ? 1 : 0; // break; case CdlValueFlavor_BoolData: case CdlValueFlavor_Data: nValue = (long) valuable->get_integer_value (CdlValueSource_Current); break; default: wxASSERT (0); // specified flavor not supported } return nValue; }
// Convert from Cdl to internal representation bool ecConfigItem::ConvertFromCdl() { if (!GetCdlItem()) return FALSE; m_name = GetCdlItem()->get_display ().c_str (); m_macro = GetCdlItem()->get_name().c_str(); m_strDescr = ecUtils::StripExtraWhitespace (wxString (GetCdlItem()->get_description ().c_str ())); // FIXME: re-implement using CdlValuableBody::get_widget_hint() // (comment from original MFC configtool) if (IsPackage()) { // If a package item, display the package version string m_optionType = ecString; m_configType = ecPackage; m_optionFlavor = ecFlavorNone; } else { const CdlValuable valuable = dynamic_cast<CdlValuable> (GetCdlItem()); switch (valuable->get_flavor ()){ case CdlValueFlavor_None: m_optionFlavor = ecFlavorNone; m_optionType=ecOptionTypeNone; //??? Shouldn't it be ecBool for CdlValueFlavor_Bool? m_configType = ecContainer; break; case CdlValueFlavor_Bool: m_optionFlavor = ecFlavorBool; m_optionType=ecOptionTypeNone; //??? Shouldn't it be ecBool for CdlValueFlavor_Bool? m_configType = ecOption; m_hint = (HasRadio() ? ecHintRadio : ecHintCheck); break; case CdlValueFlavor_Data: case CdlValueFlavor_BoolData: m_optionFlavor = (valuable->get_flavor() == CdlValueFlavor_Data ? ecFlavorData : ecFlavorBoolData); m_configType = ecOption; m_hint = (HasRadio() ? ecHintRadio : ecHintCheck); if (! valuable->has_legal_values ()) { m_optionType=ecString; } else if (0 == valuable->get_legal_values ()->ranges.size ()) { m_optionType=ecEnumerated; } else { CdlListValue list_value; CdlEvalContext context (NULL, valuable, valuable->get_property (CdlPropertyId_LegalValues)); valuable->get_legal_values ()->eval (context, list_value); m_optionType=list_value.get_double_ranges ().size () ? ecDouble : ecLong; } break; default: wxASSERT (0); // specified flavor not supported break; } } m_active = IsActive(); m_enabled = IsEnabled(); m_modifiable = IsModifiable(); return TRUE; }
void ecResolveConflictsDialog::AddConflictSolutions(CdlConflict conflict) { // SolutionInfo allows each conflict to know which solutions have been found for it SolutionInfo &info=Info(conflict); const std::vector<std::pair<CdlValuable, CdlValue> >&Solution=conflict->get_solution(); int i=0; for (std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator soln_i = Solution.begin(); soln_i != Solution.end(); soln_i++) { CdlValuable valuable = soln_i->first; CdlValue value = soln_i->second; CdlValueFlavor flavor = valuable->get_flavor(); wxString strValue; switch(flavor) { case CdlValueFlavor_None : break; case CdlValueFlavor_Bool : strValue = value.is_enabled() ? _("Enabled") : _("Disabled"); break; case CdlValueFlavor_BoolData : strValue.Printf(wxT("%s, %s"), (const wxChar*) (value.is_enabled() ? _("Enabled") : _("Disabled")), (const wxChar*) value.get_value().c_str()); break; case CdlValueFlavor_Data : strValue = value.get_value().c_str(); break; } const wxString strName(soln_i->first->get_name().c_str()); long nIndex = m_solutionsCtrl->FindItem(0, strName); wxListItem listItem; listItem.m_mask = wxLIST_MASK_TEXT; listItem.m_itemId = nIndex; listItem.m_col = 1; if (nIndex != -1) m_solutionsCtrl->GetItem(listItem); if (-1 == nIndex || strValue != listItem.m_text) { // We don't have an existing solution that matches this one nIndex = m_solutionsCtrl->GetItemCount(); m_solutionsCtrl->InsertItem(nIndex, strName); m_solutionsCtrl->SetItemData(nIndex, 1); m_solutionsCtrl->SetItem(nIndex, 1, strValue); wxASSERT(info.arItem[i]<0); m_solutionsCtrl->SetChecked(nIndex, SolutionInfo::CHECKED==info.arItem[i]); } else { // We do - to avoid duplicates, increment the "ref count" m_solutionsCtrl->SetItemData(nIndex, m_solutionsCtrl->GetItemData(nIndex)+1); } info.arItem[i++]=nIndex; } wxStaticText* staticCtrl = (wxStaticText*) FindWindow(ecID_CONFLICTS_MSG); if(0==i){ staticCtrl->SetLabel(_("No solution is available for this conflict")); m_solutionsCtrl->Show(FALSE); } else { staticCtrl->SetLabel(_("Proposed solution:")); m_solutionsCtrl->Show(TRUE); // TODO (if necessary) #if 0 m_List.SetColumnWidth(0,LVSCW_AUTOSIZE); CRect rect; m_List.GetClientRect(rect); m_List.SetColumnWidth(1,rect.Width()-m_List.GetColumnWidth(0)); #endif } }
void ecResolveConflictsDialog::OnContinue(wxCommandEvent& event) { // Ensure we have the current conflict check array int i; for (i = 0; i < m_conflictsCtrl->GetItemCount(); i++) { if (m_conflictsCtrl->GetItemState(i, wxLIST_STATE_SELECTED) & wxLIST_STATE_SELECTED) RemoveConflictSolutions((CdlConflict) m_conflictsCtrl->GetItemData(i)); } // Dismiss the window EndModal(wxID_OK); std::list<CdlConflict>::const_iterator conf_i; for (conf_i= m_conflicts.begin (); conf_i != m_conflicts.end (); conf_i++) // for each conflict { CdlConflict conflict=*conf_i; //int nSolutions=conflict->get_solution().size(); SolutionInfo &info=Info(conflict); int nIndex=0; const std::vector<std::pair<CdlValuable, CdlValue> >&Solution=conflict->get_solution(); for (std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator soln_i = Solution.begin();soln_i != Solution.end(); soln_i++) { if(SolutionInfo::CHECKED==info.arItem[nIndex++]){ CdlValuable valuable = soln_i->first; CdlValue value=soln_i->second; CdlValueFlavor flavor = valuable->get_flavor(); const wxString strName(valuable->get_name().c_str()); const wxString strValue(value.get_value().c_str()); bool rc = TRUE; wxString str; try { switch(flavor) { case CdlValueFlavor_None : str = wxT("set CdlValueFlavor_None"); rc = FALSE; break; case CdlValueFlavor_Bool : str.Printf(_("%s %s\n"), (const wxChar*) (value.is_enabled()?_("disable"):_("enable")), (const wxChar*) strName); valuable->set_enabled (m_Transaction, value.is_enabled(), CdlValueSource_User); break; case CdlValueFlavor_BoolData : { bool bEnabled=value.is_enabled(); str.Printf(_("%s %s and set value to %s\n"), (const wxChar*) (bEnabled? _("disable"):_("enable")), (const wxChar*) strName, (const wxChar*) strValue); // Surely this is wrong - we don't want to set the same value, we want to // set a NEW value. // CdlSimpleValue simple_value = valuable->get_simple_value (); //valuable->set_enabled_and_value (m_Transaction, bEnabled, simple_value, CdlValueSource_User); valuable->set_enabled_and_value (m_Transaction, bEnabled, ecUtils::UnicodeToStdStr (strValue), CdlValueSource_User); } break; case CdlValueFlavor_Data : str.Printf(_("set %s to %s\n"), (const wxChar*) strName, (const wxChar*) strValue); valuable->set_value (m_Transaction, ecUtils::UnicodeToStdStr (strValue), CdlValueSource_User); break; } } catch(...) { rc = FALSE; } if(rc) { wxGetApp().GetConfigToolDoc()->Modify(TRUE); } else { wxString msg; msg.Printf(_("Failed to %s\n"), (const wxChar*) str); wxMessageBox(msg, wxGetApp().GetSettings().GetAppName(), wxICON_EXCLAMATION|wxOK); } } } } }
void CFailingRulesDialog::OnOK() { // Ensure we have the current conflict check array for(POSITION pos = m_RulesList.GetFirstSelectedItemPosition();pos;){ int nItem = m_RulesList.GetNextSelectedItem(pos); RemoveConflictSolutions((CdlConflict)m_RulesList.GetItemData(nItem)); } // Dismiss the window CeCosDialog::OnOK(); for (std::list<CdlConflict>::const_iterator conf_i= m_conflicts.begin (); conf_i != m_conflicts.end (); conf_i++) { // for each conflict CdlConflict conflict=*conf_i; //int nSolutions=conflict->get_solution().size(); SolutionInfo &info=Info(conflict); int nIndex=0; const std::vector<std::pair<CdlValuable, CdlValue> >&Solution=conflict->get_solution(); for (std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator soln_i = Solution.begin();soln_i != Solution.end(); soln_i++) { if(SolutionInfo::CHECKED==info.arItem[nIndex++]){ CdlValuable valuable = soln_i->first; CdlValue value=soln_i->second; CdlValueFlavor flavor = valuable->get_flavor(); const CString strName(valuable->get_name().c_str()); const CString strValue(value.get_value().c_str()); bool rc=true; CString str; try { switch(flavor) { case CdlValueFlavor_None : str=_T("set CdlValueFlavor_None"); rc=false; break; case CdlValueFlavor_Bool : str.Format(_T("%s %s\n"),value.is_enabled()?_T("disable"):_T("enable"),strName); valuable->set_enabled (m_Transaction, value.is_enabled(), CdlValueSource_User); break; case CdlValueFlavor_BoolData : { bool bEnabled=value.is_enabled(); str.Format(_T("%s %s and set value to %s\n"),bEnabled?_T("disable"):_T("enable"),strName,strValue); // This is wrong: it should set the NEW value. This is the cause of a long-standing bug... // CdlSimpleValue simple_value = valuable->get_simple_value (); //valuable->set_enabled_and_value (m_Transaction, bEnabled, simple_value, CdlValueSource_User); valuable->set_enabled_and_value (m_Transaction, bEnabled, CUtils::UnicodeToStdStr (strValue), CdlValueSource_User); } break; case CdlValueFlavor_Data : str.Format(_T("set %s to %s\n"),strName,strValue); valuable->set_value (m_Transaction, CUtils::UnicodeToStdStr (strValue), CdlValueSource_User); break; } } catch(...){ rc=false; } if(rc){ CConfigTool::GetConfigToolDoc()->SetModifiedFlag(); } else { CUtils::MessageBoxF(_T("Failed to %s\n"),str); } } } } }