Src/Gtk2/DasherAppSettings.cpp

   1 #include "config.h"
   2
   3 #ifdef WITH_GCONF
   4 #include <gconf/gconf.h>
   5 #include <gconf/gconf-client.h>
   6 #include <gconf/gconf-enum-types.h>
   7 #endif
   8
   9 #include "DasherAppSettings.h"
  10 #include "../Common/AppSettingsData.h"
  11
  12 // FIXME - not sure that we're loading parameters from the registry at startup right now
  13
  14 // FIXME - shouldn't need to include this, but for now we need access to the global pointer to the dasher control.
  15
  16 #include "dasher.h"
  17 #include "GtkDasherControl.h"
  18
  19 // FIXME - should really do something to make this a singleton class
  20
  21 // TODO: Rename this file to fit in with naming conventions
  22
  23 // TODO: Bring this into the widget
  24 static GtkWidget *pDasherWidget = NULL;
  25
  26
  27 struct _DasherAppSettingsPrivate {
  28 #ifdef WITH_GCONF
  29   // GConf interface
  30   GConfClient *pGConfClient;
  31 #endif
  32   GtkDasherControl *pWidget;
  33   gboolean bWidgetSet;
  34 };
  35
  36 typedef struct _DasherAppSettingsPrivate DasherAppSettingsPrivate;
  37
  38 // Private member functions
  39
  40 static void dasher_app_settings_class_init(DasherAppSettingsClass *pClass);
  41 static void dasher_app_settings_init(DasherAppSettings *pAppSettings);
  42 static void dasher_app_settings_destroy(GObject *pObject);
  43
  44 static void dasher_app_settings_init_gconf(DasherAppSettings *pSelf, int argc, char **argv);
  45 static void dasher_app_settings_stop_gconf(DasherAppSettings *pSelf);
  46 static void dasher_app_settings_load(DasherAppSettings *pSelf);
  47
  48 // Function declarations
  49
  50 GType dasher_app_settings_get_type() {
  51
  52   static GType dasher_app_settings_type = 0;
  53
  54   if(!dasher_app_settings_type) {
  55     static const GTypeInfo dasher_app_settings_info = {
  56       sizeof(DasherAppSettingsClass),
  57       NULL,
  58       NULL,
  59       (GClassInitFunc) dasher_app_settings_class_init,
  60       NULL,
  61       NULL,
  62       sizeof(DasherAppSettings),
  63       0,
  64       (GInstanceInitFunc) dasher_app_settings_init,
  65       NULL
  66     };
  67
  68     dasher_app_settings_type = g_type_register_static(G_TYPE_OBJECT, "DasherAppSettings", &dasher_app_settings_info, static_cast < GTypeFlags > (0));
  69   }
  70
  71   return dasher_app_settings_type;
  72 }
  73
  74 static void dasher_app_settings_class_init(DasherAppSettingsClass *pClass) {
  75   GObjectClass *pObjectClass = (GObjectClass *) pClass;
  76   pObjectClass->finalize = dasher_app_settings_destroy;
  77 }
  78
  79 static void dasher_app_settings_init(DasherAppSettings *pDasherControl) {
  80   DasherAppSettingsPrivate *pPrivate = new DasherAppSettingsPrivate;
  81   pDasherControl->private_data = pPrivate;
  82
  83 #ifdef WITH_GCONF
  84   pPrivate->pGConfClient = NULL;
  85 #endif
  86   pPrivate->pWidget = NULL;
  87   pPrivate->bWidgetSet = FALSE;
  88 }
  89
  90 static void dasher_app_settings_destroy(GObject *pObject) {
  91 #ifdef WITH_GCONF
  92   dasher_app_settings_stop_gconf((DasherAppSettings *)pObject);
  93 #endif
  94
  95   for(int i(0); i < NUM_OF_APP_SPS; ++i)
  96     delete[] app_stringparamtable[i].value;
  97
  98   // FIXME - glib routines?
  99   // FIXME - do we need a typecast here?
 100   delete (DasherAppSettingsPrivate *)(((DasherAppSettings *)pObject)->private_data);
 101
 102   // FIXME - I think we need to chain up through the finalize methods
 103   // of the parent classes here...
 104 }
 105
 106 void dasher_app_settings_set_widget(DasherAppSettings *pSelf, GtkDasherControl *pWidget) {
 107   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate*)(pSelf->private_data);
 108
 109   pDasherWidget = GTK_WIDGET(pWidget);
 110
 111   pPrivate->pWidget = pWidget;
 112   pPrivate->bWidgetSet = TRUE;
 113 }
 114
 115 static void dasher_app_settings_init_gconf(DasherAppSettings *pSelf, int argc, char **argv) {
 116 #ifdef WITH_GCONF
 117   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate*)(pSelf->private_data);
 118
 119   GError *pGConfError;
 120
 121   if(!gconf_init(argc, argv, &pGConfError))
 122     g_error("Failed to initilaise gconf: %s", pGConfError->message);
 123
 124   // FIXME - apparently there's a function gnome_gconf_get_client - maybe we should use this if building with gnome
 125     pPrivate->pGConfClient = gconf_client_get_default();
 126 #endif
 127 }
 128
 129 static void dasher_app_settings_stop_gconf(DasherAppSettings *pSelf) {
 130 #ifdef WITH_GCONF
 131   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate*)(pSelf->private_data);
 132
 133   g_object_unref(pPrivate->pGConfClient);
 134 #endif
 135 }
 136
 137 static void dasher_app_settings_load(DasherAppSettings *pSelf) {
 138 #ifdef WITH_GCONF
 139   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 140
 141   GError *pGConfError = NULL;
 142   GConfValue *pGConfValue;
 143
 144   for(int i(0); i < NUM_OF_APP_BPS; ++i ) {
 145     if(app_boolparamtable[i].persistent) {
 146       gchar szName[256];
 147
 148       strncpy(szName, "/apps/dasher4/", 256);
 149       strncat(szName,  app_boolparamtable[i].regName, 255 - strlen( szName ));
 150
 151       pGConfValue = gconf_client_get_without_default(pPrivate->pGConfClient, szName, &pGConfError);
 152
 153       if(pGConfValue) {
 154         app_boolparamtable[i].value = gconf_value_get_bool(pGConfValue);
 155
 156         gconf_value_free(pGConfValue);
 157       }
 158     }
 159   }
 160
 161   for(int i(0); i < NUM_OF_APP_LPS; ++i ) {
 162     if(app_longparamtable[i].persistent) {
 163       gchar szName[256];
 164
 165       strncpy(szName, "/apps/dasher4/", 256);
 166       strncat(szName,  app_longparamtable[i].regName, 255 - strlen( szName ));
 167
 168       pGConfValue = gconf_client_get_without_default(pPrivate->pGConfClient, szName, &pGConfError);
 169
 170       if(pGConfValue) {
 171         app_longparamtable[i].value = gconf_value_get_int(pGConfValue);
 172
 173         gconf_value_free(pGConfValue);
 174       }
 175     }
 176   }
 177
 178   for(int i(0); i < NUM_OF_APP_SPS; ++i ) {
 179     if(app_stringparamtable[i].persistent) {
 180       gchar szName[256];
 181
 182       strncpy(szName, "/apps/dasher4/", 256);
 183       strncat(szName,  app_stringparamtable[i].regName, 255 - strlen( szName ));
 184
 185       pGConfValue = gconf_client_get_without_default(pPrivate->pGConfClient, szName, &pGConfError);
 186
 187       if(pGConfValue) {
 188         delete[] app_stringparamtable[i].value;
 189
 190         const gchar *szValue(gconf_value_get_string(pGConfValue));
 191
 192         gchar *szNew;
 193         szNew = new gchar[strlen(szValue) + 1];
 194         strcpy(szNew, szValue);
 195
 196         app_stringparamtable[i].value = szNew;
 197         gconf_value_free(pGConfValue);
 198       }
 199     }
 200   }
 201 #endif
 202 }
 203
 204 // Public methods
 205
 206 DasherAppSettings *dasher_app_settings_new(int argc, char **argv) {
 207   DasherAppSettings *pDasherControl;
 208   pDasherControl = (DasherAppSettings *)(g_object_new(dasher_app_settings_get_type(), NULL));
 209
 210   for(int i(0); i < NUM_OF_APP_SPS; ++i) {
 211     gchar *szNew;
 212     szNew = new gchar[strlen(app_stringparamtable[i].szDefaultValue) + 1];
 213     strcpy(szNew, app_stringparamtable[i].szDefaultValue);
 214     app_stringparamtable[i].value = szNew;
 215   }
 216 #ifdef WITH_GCONF
 217   dasher_app_settings_init_gconf(pDasherControl, argc, argv);
 218 #endif
 219   dasher_app_settings_load(pDasherControl);
 220
 221   return pDasherControl;
 222 }
 223
 224 void dasher_app_settings_reset(DasherAppSettings *pSelf, int iParameter) {
 225   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate*)(pSelf->private_data);
 226
 227   if(iParameter < END_OF_SPS) {
 228     if(pPrivate->bWidgetSet)
 229       gtk_dasher_control_reset_parameter(GTK_DASHER_CONTROL(pDasherWidget), iParameter);
 230     return;
 231   }
 232   else {
 233     //    pre_parameter_notification(0, iParameter, 0);
 234
 235     if(iParameter < END_OF_APP_BPS)
 236       app_boolparamtable[ iParameter - FIRST_APP_BP ].value = app_boolparamtable[ iParameter - FIRST_APP_BP ].bDefaultValue;
 237     else if(iParameter < END_OF_APP_LPS)
 238       app_longparamtable[ iParameter - FIRST_APP_LP ].value = app_longparamtable[ iParameter - FIRST_APP_LP ].iDefaultValue;
 239     else {
 240       delete[] app_stringparamtable[iParameter - FIRST_APP_SP].value;
 241
 242       gchar *szNew;
 243       szNew = new gchar[strlen(app_stringparamtable[iParameter - FIRST_APP_SP].szDefaultValue) + 1];
 244       strcpy(szNew, app_stringparamtable[iParameter - FIRST_APP_SP].szDefaultValue);
 245       app_stringparamtable[iParameter - FIRST_APP_SP].value = szNew;
 246     }
 247   }
 248   // TODO: Use real signals to achieve this
 249   parameter_notification(0, iParameter, 0);
 250 }
 251
 252 bool dasher_app_settings_get_bool(DasherAppSettings *pSelf, int iParameter) {
 253   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate*)(pSelf->private_data);
 254   if( iParameter < END_OF_BPS ) {
 255     if(pPrivate->bWidgetSet)
 256       return gtk_dasher_control_get_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), iParameter);
 257     else
 258       return false;
 259   }
 260   else
 261     return app_boolparamtable[ iParameter - FIRST_APP_BP ].value;
 262 }
 263
 264 void dasher_app_settings_set_bool(DasherAppSettings *pSelf, int iParameter, bool bValue) {
 265   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 266
 267   if( iParameter < END_OF_BPS ) {
 268     if(pPrivate->bWidgetSet) {
 269       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), iParameter, bValue);
 270     }
 271   }
 272   else {
 273     if(dasher_app_settings_get_bool(pSelf, iParameter) == bValue)
 274       return; // Don't attempt to change to the existing value
 275
 276     app_boolparamtable[ iParameter - FIRST_APP_BP ].value = bValue;
 277 #ifdef WITH_GCONF
 278     if(app_boolparamtable[ iParameter - FIRST_APP_BP ].persistent) {
 279       gchar szName[256];
 280
 281       strncpy(szName, "/apps/dasher4/", 256);
 282       strncat(szName,  app_boolparamtable[ iParameter - FIRST_APP_BP ].regName, 255 - strlen( szName ));
 283
 284       GError *pGConfError = NULL;
 285       gconf_client_set_bool(pPrivate->pGConfClient, szName, bValue, &pGConfError);
 286
 287       if(pGConfError)
 288         g_message("Error");
 289     }
 290 #endif
 291
 292     // TODO: Use real signals to achieve this
 293     parameter_notification(0, iParameter, 0);
 294   }
 295 }
 296
 297 gint dasher_app_settings_get_long(DasherAppSettings *pSelf, int iParameter) {
 298   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 299
 300   if( iParameter < END_OF_LPS) {
 301     if(pPrivate->bWidgetSet)
 302       return gtk_dasher_control_get_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), iParameter);
 303     else
 304       return false;
 305   }
 306   else
 307     return app_longparamtable[ iParameter - FIRST_APP_LP ].value;
 308 }
 309
 310 void dasher_app_settings_set_long(DasherAppSettings *pSelf, int iParameter, gint iValue) {
 311   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 312
 313   if( iParameter < END_OF_LPS) {
 314     if(pPrivate->bWidgetSet)
 315       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), iParameter, iValue);
 316   }
 317   else {
 318     if(dasher_app_settings_get_long(pSelf, iParameter) == iValue)
 319       return; // Don't attempt to change to the existing value
 320
 321     //    pre_parameter_notification(0, iParameter, 0);
 322
 323     app_longparamtable[ iParameter - FIRST_APP_LP ].value = iValue;
 324
 325 #ifdef WITH_GCONF
 326     if(app_longparamtable[ iParameter - FIRST_APP_LP ].persistent) {
 327       gchar szName[256];
 328
 329       strncpy(szName, "/apps/dasher4/", 256);
 330       strncat(szName,  app_longparamtable[ iParameter - FIRST_APP_LP ].regName, 255 - strlen( szName ));
 331
 332       GError *pGConfError = NULL;
 333       gconf_client_set_int(pPrivate->pGConfClient, szName, iValue, &pGConfError);
 334     }
 335 #endif
 336
 337     // TODO: Use real signals to achieve this
 338     parameter_notification(0, iParameter, 0);
 339   }
 340 }
 341
 342 gboolean dasher_app_settings_get_free_long(DasherAppSettings *pSelf, const gchar *szName, gint &iValue) {
 343   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 344
 345   gchar szFullName[256];
 346
 347   strncpy(szFullName, "/apps/dasher4/", 256);
 348   strncat(szFullName, szName, 255 - strlen(szFullName));
 349
 350   GConfValue *pGConfValue;
 351   GError *pGConfError = NULL;
 352
 353   pGConfValue = gconf_client_get_without_default(pPrivate->pGConfClient, szFullName, &pGConfError);
 354
 355   if(pGConfValue) {
 356     iValue = gconf_value_get_int(pGConfValue);
 357     gconf_value_free(pGConfValue);
 358     return true;
 359   }
 360   else {
 361     return false;
 362   }
 363 }
 364
 365 void dasher_app_settings_set_free_long(DasherAppSettings *pSelf, const gchar *szName, gint iValue) {
 366   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 367
 368   gchar szFullName[256];
 369
 370   strncpy(szFullName, "/apps/dasher4/", 256);
 371   strncat(szFullName, szName, 255 - strlen(szFullName));
 372
 373   GError *pGConfError = NULL;
 374   gconf_client_set_int(pPrivate->pGConfClient, szFullName, iValue, &pGConfError);
 375 }
 376
 377 const gchar *dasher_app_settings_get_string(DasherAppSettings *pSelf, int iParameter) {
 378   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 379
 380   if( iParameter < END_OF_SPS ) {
 381     if(pPrivate->bWidgetSet)
 382       return gtk_dasher_control_get_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), iParameter);
 383     else
 384       return false;
 385   }
 386   else
 387     return app_stringparamtable[ iParameter - FIRST_APP_SP ].value;
 388 }
 389
 390 void dasher_app_settings_set_string(DasherAppSettings *pSelf, int iParameter, const gchar *szValue) {
 391   DasherAppSettingsPrivate *pPrivate = (DasherAppSettingsPrivate *)(pSelf->private_data);
 392
 393   if( iParameter < END_OF_SPS ) {
 394     if(pPrivate->bWidgetSet)
 395       gtk_dasher_control_set_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), iParameter, szValue);
 396   }
 397   else {
 398     if(!strcmp(dasher_app_settings_get_string(pSelf, iParameter), szValue))
 399       return; // Don't attempt to change to the existing value
 400
 401     //    pre_parameter_notification(0, iParameter, 0);
 402
 403     delete[] app_stringparamtable[ iParameter - FIRST_APP_SP ].value;
 404
 405     gchar *szNew;
 406     szNew = new gchar[strlen(szValue) + 1];
 407     strcpy(szNew, szValue);
 408
 409     app_stringparamtable[ iParameter - FIRST_APP_SP ].value = szNew;
 410
 411 #ifdef WITH_GCONF
 412     if(app_stringparamtable[ iParameter - FIRST_APP_SP ].persistent) {
 413       gchar szName[256];
 414
 415       strncpy(szName, "/apps/dasher4/", 256);
 416       strncat(szName,  app_stringparamtable[ iParameter - FIRST_APP_SP ].regName, 255 - strlen( szName ));
 417
 418       GError *pGConfError = NULL;
 419       gconf_client_set_string(pPrivate->pGConfClient, szName, szValue, &pGConfError);
 420     }
 421 #endif
 422
 423     // TODO: Use real signals to achieve this
 424     parameter_notification(0, iParameter, 0);
 425   }
 426 }
 427
 428 int dasher_app_settings_get_count(DasherAppSettings *pSelf) {
 429   return END_OF_APP_SPS;
 430 }
 431
 432 int dasher_app_settings_get_parameter_type(DasherAppSettings *pSelf, int iParameter) {
 433   if(iParameter < END_OF_BPS)
 434     return DASHER_TYPE_BOOL;
 435   else if(iParameter < END_OF_LPS)
 436     return DASHER_TYPE_LONG;
 437   else if(iParameter < END_OF_SPS)
 438     return DASHER_TYPE_STRING;
 439   else if(iParameter < END_OF_APP_BPS)
 440     return DASHER_TYPE_BOOL;
 441   else if(iParameter < END_OF_APP_LPS)
 442     return DASHER_TYPE_LONG;
 443   else
 444     return DASHER_TYPE_STRING;
 445 }
 446
 447 const gchar *dasher_app_settings_get_reg_name(DasherAppSettings *pSelf, int iParameter) {
 448   if(iParameter < END_OF_BPS)
 449     return boolparamtable[iParameter - FIRST_BP].regName;
 450   else if(iParameter < END_OF_LPS)
 451     return longparamtable[iParameter - FIRST_LP].regName;
 452   else if(iParameter < END_OF_SPS)
 453     return stringparamtable[iParameter - FIRST_SP].regName;
 454   else if(iParameter < END_OF_APP_BPS)
 455     return app_boolparamtable[iParameter - FIRST_APP_BP].regName;
 456   else if(iParameter < END_OF_APP_LPS)
 457     return app_longparamtable[iParameter - FIRST_APP_LP].regName;
 458   else
 459     return app_stringparamtable[iParameter - FIRST_APP_SP].regName;
 460 }
 461
 462 const gchar *dasher_app_settings_get_human_name(DasherAppSettings *pSelf, int iParameter) {
 463   if(iParameter < END_OF_BPS)
 464     return boolparamtable[iParameter - FIRST_BP].humanReadable;
 465   else if(iParameter < END_OF_LPS)
 466     return longparamtable[iParameter - FIRST_LP].humanReadable;
 467   else if(iParameter < END_OF_SPS)
 468     return stringparamtable[iParameter - FIRST_SP].humanReadable;
 469   else if(iParameter < END_OF_APP_BPS)
 470     return app_boolparamtable[iParameter - FIRST_APP_BP].humanReadable;
 471   else if(iParameter < END_OF_APP_LPS)
 472     return app_longparamtable[iParameter - FIRST_APP_LP].humanReadable;
 473   else
 474     return app_stringparamtable[iParameter - FIRST_APP_SP].humanReadable;
 475 }
 476
 477 bool dasher_app_settings_have_advanced(DasherAppSettings *pSelf) {
 478   return(g_find_program_in_path("gconf-editor") != NULL);
 479 }
 480
 481 void dasher_app_settings_launch_advanced(DasherAppSettings *pSelf) {
 482   gchar *szArgs[3];
 483
 484   szArgs[0] = "gconf-editor";
 485   szArgs[1] = "/apps/dasher4";
 486   szArgs[2] = NULL;
 487
 488   GError *pError;
 489
 490   if(!g_spawn_async(NULL, szArgs, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &pError)) {
 491     g_warning("Could not launch gconf-editor: %s", pError->message);
 492   }
 493 }
 494
 495 void dasher_app_settings_set_widget(DasherAppSettings *pSelf, GtkWidget *pWidget) {
 496   pDasherWidget = pWidget;
 497 }
 498
 499 GArray *dasher_app_settings_get_allowed_values(DasherAppSettings *pSelf, int iParameter) {
 500   return gtk_dasher_control_get_allowed_values(GTK_DASHER_CONTROL(pDasherWidget), iParameter);
 501 }
 502
 503 gboolean dasher_app_settings_get_module_settings(DasherAppSettings *pSelf, const gchar *szValue, SModuleSettings **pSettings, gint *iCount) {
 504   return gtk_dasher_control_get_module_settings(GTK_DASHER_CONTROL(pDasherWidget), szValue, pSettings, iCount);
 505 }