Fawkes API Fawkes Development Version
|
00001 00002 /*************************************************************************** 00003 * config_tree_view.cpp - TreeView class for displaying the configuration 00004 * 00005 * Created: Wed Sep 24 13:45:39 2008 00006 * Copyright 2008 Daniel Beck 00007 * 00008 ****************************************************************************/ 00009 00010 /* This program is free software; you can redistribute it and/or modify 00011 * it under the terms of the GNU General Public License as published by 00012 * the Free Software Foundation; either version 2 of the License, or 00013 * (at your option) any later version. 00014 * 00015 * This program is distributed in the hope that it will be useful, 00016 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00017 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00018 * GNU Library General Public License for more details. 00019 * 00020 * Read the full text in the LICENSE.GPL file in the doc directory. 00021 */ 00022 00023 #include "config_tree_view.h" 00024 #include "config_edit_dialog.h" 00025 #include "config_add_dialog.h" 00026 #include "config_remove_dialog.h" 00027 #include "config_editor_plugin.h" 00028 00029 #include <core/exceptions/system.h> 00030 #include <config/netconf.h> 00031 #include <config/sqlite.h> 00032 #include <netcomm/fawkes/client.h> 00033 00034 #include <cstring> 00035 #include <iostream> 00036 #include <sstream> 00037 00038 using namespace std; 00039 using namespace fawkes; 00040 00041 /** @class ConfigTreeView tools/config_editor/config_tree_view.h 00042 * Treeview widget for displaying/editing config entries. 00043 * 00044 * @author Daniel Beck 00045 */ 00046 00047 /** @class ConfigTreeView::ConfigRecord tools/config_editor/config_tree_view.h 00048 * Column record class for the config TreeView. 00049 * 00050 * @author Daniel Beck 00051 */ 00052 00053 /** @var ConfigTreeView::m_config_record 00054 * Column record object to access the columns of the storage object. 00055 */ 00056 00057 /** @var ConfigTreeView::m_config_tree 00058 * Storage object. 00059 */ 00060 00061 /** @var ConfigTreeView::m_menu 00062 * A popup menu to edit the configuration. 00063 */ 00064 00065 /** @var ConfigTreeView::m_dlg_edit 00066 * A dialog to edit a config entry. 00067 */ 00068 00069 /** @var ConfigTreeView::m_dlg_add 00070 * A dialog to add a config entry. 00071 */ 00072 00073 /** @var ConfigTreeView::m_dlg_remove 00074 * A dialog to remove a config entry. 00075 */ 00076 00077 /** @var ConfigTreeView::m_config 00078 * The fawkes::Configuration that is displayed and editted. 00079 */ 00080 00081 /** @var ConfigTreeView::m_own_config 00082 * True if config was created by ConfigTreeView object. 00083 */ 00084 00085 /** @var ConfigTreeView::m_plugins 00086 * A map of registered plugins: config-prefix => config editor plugin. 00087 */ 00088 00089 /** Constructor. 00090 * @param cobject pointer to base object type 00091 * @param ref_xml Glade XML file 00092 */ 00093 ConfigTreeView::ConfigTreeView( BaseObjectType* cobject, 00094 const Glib::RefPtr<Gnome::Glade::Xml>& ref_xml) 00095 : Gtk::TreeView(cobject) 00096 { 00097 m_dlg_edit = NULL; 00098 ref_xml->get_widget_derived("dlgConfigEdit", m_dlg_edit); 00099 00100 m_dlg_add = NULL; 00101 ref_xml->get_widget_derived("dlgConfigAdd", m_dlg_add); 00102 00103 m_dlg_remove = NULL; 00104 ref_xml->get_widget_derived("dlgConfigRemove", m_dlg_remove); 00105 00106 m_config_tree = Gtk::TreeStore::create(m_config_record); 00107 m_config_tree->set_sort_column(0, Gtk::SORT_ASCENDING); 00108 00109 set_model(m_config_tree); 00110 append_column("Path", m_config_record.node); 00111 00112 Gtk::TreeViewColumn *column = get_column(0); 00113 Gtk::CellRendererText *cell = (Gtk::CellRendererText *)column->get_first_cell_renderer(); 00114 #ifdef GLIBMM_PROPERTIES_ENABLED 00115 column->add_attribute(cell->property_underline(), m_config_record.is_default); 00116 #else 00117 column->add_attribute(*cell, "underline", m_config_record.is_default); 00118 #endif 00119 00120 append_column("Value", m_config_record.value_string); 00121 00122 Gtk::Menu::MenuList& menulist = m_menu.items(); 00123 00124 menulist.push_back( Gtk::Menu_Helpers::MenuElem("Edit", sigc::mem_fun( *this, &ConfigTreeView::on_menu_edit_selected) ) ); 00125 menulist.push_back( Gtk::Menu_Helpers::MenuElem("Remove", sigc::mem_fun( *this, &ConfigTreeView::on_menu_remove_selected) ) ); 00126 menulist.push_back( Gtk::Menu_Helpers::MenuElem("Add", sigc::mem_fun( *this, &ConfigTreeView::on_menu_add_selected) ) ); 00127 00128 m_config = NULL; 00129 m_own_config = false; 00130 00131 signal_button_press_event().connect_notify( sigc::mem_fun(*this, &ConfigTreeView::on_button_press_event_custom) ); 00132 } 00133 00134 /** Destructor. */ 00135 ConfigTreeView::~ConfigTreeView() 00136 { 00137 if (m_own_config) 00138 { delete m_config; } 00139 00140 for ( std::map< string, ConfigEditorPlugin* >::iterator iter = m_plugins.begin(); 00141 iter != m_plugins.end(); 00142 ++iter ) 00143 { delete iter->second; } 00144 } 00145 00146 /** Set the fawkes::Configuration to be displayed. 00147 * @param config the fawkes::Configuration; set it to NULL to signal 00148 * the unavailability of the config 00149 */ 00150 void 00151 ConfigTreeView::set_config(Configuration* config) 00152 { 00153 if ( config ) 00154 { 00155 m_config = config; 00156 m_own_config = false; 00157 00158 // TODO: enable mirror mode if it is a netconf 00159 read_config(); 00160 } 00161 else 00162 { 00163 delete m_config; 00164 m_config = NULL; 00165 m_config_tree->clear(); 00166 } 00167 00168 for ( std::map< string, ConfigEditorPlugin* >::iterator i = m_plugins.begin(); 00169 i != m_plugins.end(); 00170 ++i ) 00171 { i->second->set_config( m_config ); } 00172 } 00173 00174 /** Set a network client that is used to open a fawkes::NetworkConfiguration. 00175 * @param client a fawkes::NetworkClient; set it to NULL to signal the 00176 * unavailability of the client 00177 */ 00178 void 00179 ConfigTreeView::set_network_client(FawkesNetworkClient* client) 00180 { 00181 if (client) 00182 { 00183 NetworkConfiguration* netconf = new NetworkConfiguration(client); 00184 netconf->set_mirror_mode(true); 00185 m_config = netconf; 00186 m_own_config = true; 00187 00188 read_config(); 00189 } 00190 else 00191 { 00192 delete m_config; 00193 m_config = NULL; 00194 m_config_tree->clear(); 00195 } 00196 00197 for ( std::map< string, ConfigEditorPlugin* >::iterator i = m_plugins.begin(); 00198 i != m_plugins.end(); 00199 ++i ) 00200 { i->second->set_config( m_config ); } 00201 } 00202 00203 /** Set the file to read the config from. 00204 * @param filename the filename of the database file 00205 */ 00206 void 00207 ConfigTreeView::set_config_file(const char* filename) 00208 { 00209 m_config = new SQLiteConfiguration(filename); 00210 m_own_config = true; 00211 00212 read_config(); 00213 } 00214 00215 /** Register a plugin. 00216 * This also initializes the plugin. 00217 * @param plugin the new plugin to register 00218 */ 00219 void 00220 ConfigTreeView::register_plugin( ConfigEditorPlugin* plugin ) 00221 { 00222 plugin->initialize(); 00223 m_plugins[ plugin->get_config_path() ] = plugin; 00224 } 00225 00226 /** Remove a plugin. 00227 * @param config_path the config prefix corresponding to the plugin to 00228 * be removed 00229 */ 00230 void 00231 ConfigTreeView::remove_plugin( string config_path ) 00232 { 00233 std::map< string, ConfigEditorPlugin* >::iterator iter = m_plugins.find( config_path ); 00234 00235 if ( iter != m_plugins.end() ) 00236 { 00237 ConfigEditorPlugin* p = iter->second; 00238 m_plugins.erase( iter ); 00239 delete p; 00240 } 00241 } 00242 00243 void 00244 ConfigTreeView::read_config() 00245 { 00246 if ( !m_config ) 00247 { return; } 00248 00249 m_config_tree->clear(); 00250 00251 m_config->lock(); 00252 Configuration::ValueIterator* cit = m_config->iterator(); 00253 while ( cit->next() ) 00254 { 00255 if ( cit->is_bool() ) 00256 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_bool()); } 00257 else if ( cit->is_int() ) 00258 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_int()); } 00259 else if ( cit->is_uint() ) 00260 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_uint()); } 00261 else if ( cit->is_float() ) 00262 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_float()); } 00263 else if ( cit->is_string() ) 00264 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_string()); } 00265 } 00266 00267 delete cit; 00268 m_config->unlock(); 00269 } 00270 00271 00272 /** Add a config entry to the TreeModel storage object. 00273 * @param path config path 00274 * @param type type of config entry 00275 * @param is_default true if config entry is in the default config 00276 * @param value the value of the config entry 00277 */ 00278 void 00279 ConfigTreeView::set_value(const char* path, const char* type, bool is_default, bool value) 00280 { 00281 Gtk::TreeModel::Row row; 00282 row = *get_iter(path); 00283 00284 row[m_config_record.type] = type; 00285 row[m_config_record.is_default] = is_default; 00286 row[m_config_record.value_bool] = value; 00287 row[m_config_record.value_string] = ( value ? "TRUE" : "FALSE" ); 00288 } 00289 00290 /** Add a config entry to the TreeModel storage object. 00291 * @param path config path 00292 * @param type type of config entry 00293 * @param is_default true if config entry is in the default config 00294 * @param value the value of the config entry 00295 */ 00296 void 00297 ConfigTreeView::set_value(const char* path, const char* type, bool is_default, int value) 00298 { 00299 Gtk::TreeModel::Row row; 00300 row = *get_iter(path); 00301 00302 row[m_config_record.type] = type; 00303 row[m_config_record.is_default] = is_default; 00304 row[m_config_record.value_int] = value; 00305 00306 string val_str; 00307 stringstream ss; 00308 ss << value; 00309 ss >> val_str; 00310 row[m_config_record.value_string] = val_str; 00311 } 00312 00313 /** Add a config entry to the TreeModel storage object. 00314 * @param path config path 00315 * @param type type of config entry 00316 * @param is_default true if config entry is in the default config 00317 * @param value the value of the config entry 00318 */ 00319 void 00320 ConfigTreeView::set_value(const char* path, const char* type, bool is_default, uint value) 00321 { 00322 Gtk::TreeModel::Row row; 00323 row = *get_iter(path); 00324 00325 row[m_config_record.type] = type; 00326 row[m_config_record.is_default] = is_default; 00327 row[m_config_record.value_uint] = value; 00328 00329 string val_str; 00330 stringstream ss; 00331 ss << value; 00332 ss >> val_str; 00333 row[m_config_record.value_string] = val_str; 00334 } 00335 00336 /** Add a config entry to the TreeModel storage object. 00337 * @param path config path 00338 * @param type type of config entry 00339 * @param is_default true if config entry is in the default config 00340 * @param value the value of the config entry 00341 */ 00342 void 00343 ConfigTreeView::set_value(const char* path, const char* type, bool is_default, float value) 00344 { 00345 Gtk::TreeModel::Row row; 00346 row = *get_iter(path); 00347 00348 row[m_config_record.type] = type; 00349 row[m_config_record.is_default] = is_default; 00350 row[m_config_record.value_float] = value; 00351 00352 string val_str; 00353 stringstream ss; 00354 ss << value; 00355 ss >> val_str; 00356 row[m_config_record.value_string] = val_str; 00357 } 00358 00359 /** Add a config entry to the TreeModel storage object. 00360 * @param path config path 00361 * @param type type of config entry 00362 * @param is_default true if config entry is in the default config 00363 * @param value the value of the config entry 00364 */ 00365 void 00366 ConfigTreeView::set_value(const char* path, const char* type, bool is_default, std::string value) 00367 { 00368 Gtk::TreeModel::Row row; 00369 row = *get_iter(path); 00370 00371 row[m_config_record.type] = type; 00372 row[m_config_record.is_default] = is_default; 00373 row[m_config_record.value_string] = value; 00374 } 00375 00376 Gtk::TreeIter 00377 ConfigTreeView::get_iter(const char* p) 00378 { 00379 char* path; 00380 char* full_path; 00381 00382 if (asprintf(&full_path, "%s", p) == -1) { 00383 throw OutOfMemoryException("get_iter(): asprintf() failed"); 00384 } 00385 char* node = strtok(full_path, "/"); 00386 00387 if (asprintf(&path, "/%s", node) == -1) { 00388 throw OutOfMemoryException("get_iter(): asprintf() failed"); 00389 } 00390 00391 Gtk::TreeModel::Children children = m_config_tree->children(); 00392 Gtk::TreeIter iter = children.begin(); 00393 00394 while ( node != NULL ) 00395 { 00396 bool found = false; 00397 iter = children.begin(); 00398 00399 while ( !found && iter != children.end() ) 00400 { 00401 Gtk::TreeModel::Row row = *iter; 00402 00403 Glib::ustring r = row[m_config_record.node]; 00404 if ( strcmp(r.c_str(), node) == 0 ) 00405 { 00406 found = true; 00407 children = row.children(); 00408 iter = children.begin(); 00409 } 00410 else 00411 { ++iter; } 00412 } 00413 00414 if ( !found ) 00415 { 00416 iter = m_config_tree->append(children); 00417 Gtk::TreeModel::Row row = *iter; 00418 row[m_config_record.node] = Glib::ustring(node); 00419 row[m_config_record.path] = Glib::ustring(path); 00420 00421 children = row.children(); 00422 } 00423 00424 node = strtok(NULL, "/"); 00425 00426 char* t; 00427 if (asprintf(&t, "%s/%s", path, node) == -1) { 00428 throw OutOfMemoryException("get_iter(): asprintf() failed"); 00429 } 00430 free(path); 00431 path = t; 00432 } 00433 00434 free(path); 00435 free(full_path); 00436 00437 return iter; 00438 } 00439 00440 Gtk::TreeIter 00441 ConfigTreeView::search_path( const char* path ) 00442 { 00443 Gtk::TreeModel::Children children = m_config_tree->children(); 00444 Gtk::TreeModel::iterator iter = children.begin(); 00445 00446 while ( iter != children.end() ) 00447 { 00448 Gtk::TreeModel::Row row = *iter; 00449 Glib::ustring p = row[ m_config_record.path ]; 00450 size_t len = strlen( p.c_str() ); 00451 00452 if ( strncmp( p.c_str(), path, len) == 0 ) 00453 { 00454 if ( strcmp( p.c_str(), path ) == 0 ) 00455 { return iter; } 00456 else 00457 { iter = iter->children().begin(); } 00458 } 00459 else 00460 { ++iter; } 00461 } 00462 00463 return m_config_tree->children().end(); 00464 } 00465 00466 /** Signal handler for the button press event. 00467 * @param event a Gdk button event 00468 * @return true if signal has been handled, false otherwise 00469 */ 00470 void 00471 ConfigTreeView::on_button_press_event_custom(GdkEventButton* event) 00472 { 00473 if (event->type == GDK_2BUTTON_PRESS) 00474 { 00475 Gtk::TreeModel::Row row = *( get_selection()->get_selected() ); 00476 Glib::ustring path = row[ m_config_record.path ]; 00477 00478 std::map< string, ConfigEditorPlugin* >::iterator i = m_plugins.find( path.c_str() ); 00479 if ( i != m_plugins.end() ) 00480 { i->second->run(); } 00481 else 00482 { edit_entry( get_selection()->get_selected() ); } 00483 } 00484 else if ( event->type == GDK_BUTTON_PRESS && (event->button == 3) ) 00485 { 00486 m_menu.popup(event->button, event->time); 00487 } 00488 } 00489 00490 /** Signal handler that is called when the 'edit' entry is selected 00491 * from popup menu. 00492 */ 00493 void ConfigTreeView::on_menu_edit_selected() 00494 { 00495 edit_entry( get_selection()->get_selected() ); 00496 } 00497 00498 /** Signal handler that is called when the 'add' entry is selected 00499 * from popup menu. 00500 */ 00501 void 00502 ConfigTreeView::on_menu_add_selected() 00503 { 00504 add_entry( get_selection()->get_selected() ); 00505 } 00506 00507 /** Signal handler that is called when the 'remove' entry is selected 00508 * from popup menu. 00509 */ 00510 void 00511 ConfigTreeView::on_menu_remove_selected() 00512 { 00513 remove_entry( get_selection()->get_selected() ); 00514 } 00515 00516 bool 00517 ConfigTreeView::edit_entry(const Gtk::TreeIter& iter) 00518 { 00519 bool ret_val; 00520 00521 Gtk::TreeModel::Row row = *iter; 00522 Glib::ustring type = row[m_config_record.type]; 00523 00524 if (type == "") //if type is empty the row is a directory... 00525 { ret_val = false; } 00526 else 00527 { 00528 int result; 00529 Glib::ustring path = row[m_config_record.path]; 00530 Glib::ustring value = row[m_config_record.value_string]; 00531 bool is_default = row[m_config_record.is_default]; 00532 00533 m_dlg_edit->init(path, type, value); 00534 Gtk::Window* parent = dynamic_cast<Gtk::Window*>( get_toplevel() ); 00535 m_dlg_edit->set_transient_for(*parent); 00536 result = m_dlg_edit->run(); 00537 00538 switch (result) 00539 { 00540 case Gtk::RESPONSE_OK: 00541 { 00542 Glib::ustring value = m_dlg_edit->get_value(); 00543 00544 const char* p = path.c_str(); 00545 const char* t = type.c_str(); 00546 00547 is_default = m_dlg_edit->get_is_default(); 00548 if (is_default) m_config->erase(p); 00549 00550 if ( m_config->is_bool(p) ) 00551 { 00552 bool b = false; 00553 if (value == "TRUE") 00554 { b = true; } 00555 else if (value == "FALSE") 00556 { b = false; } 00557 00558 if (!is_default) m_config->set_bool(p, b); 00559 else m_config->set_default_bool(p, b); 00560 set_value(p, t, is_default, b); 00561 } 00562 else if ( m_config->is_int(p) ) 00563 { 00564 int i; 00565 i = atoi( value.c_str() ); 00566 00567 if (!is_default) m_config->set_int(p, i); 00568 else m_config->set_default_int(p, i); 00569 set_value(p, t, is_default, i); 00570 } 00571 else if ( m_config->is_uint(p) ) 00572 { 00573 int i; 00574 i = atoi( value.c_str() ); 00575 if ( 0 <= i) 00576 { 00577 if (!is_default) m_config->set_uint(p, (unsigned int) i); 00578 else m_config->set_default_uint( p, (unsigned int) i ); 00579 set_value(p, t, is_default, (unsigned int) i); 00580 } 00581 } 00582 else if ( m_config->is_float(p) ) 00583 { 00584 float f; 00585 f = atof( value.c_str() ); 00586 00587 if (!is_default) m_config->set_float(p, f); 00588 else m_config->set_default_float(p, f); 00589 set_value(p, t, is_default, f); 00590 } 00591 else if ( m_config->is_string(p) ) 00592 { 00593 string s( value.c_str() ); 00594 00595 if (!is_default) m_config->set_string(p, s); 00596 else m_config->set_default_string(p, s); 00597 set_value(p, t, is_default, s); 00598 } 00599 00600 ret_val = true; 00601 00602 break; 00603 } 00604 00605 default: 00606 ret_val = false; 00607 break; 00608 } 00609 00610 m_dlg_edit->hide(); 00611 } 00612 00613 return ret_val; 00614 } 00615 00616 bool 00617 ConfigTreeView::remove_entry(const Gtk::TreeIter& iter) 00618 { 00619 bool ret_val = false; 00620 int result; 00621 Gtk::TreeModel::Row row = *iter; 00622 Glib::ustring type = row[m_config_record.type]; 00623 bool is_default = row[m_config_record.is_default]; 00624 00625 if (type == "") //if type is empty the row is a directory -> return 00626 { ret_val = false; } 00627 else 00628 { 00629 Glib::ustring path = row[m_config_record.path]; 00630 m_dlg_remove->init(path, is_default); 00631 00632 Gtk::Window* parent = dynamic_cast<Gtk::Window*>( get_toplevel() ); 00633 m_dlg_remove->set_transient_for(*parent); 00634 result = m_dlg_remove->run(); 00635 00636 switch (result) 00637 { 00638 case Gtk::RESPONSE_OK: 00639 { 00640 const char* p = path.c_str(); 00641 bool rem_default = m_dlg_remove->get_remove_default(); 00642 m_config->erase(p); 00643 if (rem_default) m_config->erase_default(p); 00644 00645 Gtk::TreePath tree_path = m_config_tree->get_path(iter); 00646 m_config_tree->erase(iter); 00647 m_config_tree->row_deleted(tree_path); 00648 00649 Configuration::ValueIterator* cit = m_config->search(p); 00650 if (!rem_default && cit->next()) //reenter the default value 00651 { 00652 if ( cit->is_bool() ) 00653 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_bool()); } 00654 else if ( cit->is_int() ) 00655 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_int()); } 00656 else if ( cit->is_uint() ) 00657 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_uint()); } 00658 else if ( cit->is_float() ) 00659 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_float()); } 00660 else if ( cit->is_string() ) 00661 { set_value(cit->path(), cit->type(), cit->is_default(), cit->get_string()); } 00662 } 00663 00664 break; 00665 } 00666 00667 default: 00668 ret_val = false; 00669 break; 00670 } 00671 00672 m_dlg_remove->hide(); 00673 } 00674 00675 return ret_val; 00676 } 00677 00678 bool 00679 ConfigTreeView::add_entry(const Gtk::TreeIter& iter) 00680 { 00681 bool ret_val = false; 00682 int result; 00683 Gtk::TreeModel::Row row = *iter; 00684 Glib::ustring path = row[m_config_record.path]; 00685 00686 m_dlg_add->init(path); 00687 00688 Gtk::Window* parent = dynamic_cast<Gtk::Window*>( get_toplevel() ); 00689 m_dlg_add->set_transient_for(*parent); 00690 result = m_dlg_add->run(); 00691 00692 switch (result) 00693 { 00694 case Gtk::RESPONSE_OK: 00695 { 00696 Glib::ustring type = m_dlg_add->get_type(); 00697 Glib::ustring path = m_dlg_add->get_path(); 00698 Glib::ustring value = m_dlg_add->get_value(); 00699 bool is_default = m_dlg_add->get_is_default(); 00700 00701 const char* t = type.c_str(); 00702 const char* p = path.c_str(); 00703 00704 ret_val = true; 00705 00706 if ( type == "bool" ) 00707 { 00708 bool b = false; 00709 00710 if ( value == "TRUE" || value == "true" ) 00711 { b = true; } 00712 else if ( value == "FALSE" || value == "false" ) 00713 { b = false; } 00714 00715 if (!is_default) m_config->set_bool(p, b); 00716 else m_config->set_default_bool(p, b); 00717 set_value(p, t, is_default, b); 00718 } 00719 00720 else if ( type == "int" ) 00721 { 00722 int i; 00723 i = atoi( value.c_str() ); 00724 00725 if (!is_default) m_config->set_int(p, i); 00726 else m_config->set_default_int(p, i); 00727 set_value(p, t, is_default, i); 00728 } 00729 00730 else if ( type == "uint" ) 00731 { 00732 int i; 00733 i = atoi( value.c_str() ); 00734 if ( 0 <= i) 00735 { 00736 if (!is_default) m_config->set_uint(p, (unsigned int) i); 00737 else m_config->set_default_uint( p, (unsigned int) i); 00738 set_value(p, t, is_default, (unsigned int) i); 00739 } 00740 } 00741 00742 else if ( type == "float" ) 00743 { 00744 float f; 00745 f = atof( value.c_str() ); 00746 00747 if (!is_default) m_config->set_float(p, f); 00748 else m_config->set_default_float(p, f); 00749 set_value(p, t, is_default, f); 00750 } 00751 00752 else if ( type == "string") 00753 { 00754 string s( value.c_str() ); 00755 00756 if (!is_default) m_config->set_string(p, s); 00757 else m_config->set_default_string(p, s); 00758 set_value(p, t, is_default, s); 00759 } 00760 00761 else 00762 { 00763 ret_val = false; 00764 cout << "Unknown type." << endl; 00765 } 00766 00767 break; 00768 } 00769 00770 default: 00771 ret_val = false; 00772 break; 00773 } 00774 00775 m_dlg_add->hide(); 00776 00777 return ret_val; 00778 }