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);
}
}
}
}
}
