Src/Gtk2/Preferences.cpp

   1 #include "../Common/Common.h"
   2 #include "../../config.h"
   3
   4 #include "Preferences.h"
   5 #include "Parameters.h"
   6 #include "dasher.h"
   7 #include "config.h"
   8 #include "GtkDasherControl.h"
   9
  10 #include "DasherControl.h"
  11
  12 #include "DasherTypes.h"
  13 #include "module_settings_window.h"
  14
  15 #include <cstring>
  16 #include <libintl.h>
  17
  18 // TODO: Reintroduce advanced settings and start on mouse position offset
  19
  20
  21 GtkListStore *g_pStore;
  22
  23 // TODO: Get rid of this as soon as possible
  24 GladeXML *widgets;
  25
  26 typedef struct _BoolTranslation BoolTranslation;
  27
  28 struct _BoolTranslation {
  29   gint iParameter;
  30   gchar *szWidgetName;
  31   GtkWidget *pWidget;
  32 };
  33
  34 typedef struct _StringTranslation StringTranslation;
  35
  36 struct _StringTranslation {
  37   gint iParameter;
  38   gchar *szWidgetName;
  39   GtkWidget *pWidget;
  40   gchar *szHelperName;
  41   GtkWidget *pHelper;
  42 };
  43
  44 // Checkbox widgets which map directly to boolean parameters
  45
  46 #ifndef WITH_MAEMO
  47
  48 BoolTranslation sBoolTranslationTable[] = {
  49   {BP_DRAW_MOUSE_LINE, "showmouselinebutton", NULL},
  50   {BP_DRAW_MOUSE, "showmousebutton", NULL},
  51   {BP_SHOW_SLIDER, "speedsliderbutton", NULL},
  52   {APP_BP_SHOW_TOOLBAR, "toolbarbutton", NULL},
  53   {BP_OUTLINE_MODE, "outlinebutton", NULL},
  54   {BP_CONTROL_MODE, "control_controlmode", NULL},
  55   {APP_BP_TIME_STAMP, "timestampbutton", NULL},
  56   {APP_BP_DOCK, "dockbutton", NULL}
  57 };
  58
  59 #endif
  60
  61 // List widgets which map directly to string parameters
  62
  63 #ifdef WITH_MAEMO
  64
  65 StringTranslation sStringTranslationTable[] = {
  66   {SP_ALPHABET_ID, "AlphabetTree", NULL, NULL, NULL},
  67   {SP_COLOUR_ID, "ColorTree", NULL, NULL, NULL},
  68 };
  69
  70 #else
  71
  72 StringTranslation sStringTranslationTable[] = {
  73   {SP_ALPHABET_ID, "AlphabetTree", NULL, NULL, NULL},
  74   {SP_COLOUR_ID, "ColorTree", NULL, NULL, NULL},
  75   {SP_INPUT_FILTER, "input_filter_tree_view", NULL, "button13", NULL},
  76   {SP_INPUT_DEVICE, "input_tree_view", NULL, "button25", NULL}
  77 };
  78
  79 #endif
  80
  81 enum {
  82   ACTIONS_ID_COLUMN,
  83   ACTIONS_NAME_COLUMN,
  84   ACTIONS_SHOW_COLUMN,
  85   ACTIONS_CONTROL_COLUMN,
  86   ACTIONS_AUTO_COLUMN,
  87   ACTIONS_N_COLUMNS
  88 };
  89
  90 void RefreshWidget(gint iParameter);
  91 extern "C" void RefreshParameter(GtkWidget *pWidget, gpointer pUserData);
  92
  93 void InitialiseTables(GladeXML *pGladeWidgets);
  94 void PopulateLMPage(GladeXML * pGladeWidgets);
  95 void generate_preferences(GladeXML * pGladeWidgets);
  96 void PopulateControlPage(GladeXML * pGladeWidgets);
  97 void PopulateViewPage(GladeXML * pGladeWidgets);
  98 void dasher_preferences_populate_font_buttons(DasherPreferencesDialogue *pSelf, GladeXML * pGladeWidgets);
  99
 100 //void SetAlphabetSelection(int i, GtkTreeIter *pAlphIter);
 101 void dasher_preferences_populate_list(GtkTreeView *pView, int iParameter, GtkWidget *pHelper);
 102
 103 extern "C" void advanced_edited_callback(GtkCellRendererText * cell, gchar * path_string, gchar * new_text, gpointer user_data);
 104 extern "C" void colour_select(GtkTreeSelection * selection, gpointer data);
 105 extern "C" void alphabet_select(GtkTreeSelection * selection, gpointer data);
 106 extern "C" void on_action_toggle(GtkCellRendererToggle *pRenderer, gchar *szPath, gpointer pUserData);
 107 extern "C" void on_list_selection(GtkTreeSelection *pSelection, gpointer pUserData);
 108 extern "C" void on_widget_realize(GtkWidget *pWidget, gpointer pUserData);
 109
 110 // Private member variables
 111 GtkWidget *dasher_preferences_dialogue_get_helper(DasherPreferencesDialogue *pSelf, int iParameter, const gchar *szValue);
 112
 113 GtkTreeSelection *alphselection;
 114 GtkWidget *alphabettreeview;
 115 GtkListStore *alph_list_store;
 116
 117 GtkTreeModel *m_pAdvancedModel;
 118
 119 GtkWidget *preferences_window;
 120 GtkWidget *train_dialogue;
 121
 122 GtkWidget *m_pLRButton;
 123 GtkWidget *m_pRLButton;
 124 GtkWidget *m_pTBButton;
 125 GtkWidget *m_pBTButton;
 126 GtkWidget *m_pSpeedSlider;
 127
 128 GtkWidget *m_pAdvancedSettings;
 129
 130 GtkWidget *m_pMousePosButton;
 131 GtkWidget *m_pMousePosStyle;
 132
 133 // Set this to ignore signals (ie loops coming back from setting widgets in response to parameters having changed)
 134
 135 bool g_bIgnoreSignals(false);
 136
 137 #define _(_x) gettext(_x)
 138
 139 // Stuff to do with training threads
 140
 141 GThread *trainthread;
 142
 143 struct TrainingThreadData {
 144   GtkWidget *pDasherControl;
 145   GtkWidget *pTrainingDialogue;
 146   gchar *szAlphabet;
 147 };
 148
 149
 150 // TODO: Look at coding convention stuff for gobjets
 151
 152 /// Newer, object based stuff
 153
 154 struct _DasherPreferencesDialoguePrivate {
 155   GtkWindow *pWindow;
 156   DasherEditor *pEditor;
 157   GtkWidget *pActionTreeView;
 158 };
 159
 160 typedef struct _DasherPreferencesDialoguePrivate DasherPreferencesDialoguePrivate;
 161
 162 // Private member functions
 163 static void dasher_preferences_dialogue_class_init(DasherPreferencesDialogueClass *pClass);
 164 static void dasher_preferences_dialogue_init(DasherPreferencesDialogue *pMain);
 165 static void dasher_preferences_dialogue_destroy(GObject *pObject);
 166
 167 // Private methods not associated with class
 168 void update_advanced(int iParameter);
 169
 170 GType dasher_preferences_dialogue_get_type() {
 171
 172   static GType dasher_preferences_dialogue_type = 0;
 173
 174   if(!dasher_preferences_dialogue_type) {
 175     static const GTypeInfo dasher_preferences_dialogue_info = {
 176       sizeof(DasherPreferencesDialogueClass),
 177       NULL,
 178       NULL,
 179       (GClassInitFunc) dasher_preferences_dialogue_class_init,
 180       NULL,
 181       NULL,
 182       sizeof(DasherPreferencesDialogue),
 183       0,
 184       (GInstanceInitFunc) dasher_preferences_dialogue_init,
 185       NULL
 186     };
 187
 188     dasher_preferences_dialogue_type = g_type_register_static(G_TYPE_OBJECT, "DasherPreferencesDialogue", &dasher_preferences_dialogue_info, static_cast < GTypeFlags > (0));
 189   }
 190
 191   return dasher_preferences_dialogue_type;
 192 }
 193
 194 static void dasher_preferences_dialogue_class_init(DasherPreferencesDialogueClass *pClass) {
 195   GObjectClass *pObjectClass = (GObjectClass *) pClass;
 196   pObjectClass->finalize = dasher_preferences_dialogue_destroy;
 197 }
 198
 199 static void dasher_preferences_dialogue_init(DasherPreferencesDialogue *pDasherControl) {
 200   pDasherControl->private_data = new DasherPreferencesDialoguePrivate;
 201   DasherPreferencesDialoguePrivate *pPrivate = (DasherPreferencesDialoguePrivate *)(pDasherControl->private_data);
 202 }
 203
 204 static void dasher_preferences_dialogue_destroy(GObject *pObject) {
 205   // FIXME - I think we need to chain up through the finalize methods
 206   // of the parent classes here...
 207 }
 208
 209 // Public methods
 210
 211 DasherPreferencesDialogue *dasher_preferences_dialogue_new(GladeXML *pGladeWidgets, DasherEditor *pEditor) {
 212   DasherPreferencesDialogue *pDasherControl;
 213   pDasherControl = (DasherPreferencesDialogue *)(g_object_new(dasher_preferences_dialogue_get_type(), NULL));
 214   DasherPreferencesDialoguePrivate *pPrivate = (DasherPreferencesDialoguePrivate *)(pDasherControl->private_data);
 215
 216   pPrivate->pEditor = pEditor;
 217
 218   widgets = pGladeWidgets;
 219
 220   preferences_window = glade_xml_get_widget(pGladeWidgets, "preferences");
 221   pPrivate->pWindow = GTK_WINDOW(preferences_window);
 222
 223   pPrivate->pActionTreeView =glade_xml_get_widget(pGladeWidgets, "action_tree_view");
 224
 225   gtk_window_set_transient_for(GTK_WINDOW(preferences_window), GTK_WINDOW(window));
 226
 227   m_pSpeedSlider = glade_xml_get_widget(pGladeWidgets, "hscale1");
 228
 229   m_pAdvancedSettings = glade_xml_get_widget(pGladeWidgets, "window3");
 230
 231   InitialiseTables(pGladeWidgets);
 232   RefreshWidget(-1);
 233
 234   generate_preferences(pGladeWidgets);
 235   PopulateControlPage(pGladeWidgets);
 236   PopulateViewPage(pGladeWidgets);
 237   PopulateLMPage(pGladeWidgets);
 238
 239   dasher_preferences_populate_font_buttons(pDasherControl, pGladeWidgets);
 240
 241 // #ifndef GNOME_SPEECH
 242 //   // This ought to be greyed out if not built with speech support
 243 //   gtk_widget_set_sensitive(glade_xml_get_widget(pGladeWidgets, "speakbutton"), false);
 244 // #endif
 245
 246 #ifndef JAPANESE
 247   gtk_widget_hide(glade_xml_get_widget(pGladeWidgets, "radiobutton9"));
 248 #endif
 249
 250 // #ifndef WITH_MAEMO
 251 //   if(!dasher_app_settings_have_advanced(g_pDasherAppSettings)) {
 252 //     gtk_widget_set_sensitive(glade_xml_get_widget(pGladeWidgets, "button27"), dasher_app_settings_have_advanced(g_pDasherAppSettings));
 253 //     gtk_widget_show(glade_xml_get_widget(pGladeWidgets, "gconfwarning"));
 254 //   }
 255 //   else {
 256 //     gtk_widget_hide(glade_xml_get_widget(pGladeWidgets, "gconfwarning"));
 257 //   }
 258 // #endif
 259
 260   return pDasherControl;
 261 }
 262
 263 void dasher_preferences_dialogue_show(DasherPreferencesDialogue *pSelf) {
 264   DasherPreferencesDialoguePrivate *pPrivate = (DasherPreferencesDialoguePrivate *)(pSelf->private_data);
 265   // FIXME - REIMPLEMENT
 266
 267   // Keep the preferences window in the correct position relative to the
 268   // main Dasher window
 269
 270   gtk_window_set_transient_for(pPrivate->pWindow,GTK_WINDOW(window));
 271 #ifdef WITH_MAEMO
 272 #ifndef WITH_MAEMOFULLSCREEN
 273   gtk_window_set_keep_above((pPrivate->pWindow), true);
 274 #endif
 275 #endif
 276   gtk_window_set_keep_above((pPrivate->pWindow), dasher_main_topmost(g_pDasherMain));
 277   gtk_window_present(pPrivate->pWindow);
 278 }
 279
 280
 281 void dasher_preferences_dialogue_handle_parameter_change(DasherPreferencesDialogue *pSelf, int iParameter) {
 282
 283   //  update_advanced(iParameter);
 284
 285   if(iParameter == LP_DASHER_FONTSIZE) {
 286     switch (gtk_dasher_control_get_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_DASHER_FONTSIZE)) {
 287     case Opts::Normal:
 288       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "fontsizenormal")), TRUE);
 289       break;
 290     case Opts::Big:
 291       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "fontsizelarge")), TRUE);
 292       break;
 293     case Opts::VBig:
 294       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "fontsizevlarge")), TRUE);
 295       break;
 296     }
 297   }
 298   else if(iParameter == LP_UNIFORM) {
 299     gtk_range_set_value(GTK_RANGE(glade_xml_get_widget(widgets, "uniformhscale")), gtk_dasher_control_get_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_UNIFORM) / 10.0);
 300   }
 301   else if(iParameter == LP_LANGUAGE_MODEL_ID) {
 302     switch (gtk_dasher_control_get_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_LANGUAGE_MODEL_ID)) {
 303     case 0:
 304       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton6"))) != TRUE)
 305         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton6")), TRUE);
 306       break;
 307     case 2:
 308       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton7"))) != TRUE)
 309         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton7")), TRUE);
 310       break;
 311     case 3:
 312       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton8"))) != TRUE)
 313         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton8")), TRUE);
 314       break;
 315 #ifdef JAPANESE
 316     case 4:
 317       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton9"))) != TRUE)
 318         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton9")), TRUE);
 319       break;
 320 #endif
 321     }
 322   }
 323   else if(iParameter == LP_ORIENTATION) {
 324     switch (gtk_dasher_control_get_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION)) {
 325     case Opts::Alphabet:
 326       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton1"))) != TRUE)
 327         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton1")), TRUE);
 328       break;
 329     case Opts::LeftToRight:
 330       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton2"))) != TRUE)
 331         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton2")), TRUE);
 332       break;
 333     case Opts::RightToLeft:
 334       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton3"))) != TRUE)
 335         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton3")), TRUE);
 336       break;
 337     case Opts::TopToBottom:
 338       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton4"))) != TRUE)
 339         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton4")), TRUE);
 340       break;
 341     case Opts::BottomToTop:
 342       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton5"))) != TRUE)
 343         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "radiobutton5")), TRUE);
 344       break;
 345     }
 346   }
 347   else if(iParameter == BP_START_MOUSE) {
 348     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "leftbutton")), gtk_dasher_control_get_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_START_MOUSE));
 349   }
 350   else if(iParameter == BP_START_SPACE) {
 351     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "spacebutton")), gtk_dasher_control_get_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_START_SPACE));
 352   }
 353   else if((iParameter == BP_MOUSEPOS_MODE) || (iParameter == BP_CIRCLE_START)) {
 354     // FIXME - duplicated code from Preferences.cpp
 355     if(dasher_app_settings_get_bool(g_pDasherAppSettings, BP_MOUSEPOS_MODE)) {
 356       gtk_combo_box_set_active(GTK_COMBO_BOX(glade_xml_get_widget(widgets, "MousePosStyle")), 1);
 357       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "mouseposbutton")), true);
 358     }
 359     else if(dasher_app_settings_get_bool(g_pDasherAppSettings, BP_CIRCLE_START)) {
 360       gtk_combo_box_set_active(GTK_COMBO_BOX(glade_xml_get_widget(widgets, "MousePosStyle")), 0);
 361       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "mouseposbutton")), true);
 362     }
 363     else {
 364       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(widgets, "mouseposbutton")), false);
 365     }
 366   }
 367   else if(iParameter == LP_MAX_BITRATE) {
 368     double dNewValue = dasher_app_settings_get_long(g_pDasherAppSettings, LP_MAX_BITRATE) / 100.0;
 369     gtk_range_set_value(GTK_RANGE(m_pSpeedSlider), dNewValue);
 370   }
 371   else if(iParameter == BP_PALETTE_CHANGE) {
 372     gtk_widget_set_sensitive(glade_xml_get_widget(widgets, "ColorTree"), !dasher_app_settings_get_bool(g_pDasherAppSettings, BP_PALETTE_CHANGE));
 373   }
 374   else if((iParameter == SP_DASHER_FONT) || (iParameter == APP_SP_EDIT_FONT))  {
 375     dasher_preferences_populate_font_buttons(NULL, widgets);
 376   }
 377   else {
 378     RefreshWidget(iParameter);
 379   }
 380 }
 381
 382
 383 void dasher_preferences_dialogue_populate_actions(DasherPreferencesDialogue *pSelf) {
 384 #ifndef WITH_MAEMO
 385   DasherPreferencesDialoguePrivate *pPrivate = (DasherPreferencesDialoguePrivate *)(pSelf->private_data);
 386
 387   g_pStore = gtk_list_store_new(ACTIONS_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
 388
 389   GtkTreeIter oIter;
 390
 391   dasher_editor_actions_start(pPrivate->pEditor);
 392
 393   while(dasher_editor_actions_more(pPrivate->pEditor)) {
 394     gtk_list_store_append(g_pStore, &oIter);
 395
 396     const gchar *szName;
 397     gint iID;
 398     gboolean bShow;
 399     gboolean bControl;
 400     gboolean bAuto;
 401
 402     dasher_editor_actions_get_next(pPrivate->pEditor, &szName, &iID, &bShow, &bControl, &bAuto),
 403
 404     gtk_list_store_set(g_pStore, &oIter,
 405                        ACTIONS_ID_COLUMN, iID,
 406                        ACTIONS_NAME_COLUMN, szName,
 407                        ACTIONS_SHOW_COLUMN, bShow,
 408                        ACTIONS_CONTROL_COLUMN, bControl,
 409                        ACTIONS_AUTO_COLUMN, bAuto,
 410                        -1);
 411   }
 412
 413   GtkCellRenderer *pRenderer;
 414   GtkTreeViewColumn *pColumn;
 415
 416   // TODO: (small) memory leak here at the moment
 417   gint *pColumnIndex = new gint[3];
 418   pColumnIndex[0] = ACTIONS_SHOW_COLUMN;
 419   pColumnIndex[1] = ACTIONS_CONTROL_COLUMN;
 420   pColumnIndex[2] = ACTIONS_AUTO_COLUMN;
 421
 422   pRenderer = gtk_cell_renderer_text_new();
 423   pColumn = gtk_tree_view_column_new_with_attributes("Action", pRenderer, "text", ACTIONS_NAME_COLUMN, NULL);
 424   g_object_set(G_OBJECT(pColumn), "expand", true, NULL);
 425   gtk_tree_view_append_column(GTK_TREE_VIEW(pPrivate->pActionTreeView), pColumn);
 426
 427   pRenderer = gtk_cell_renderer_toggle_new();
 428   g_signal_connect(pRenderer, "toggled", (GCallback)on_action_toggle, pColumnIndex);
 429   pColumn = gtk_tree_view_column_new_with_attributes("Show Button", pRenderer, "active", ACTIONS_SHOW_COLUMN, NULL);
 430   gtk_tree_view_append_column(GTK_TREE_VIEW(pPrivate->pActionTreeView), pColumn);
 431
 432   pRenderer = gtk_cell_renderer_toggle_new();
 433   g_signal_connect(pRenderer, "toggled", (GCallback)on_action_toggle, pColumnIndex + 1);
 434   pColumn = gtk_tree_view_column_new_with_attributes("Control Mode", pRenderer, "active", ACTIONS_CONTROL_COLUMN, NULL);
 435   gtk_tree_view_append_column(GTK_TREE_VIEW(pPrivate->pActionTreeView), pColumn);
 436
 437   pRenderer = gtk_cell_renderer_toggle_new();
 438   g_signal_connect(pRenderer, "toggled", (GCallback)on_action_toggle, pColumnIndex + 2);
 439   pColumn = gtk_tree_view_column_new_with_attributes("Auto On Stop", pRenderer, "active", ACTIONS_AUTO_COLUMN, NULL);
 440   gtk_tree_view_append_column(GTK_TREE_VIEW(pPrivate->pActionTreeView), pColumn);
 441
 442   gtk_tree_view_set_model(GTK_TREE_VIEW(pPrivate->pActionTreeView), GTK_TREE_MODEL(g_pStore));
 443
 444   // New input filter selection
 445
 446 //   dasher_preferences_populate_list(GTK_TREE_VIEW(glade_xml_get_widget(pGladeWidgets, "input_filter_tree_view")), SP_INPUT_FILTER);
 447 //   dasher_preferences_populate_list(GTK_TREE_VIEW(glade_xml_get_widget(pGladeWidgets, "input_tree_view")), SP_INPUT_DEVICE);
 448 #endif
 449 }
 450
 451 /// Older stuff
 452
 453
 454 // This file contains callbacks for the controls in the preferences
 455 // dialogue. Please keep the callbacks in the same order that they
 456 // appear in the dialogue box
 457
 458 // TODO: In theory a lot of these could be replaced by a single
 459 // function by using user_data to store the key.
 460
 461 void PopulateControlPage(GladeXML *pGladeWidgets) {
 462   double dNewValue = dasher_app_settings_get_long(g_pDasherAppSettings, LP_MAX_BITRATE) / 100.0;
 463   gtk_range_set_value(GTK_RANGE(m_pSpeedSlider), dNewValue);
 464
 465   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "adaptivebutton")), getBool(BP_AUTO_SPEEDCONTROL));
 466
 467 #ifndef WITH_MAEMO
 468   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "leftbutton")), getBool(BP_START_MOUSE));
 469   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "spacebutton")), getBool(BP_START_SPACE));
 470
 471   m_pMousePosButton = glade_xml_get_widget(pGladeWidgets, "mouseposbutton");
 472   m_pMousePosStyle = glade_xml_get_widget(pGladeWidgets, "MousePosStyle");
 473
 474   if(dasher_app_settings_get_bool(g_pDasherAppSettings, BP_MOUSEPOS_MODE)) {
 475     gtk_combo_box_set_active(GTK_COMBO_BOX(m_pMousePosStyle), 1);
 476     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "mouseposbutton")), true);
 477   }
 478   else if(dasher_app_settings_get_bool(g_pDasherAppSettings, BP_CIRCLE_START)) {
 479     gtk_combo_box_set_active(GTK_COMBO_BOX(m_pMousePosStyle), 0);
 480     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "mouseposbutton")), true);
 481   }
 482   else {
 483     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "mouseposbutton")), false);
 484   }
 485 #endif
 486 }
 487
 488 void PopulateViewPage(GladeXML *pGladeWidgets) {
 489
 490   m_pLRButton = glade_xml_get_widget(pGladeWidgets, "radiobutton2");
 491   m_pRLButton = glade_xml_get_widget(pGladeWidgets, "radiobutton3");
 492   m_pTBButton = glade_xml_get_widget(pGladeWidgets, "radiobutton4");
 493   m_pBTButton = glade_xml_get_widget(pGladeWidgets, "radiobutton5");
 494
 495   switch (getLong(LP_ORIENTATION)) {
 496   case Dasher::Opts::Alphabet:
 497     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton1"))) != TRUE)
 498       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton1")), TRUE);
 499
 500     g_bIgnoreSignals = true;
 501
 502     switch (getLong(LP_REAL_ORIENTATION)) {
 503     case Dasher::Opts::LeftToRight:
 504       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pLRButton)) != TRUE)
 505         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pLRButton), TRUE);
 506       break;
 507     case Dasher::Opts::RightToLeft:
 508       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pRLButton)) != TRUE)
 509         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pRLButton), TRUE);
 510       break;
 511     case Dasher::Opts::TopToBottom:
 512       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pTBButton)) != TRUE)
 513         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pTBButton), TRUE);
 514       break;
 515     case Dasher::Opts::BottomToTop:
 516       if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pTBButton)) != TRUE)
 517         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pTBButton), TRUE);
 518       break;
 519     }
 520
 521     g_bIgnoreSignals = false;
 522
 523     gtk_widget_set_sensitive(m_pLRButton, FALSE);
 524     gtk_widget_set_sensitive(m_pRLButton, FALSE);
 525     gtk_widget_set_sensitive(m_pTBButton, FALSE);
 526     gtk_widget_set_sensitive(m_pBTButton, FALSE);
 527
 528
 529     break;
 530   case Dasher::Opts::LeftToRight:
 531     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton2"))) != TRUE)
 532       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton2")), TRUE);
 533     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12"))) != TRUE)
 534       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12")), TRUE);
 535
 536     gtk_widget_set_sensitive(m_pLRButton, TRUE);
 537     gtk_widget_set_sensitive(m_pRLButton, TRUE);
 538     gtk_widget_set_sensitive(m_pTBButton, TRUE);
 539     gtk_widget_set_sensitive(m_pBTButton, TRUE);
 540     break;
 541   case Dasher::Opts::RightToLeft:
 542     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton3"))) != TRUE)
 543       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton3")), TRUE);
 544     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12"))) != TRUE)
 545       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12")), TRUE);
 546
 547     gtk_widget_set_sensitive(m_pLRButton, TRUE);
 548     gtk_widget_set_sensitive(m_pRLButton, TRUE);
 549     gtk_widget_set_sensitive(m_pTBButton, TRUE);
 550     gtk_widget_set_sensitive(m_pBTButton, TRUE);
 551     break;
 552   case Dasher::Opts::TopToBottom:
 553     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton4"))) != TRUE)
 554       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton4")), TRUE);
 555     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12"))) != TRUE)
 556       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12")), TRUE);
 557
 558     gtk_widget_set_sensitive(m_pLRButton, TRUE);
 559     gtk_widget_set_sensitive(m_pRLButton, TRUE);
 560     gtk_widget_set_sensitive(m_pTBButton, TRUE);
 561     gtk_widget_set_sensitive(m_pBTButton, TRUE);
 562     break;
 563   case Dasher::Opts::BottomToTop:
 564     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton5"))) != TRUE)
 565       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton5")), TRUE);
 566     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12"))) != TRUE)
 567       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton12")), TRUE);
 568
 569     gtk_widget_set_sensitive(m_pLRButton, TRUE);
 570     gtk_widget_set_sensitive(m_pRLButton, TRUE);
 571     gtk_widget_set_sensitive(m_pTBButton, TRUE);
 572     gtk_widget_set_sensitive(m_pBTButton, TRUE);
 573     break;
 574   }
 575
 576 #ifndef WITH_MAEMO
 577   switch(dasher_app_settings_get_long(g_pDasherAppSettings, APP_LP_STYLE)) {
 578   case 0:
 579     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "appstyle_classic")), TRUE);
 580     break;
 581   case 1:
 582     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "appstyle_compose")), TRUE);
 583     break;
 584   case 2:
 585     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "appstyle_direct")), TRUE);
 586     break;
 587   case 3:
 588     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "appstyle_fullscreen")), TRUE);
 589     break;
 590   }
 591
 592   if(getLong(LP_LINE_WIDTH) > 1)
 593     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "thicklinebutton")), true);
 594   else
 595     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "thicklinebutton")), false);
 596
 597 #endif
 598 }
 599
 600
 601 void PopulateLMPage(GladeXML *pGladeWidgets) {
 602
 603   switch( gtk_dasher_control_get_parameter_long( GTK_DASHER_CONTROL(pDasherWidget), LP_LANGUAGE_MODEL_ID )) {
 604   case 0:
 605     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton6"))) != TRUE)
 606       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton6")), TRUE);
 607     break;
 608   case 2:
 609     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton7"))) != TRUE)
 610       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton7")), TRUE);
 611     break;
 612   case 3:
 613     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton8"))) != TRUE)
 614       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton8")), TRUE);
 615     break;
 616   case 4:
 617     if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton9"))) != TRUE)
 618       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "radiobutton9")), TRUE);
 619     break;
 620   default:
 621     break;
 622   }
 623
 624
 625   gtk_range_set_value( GTK_RANGE(glade_xml_get_widget(pGladeWidgets, "uniformhscale")), getLong(LP_UNIFORM)/10.0);
 626
 627   // LM parameters are now obsolete - will eventually be part of the 'advanced' page
 628
 629
 630 }
 631
 632 void generate_preferences(GladeXML *pGladeWidgets) {
 633   // We need to populate the lists of alphabets and colours
 634 //  dasher_preferences_populate_list(GTK_TREE_VIEW(glade_xml_get_widget(pGladeWidgets, "AlphabetTree")), SP_ALPHABET_ID);
 635 //  dasher_preferences_populate_list(GTK_TREE_VIEW(glade_xml_get_widget(pGladeWidgets, "ColorTree")), SP_COLOUR_ID);
 636
 637 //   GtkTreeIter alphiter, colouriter;
 638
 639 //   // Build the alphabet tree - this is nasty
 640 //   alphabettreeview = glade_xml_get_widget(pGladeWidgets, "AlphabetTree");
 641 //   alph_list_store = gtk_list_store_new(1, G_TYPE_STRING);
 642 //   gtk_tree_view_set_model(GTK_TREE_VIEW(alphabettreeview), GTK_TREE_MODEL(alph_list_store));
 643 //   alphselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(alphabettreeview));
 644 //   gtk_tree_selection_set_mode(GTK_TREE_SELECTION(alphselection), GTK_SELECTION_BROWSE);
 645 //   GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Alphabet", gtk_cell_renderer_text_new(), "text", 0, NULL);
 646 //   gtk_tree_view_append_column(GTK_TREE_VIEW(alphabettreeview), column);
 647
 648 //   // Clear the contents of the alphabet list
 649 //   gtk_list_store_clear(alph_list_store);
 650
 651 //   GArray *pAlphabetArray;
 652
 653 //   pAlphabetArray = gtk_dasher_control_get_allowed_values(GTK_DASHER_CONTROL(pDasherWidget), SP_ALPHABET_ID);
 654
 655 //   for(unsigned int i(0); i < pAlphabetArray->len; ++i) {
 656
 657 //     const gchar *pCurrentAlphabet(g_array_index(pAlphabetArray, gchar *, i));
 658
 659 //     gtk_list_store_append(alph_list_store, &alphiter);
 660 //     gtk_list_store_set(alph_list_store, &alphiter, 0, pCurrentAlphabet, -1);
 661
 662 //     if(!strcmp(pCurrentAlphabet, getString(SP_ALPHABET_ID)))
 663 //       SetAlphabetSelection(i, &alphiter);
 664
 665 //   }
 666
 667 //   g_array_free(pAlphabetArray, true);
 668
 669 //   // Connect up a signal so we can select a new alphabet
 670 //   g_signal_connect_after(G_OBJECT(alphselection), "changed", GTK_SIGNAL_FUNC(alphabet_select), NULL);
 671
 672 //   // Do the same for colours
 673 //   colourtreeview = glade_xml_get_widget(pGladeWidgets, "ColorTree");
 674
 675 //   // Make sure that the colour tree is realized now as we'll need to do
 676 //   // stuff with it before it's actually displayed
 677 //   gtk_widget_realize(colourtreeview);
 678
 679 //   colour_list_store = gtk_list_store_new(1, G_TYPE_STRING);
 680 //   gtk_tree_view_set_model(GTK_TREE_VIEW(colourtreeview), GTK_TREE_MODEL(colour_list_store));
 681 //   colourselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(colourtreeview));
 682 //   gtk_tree_selection_set_mode(GTK_TREE_SELECTION(colourselection), GTK_SELECTION_BROWSE);
 683 //   column = gtk_tree_view_column_new_with_attributes("Colour", gtk_cell_renderer_text_new(), "text", 0, NULL);
 684 //   gtk_tree_view_append_column(GTK_TREE_VIEW(colourtreeview), column);
 685
 686 //   // Clear the contents of the colour list
 687 //   gtk_list_store_clear(colour_list_store);
 688
 689 //   GArray *pColourArray;
 690
 691 //   pColourArray = gtk_dasher_control_get_allowed_values(GTK_DASHER_CONTROL(pDasherWidget), SP_COLOUR_ID);
 692
 693 //   for(unsigned int i(0); i < pColourArray->len; ++i) {
 694
 695 //     const gchar *pCurrentColour(g_array_index(pColourArray, gchar *, i));
 696
 697 //     gtk_list_store_append(colour_list_store, &colouriter);
 698 //     gtk_list_store_set(colour_list_store, &colouriter, 0, pCurrentColour, -1);
 699
 700 //     if(!strcmp(pCurrentColour, getString(SP_COLOUR_ID))) {
 701 //       gchar ugly_path_hack[100];
 702 //       sprintf(ugly_path_hack, "%d", i);
 703 //       gtk_tree_selection_select_iter(colourselection, &colouriter);
 704 //       gtk_tree_view_set_cursor(GTK_TREE_VIEW(colourtreeview), gtk_tree_path_new_from_string(ugly_path_hack), NULL, false);
 705 //     }
 706 //   }
 707
 708 //   g_array_free(pColourArray, true);
 709
 710 //   // Connect up a signal so we can select a new colour scheme
 711 //   g_signal_connect_after(G_OBJECT(colourselection), "changed", GTK_SIGNAL_FUNC(colour_select), NULL);
 712
 713   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(glade_xml_get_widget(pGladeWidgets, "manual_colour")), !getBool(BP_PALETTE_CHANGE));
 714   gtk_widget_set_sensitive(glade_xml_get_widget(pGladeWidgets, "ColorTree"), !getBool(BP_PALETTE_CHANGE));
 715 }
 716
 717 // void SetAlphabetSelection(int i, GtkTreeIter *pAlphIter) {
 718 //  //  gchar ugly_path_hack[100];
 719 // //   sprintf(ugly_path_hack, "%d", i);
 720 //   gtk_tree_selection_select_iter(alphselection, pAlphIter);
 721
 722 //   // GtkTreePath *pPath(gtk_tree_path_new_from_string(ugly_path_hack));
 723
 724 //   GtkTreePath *pPath(gtk_tree_model_get_path(GTK_TREE_MODEL(alph_list_store), pAlphIter));
 725
 726 //   gtk_tree_view_set_cursor(GTK_TREE_VIEW(alphabettreeview), pPath, NULL, false);
 727 //   gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(alphabettreeview), pPath, NULL, false, 0.5, 0.0);
 728
 729 //   gtk_tree_path_free(pPath);
 730 // }
 731
 732
 733 void update_colours() {
 734
 735   // FIXME - REIMPLEMENT
 736
 737 //   if (training==true) {
 738 //     // We can go back and do this after training, but doing it now would
 739 //     // break stuff
 740 //     return;
 741 //   }
 742
 743 //   colourscheme=dasher_get_current_colours();
 744 //   const int colourlist_size=512;
 745 //   const char *colourlist[ colourlist_size ];
 746 //   int colour_count = dasher_get_colours( colourlist, colourlist_size );
 747 //   for (int i=0; i<colour_count; i++) {
 748 //     if (colourscheme==colourlist[i]) {
 749 //       // We need to build a path - GTK 2.2 lets us do this nicely, but we
 750 //       // want to support 2.0
 751 //       gchar ugly_path_hack[100];
 752 //       sprintf(ugly_path_hack,"%d",i);
 753 //       gtk_tree_selection_select_path(colourselection,gtk_tree_path_new_from_string(ugly_path_hack));
 754 //       gtk_tree_view_set_cursor(GTK_TREE_VIEW(colourtreeview),gtk_tree_path_new_from_string(ugly_path_hack),NULL,false);
 755 //     }
 756 //   }
 757 }
 758
 759 // General Callbacks
 760
 761 extern "C" gboolean preferences_hide(GtkWidget *widget, gpointer user_data) {
 762   gtk_widget_hide(preferences_window);
 763   return TRUE;
 764 }
 765
 766 // 'Alphabet' Page
 767
 768 // FIXME - maybe have a separate 'training thread' file
 769
 770 gpointer change_alphabet(gpointer alph) {
 771
 772    std::cout << "Starting training thread" << std::endl;
 773
 774   struct TrainingThreadData *pThreadData((struct TrainingThreadData *)alph);
 775
 776   gtk_dasher_control_set_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), SP_ALPHABET_ID, pThreadData->szAlphabet);
 777
 778   std::cout << "Finished training" << std::endl;
 779
 780   gtk_widget_destroy(pThreadData->pTrainingDialogue);
 781
 782   g_free(pThreadData->szAlphabet);
 783   delete pThreadData;
 784
 785   std::cout << "Finished training thread" << std::endl;
 786
 787   g_thread_exit(NULL);
 788
 789   return NULL;
 790 }
 791
 792 extern "C" void alphabet_select(GtkTreeSelection *selection, gpointer data) {
 793
 794   std::cout << "Thread status: " << g_thread_supported() << std::endl;
 795
 796   GtkTreeIter iter;
 797   GtkTreeModel *model;
 798   gchar *alph;
 799
 800   if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
 801     gtk_tree_model_get(model, &iter, 0, &alph, -1);
 802
 803     // FIXME - Reimplement this check
 804
 805     // There's no point in training if the alphabet is already selected
 806     //   if (alph!=alphabet) {
 807     //     alphabet=alph;
 808 #ifndef WITH_GPE
 809     // Don't let them select another alphabet while we're training the first one
 810     //  if (training==true) {
 811     //  return;
 812     //  }
 813
 814     // Note that we're training - this is needed in order to avoid
 815     // doing anything that would conflict with the other thread
 816     //  training=TRUE;
 817     //      trainqueue=g_async_queue_new();
 818
 819     struct TrainingThreadData *pThreadData(new struct TrainingThreadData);
 820
 821     std::cout << "*" << _("Training Dasher... please wait") << "*" << std::endl;
 822
 823     train_dialogue = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_NONE, _("Training Dasher... please wait"));
 824     gtk_window_set_resizable(GTK_WINDOW(train_dialogue), FALSE);
 825     gtk_window_present(GTK_WINDOW(train_dialogue));
 826
 827     pThreadData->szAlphabet = alph;
 828     pThreadData->pTrainingDialogue = train_dialogue;
 829     pThreadData->pDasherControl = pDasherWidget;
 830
 831     // Clear the queue of GTK events to make sure the dialogue gets displayed before we start training.
 832
 833     while(gtk_events_pending())
 834       gtk_main_iteration();
 835
 836     gtk_dasher_control_set_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), SP_ALPHABET_ID, pThreadData->szAlphabet);
 837
 838     gtk_widget_hide(pThreadData->pTrainingDialogue);
 839     gtk_widget_destroy(pThreadData->pTrainingDialogue);
 840
 841     g_free(pThreadData->szAlphabet);
 842     delete pThreadData;
 843
 844     //    trainthread = g_thread_create(change_alphabet, pThreadData, false, NULL);
 845
 846 #else
 847     // For GPE, we're not so fussed at the moment
 848     //      dasher_set_parameter_string( STRING_ALPHABET, (gchar*)alph );
 849     gtk_dasher_control_set_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), SP_ALPHABET_ID, alph);
 850 #endif
 851     //      g_free(alph);
 852     //  } else {
 853 //       g_free(alph);
 854 //     }
 855   }
 856 }
 857
 858 // 'Color' Page
 859
 860 extern "C" void colour_select(GtkTreeSelection *selection, gpointer data) {
 861
 862   // FIXME - REIMPLEMENT
 863
 864    GtkTreeIter iter;
 865    GtkTreeModel *model;
 866    gchar *colour;
 867
 868    if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
 869      gtk_tree_model_get(model, &iter, 0, &colour, -1);
 870
 871      gtk_dasher_control_set_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), SP_COLOUR_ID, colour);
 872
 873      // Reset the colour selection as well
 874
 875
 876      g_free(colour);
 877    }
 878 }
 879
 880 // 'Control' Page
 881
 882 // extern "C" void SetDimension(GtkWidget *widget, gpointer user_data) {
 883 //   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_NUMBER_DIMENSIONS, GTK_TOGGLE_BUTTON(widget)->active);
 884 // }
 885
 886 // extern "C" void SetEyetracker(GtkWidget *widget, gpointer user_data) {
 887 //   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_EYETRACKER_MODE, GTK_TOGGLE_BUTTON(widget)->active);
 888 // }
 889
 890 // extern "C" void SetClick(GtkWidget *widget, gpointer user_data) {
 891 //   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CLICK_MODE, GTK_TOGGLE_BUTTON(widget)->active);
 892 // }
 893
 894 extern "C" void startonleft(GtkWidget *widget, gpointer user_data) {
 895   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_START_MOUSE, GTK_TOGGLE_BUTTON(widget)->active);
 896 }
 897
 898 extern "C" void startonspace(GtkWidget *widget, gpointer user_data) {
 899   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_START_SPACE, GTK_TOGGLE_BUTTON(widget)->active);
 900 }
 901
 902 extern "C" void startonmousepos(GtkWidget *widget, gpointer user_data) {
 903   if(GTK_TOGGLE_BUTTON(widget)->active) {
 904     int iIndex;
 905     iIndex = gtk_combo_box_get_active(GTK_COMBO_BOX(m_pMousePosStyle));
 906
 907     if(iIndex == 1) {
 908       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_MOUSEPOS_MODE, true);
 909       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CIRCLE_START, false);
 910     }
 911     else {
 912       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_MOUSEPOS_MODE, false);
 913       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CIRCLE_START, true);
 914     }
 915   }
 916   else {
 917     gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_MOUSEPOS_MODE, false);
 918     gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CIRCLE_START, false);
 919   }
 920 }
 921
 922 extern "C" void OnMousePosStyleChanged(GtkWidget *widget, gpointer user_data) {
 923   // FIXME - duplicate code from extern "C" void startonmousepos
 924   if(GTK_TOGGLE_BUTTON(m_pMousePosButton)->active) {
 925     int iIndex;
 926     iIndex = gtk_combo_box_get_active(GTK_COMBO_BOX(m_pMousePosStyle));
 927
 928     if(iIndex == 1) {
 929       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_MOUSEPOS_MODE, true);
 930       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CIRCLE_START, false);
 931     }
 932     else {
 933       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_MOUSEPOS_MODE, false);
 934       gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CIRCLE_START, true);
 935     }
 936   }
 937 }
 938
 939 extern "C" void copy_all_on_stop(GtkWidget *widget, gpointer user_data) {
 940   dasher_app_settings_set_bool(g_pDasherAppSettings, APP_BP_COPY_ALL_ON_STOP, GTK_TOGGLE_BUTTON(widget)->active);
 941 }
 942
 943 extern "C" void windowpause(GtkWidget *widget, gpointer user_data) {
 944   dasher_app_settings_set_bool(g_pDasherAppSettings, BP_PAUSE_OUTSIDE, GTK_TOGGLE_BUTTON(widget)->active);
 945 }
 946
 947 extern "C" void on_controlmode_changed(GtkWidget *widget, gpointer user_data) {
 948   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_CONTROL_MODE, GTK_TOGGLE_BUTTON(widget)->active);
 949 }
 950
 951
 952 extern "C" void speak(GtkWidget *widget, gpointer user_data) {
 953   dasher_app_settings_set_bool(g_pDasherAppSettings, APP_BP_SPEECH_MODE, GTK_TOGGLE_BUTTON(widget)->active);
 954 }
 955
 956 extern "C" void PrefsSpeedSliderChanged(GtkHScale *hscale, gpointer user_data) {
 957     long iNewValue = long(round(gtk_range_get_value(GTK_RANGE(hscale)) * 100));
 958     dasher_app_settings_set_long(g_pDasherAppSettings, LP_MAX_BITRATE, iNewValue);
 959
 960 }
 961 extern "C" void adaptive(GtkWidget *widget, gpointer user_data) {
 962   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_AUTO_SPEEDCONTROL, GTK_TOGGLE_BUTTON(widget)->active);
 963 }
 964
 965 // 'View' Page
 966
 967 extern "C" void orientation(GtkRadioButton *widget, gpointer user_data) {
 968
 969   if(g_bIgnoreSignals)
 970     return;
 971
 972   // Again, this could be neater.
 973   if(GTK_TOGGLE_BUTTON(widget)->active == TRUE) {
 974     if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "radiobutton1")) {
 975       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION, Dasher::Opts::Alphabet);
 976
 977       // FIXME - get rid of global variables here.
 978
 979       gtk_widget_set_sensitive(m_pLRButton, FALSE);
 980       gtk_widget_set_sensitive(m_pRLButton, FALSE);
 981       gtk_widget_set_sensitive(m_pTBButton, FALSE);
 982       gtk_widget_set_sensitive(m_pBTButton, FALSE);
 983
 984
 985       g_bIgnoreSignals = true;
 986
 987       switch (getLong(LP_REAL_ORIENTATION)) {
 988       case Dasher::Opts::LeftToRight:
 989         if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pLRButton)) != TRUE)
 990           gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pLRButton), TRUE);
 991         break;
 992       case Dasher::Opts::RightToLeft:
 993         if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pRLButton)) != TRUE)
 994           gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pRLButton), TRUE);
 995         break;
 996       case Dasher::Opts::TopToBottom:
 997         if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pTBButton)) != TRUE)
 998           gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pTBButton), TRUE);
 999         break;
1000       case Dasher::Opts::BottomToTop:
1001         if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_pTBButton)) != TRUE)
1002           gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_pTBButton), TRUE);
1003         break;
1004       }
1005
1006       g_bIgnoreSignals = false;
1007     }
1008     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "radiobutton12")) {
1009       gtk_widget_set_sensitive(m_pLRButton, TRUE);
1010       gtk_widget_set_sensitive(m_pRLButton, TRUE);
1011       gtk_widget_set_sensitive(m_pTBButton, TRUE);
1012       gtk_widget_set_sensitive(m_pBTButton, TRUE);
1013
1014       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION,  getLong(LP_REAL_ORIENTATION));
1015     }
1016     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "radiobutton2")) {
1017       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION, Dasher::Opts::LeftToRight);
1018     }
1019     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "radiobutton3")) {
1020       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION, Dasher::Opts::RightToLeft);
1021     }
1022     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "radiobutton4")) {
1023       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION, Dasher::Opts::TopToBottom);
1024     }
1025     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "radiobutton5")) {
1026       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_ORIENTATION, Dasher::Opts::BottomToTop);
1027     }
1028   }
1029 }
1030
1031 extern "C" void generic_bool_changed(GtkWidget *widget, gpointer user_data) {
1032   RefreshParameter(widget, user_data);
1033 }
1034
1035 extern "C" void ThickLineClicked(GtkWidget *widget, gpointer user_data) {
1036   if(GTK_TOGGLE_BUTTON(widget)->active)
1037     gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_LINE_WIDTH, 3);
1038   else
1039     gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_LINE_WIDTH, 1);
1040 }
1041
1042 extern "C" void autocolour_clicked(GtkWidget *widget, gpointer user_data) {
1043   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_PALETTE_CHANGE, !GTK_TOGGLE_BUTTON(widget)->active);
1044 }
1045 // 'Advanced' Page
1046
1047 extern "C" void mouseposstart_y_changed(GtkRange *widget, gpointer user_data) {
1048   int mouseposstartdist=int(widget->adjustment->value);
1049   gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_MOUSEPOSDIST, mouseposstartdist);
1050 }
1051
1052 // 'Language Model' Page
1053
1054 extern "C" void languagemodel(GtkRadioButton *widget, gpointer user_data) {
1055   if (GTK_TOGGLE_BUTTON(widget)->active==TRUE) {
1056     if( !strcmp( gtk_widget_get_name( GTK_WIDGET(widget) ), "radiobutton6" ) ) {
1057       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget),  LP_LANGUAGE_MODEL_ID, 0 );
1058     } else if (!strcmp( gtk_widget_get_name( GTK_WIDGET(widget) ), "radiobutton7" )) {
1059       gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget),  LP_LANGUAGE_MODEL_ID, 2 );
1060     } else if (!strcmp( gtk_widget_get_name( GTK_WIDGET(widget) ), "radiobutton8" )) {
1061       gtk_dasher_control_set_parameter_long( GTK_DASHER_CONTROL(pDasherWidget), LP_LANGUAGE_MODEL_ID, 3 );
1062     } else if (!strcmp( gtk_widget_get_name( GTK_WIDGET(widget) ), "radiobutton9" )) {
1063       gtk_dasher_control_set_parameter_long( GTK_DASHER_CONTROL(pDasherWidget), LP_LANGUAGE_MODEL_ID, 4 );
1064     }
1065   }
1066 }
1067
1068 extern "C" void Adaptive(GtkWidget *widget, gpointer user_data) {
1069   // FIXME - Not yet implemented
1070 }
1071
1072 extern "C" void uniform_changed(GtkHScale *hscale) {
1073   gtk_dasher_control_set_parameter_long(GTK_DASHER_CONTROL(pDasherWidget), LP_UNIFORM, int (GTK_RANGE(hscale)->adjustment->value * 10));
1074 }
1075
1076
1077 // Advanced 2 page (reorganise!)
1078
1079 extern "C" void advanced_edited_callback(GtkCellRendererText *cell, gchar *path_string, gchar *new_text, gpointer pUserData) {
1080
1081   // TODO - store integer values in model
1082
1083   GtkTreeModel *pModel((GtkTreeModel*)pUserData);
1084
1085   GtkTreeIter iter;
1086   gtk_tree_model_get_iter_from_string( pModel, &iter, path_string );
1087
1088   gint iKey;
1089   gtk_tree_model_get( pModel, &iter, 2, &iKey, -1 );
1090
1091   gpointer pData;
1092   gtk_tree_model_get( pModel, &iter, 1, &pData, -1 );
1093   GValue *pValue((GValue *)pData);
1094
1095   if(G_VALUE_HOLDS_BOOLEAN(pValue)) {
1096     if(!strcmp(new_text, "Yes"))
1097       dasher_app_settings_set_bool(g_pDasherAppSettings, iKey, TRUE);
1098     else if(!strcmp(new_text, "No"))
1099       dasher_app_settings_set_bool(g_pDasherAppSettings, iKey, FALSE);
1100   }
1101   else if(G_VALUE_HOLDS_INT(pValue)) {
1102
1103     // TODO - use strtol here so we can detect errors
1104
1105     dasher_app_settings_set_long(g_pDasherAppSettings, iKey, atoi(new_text));
1106   }
1107   else if(G_VALUE_HOLDS_STRING(pValue)) {
1108     dasher_app_settings_set_string(g_pDasherAppSettings, iKey, new_text);
1109   }
1110 }
1111
1112 void update_advanced(int iParameter) {
1113
1114   // Don't do anything if we haven't created the tree model yet.
1115
1116   if(!GTK_IS_TREE_MODEL(m_pAdvancedModel))
1117     return;
1118
1119   GtkTreeIter sIter;
1120
1121   bool bMore(gtk_tree_model_get_iter_first(m_pAdvancedModel, &sIter));
1122
1123   while(bMore) {
1124
1125     gint iKey;
1126     gtk_tree_model_get( m_pAdvancedModel, &sIter, 2, &iKey, -1 );
1127
1128     if(iKey == iParameter) {
1129       gpointer pData;
1130       gtk_tree_model_get( m_pAdvancedModel, &sIter, 1, &pData, -1 );
1131       GValue *pValue((GValue *)pData);
1132
1133       if(G_VALUE_HOLDS_BOOLEAN(pValue))
1134         g_value_set_boolean(pValue, dasher_app_settings_get_bool(g_pDasherAppSettings, iParameter));
1135       else if(G_VALUE_HOLDS_INT(pValue))
1136         g_value_set_int(pValue, dasher_app_settings_get_long(g_pDasherAppSettings, iParameter));
1137       else if(G_VALUE_HOLDS_STRING(pValue))
1138         g_value_set_string(pValue, dasher_app_settings_get_string(g_pDasherAppSettings, iParameter));
1139
1140       gtk_tree_model_row_changed(m_pAdvancedModel, gtk_tree_model_get_path(m_pAdvancedModel, &sIter), &sIter);
1141
1142       return;
1143     }
1144
1145     bMore = gtk_tree_model_iter_next(m_pAdvancedModel, &sIter);
1146   }
1147
1148   return;
1149 }
1150
1151 extern "C" gboolean show_helper_window(GtkWidget *pWidget, gpointer *pUserData) {
1152   gtk_window_present(GTK_WINDOW(*pUserData));
1153 }
1154
1155 extern "C" gboolean advanced_preferences_show(GtkWidget *widget, gpointer user_data) {
1156   dasher_app_settings_launch_advanced(g_pDasherAppSettings);
1157   return FALSE;
1158 }
1159
1160 // extern "C" gboolean advanced_preferences_hide(GtkWidget *widget, gpointer user_data) {
1161 //   gtk_widget_hide(m_pAdvancedSettings);
1162 //   return FALSE;
1163 // }
1164
1165 // extern "C" void keycontrol(GtkWidget *widget, gpointer user_data) {
1166 //   gtk_dasher_control_set_parameter_bool(GTK_DASHER_CONTROL(pDasherWidget), BP_KEY_CONTROL, GTK_TOGGLE_BUTTON(widget)->active );
1167 // }
1168
1169 #ifdef WITH_MAEMO
1170 extern "C" void on_window_size_changed(GtkWidget *widget, gpointer user_data) {
1171   if(GTK_TOGGLE_BUTTON(widget)->active)
1172     dasher_app_settings_set_long(g_pDasherAppSettings, APP_LP_MAEMO_SIZE, 1);
1173   else
1174     dasher_app_settings_set_long(g_pDasherAppSettings, APP_LP_MAEMO_SIZE, 0);
1175 }
1176 #endif
1177
1178
1179 extern "C" void on_appstyle_changed(GtkWidget *widget, gpointer user_data) {
1180   if(GTK_TOGGLE_BUTTON(widget)->active) {
1181     if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "appstyle_classic"))
1182       dasher_app_settings_set_long(g_pDasherAppSettings, APP_LP_STYLE, 0);
1183     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "appstyle_compose"))
1184       dasher_app_settings_set_long(g_pDasherAppSettings, APP_LP_STYLE, 1);
1185     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "appstyle_direct"))
1186       dasher_app_settings_set_long(g_pDasherAppSettings, APP_LP_STYLE, 2);
1187     else if(!strcmp(gtk_widget_get_name(GTK_WIDGET(widget)), "appstyle_fullscreen"))
1188       dasher_app_settings_set_long(g_pDasherAppSettings, APP_LP_STYLE, 3);
1189   }
1190 }
1191
1192 void InitialiseTables(GladeXML *pGladeWidgets) {
1193 #ifndef WITH_MAEMO
1194   int iNumBoolEntries = sizeof(sBoolTranslationTable) / sizeof(BoolTranslation);
1195   for(int i(0); i < iNumBoolEntries; ++i) {
1196     sBoolTranslationTable[i].pWidget = glade_xml_get_widget(pGladeWidgets, sBoolTranslationTable[i].szWidgetName);
1197   }
1198 #endif
1199
1200   int iNumStringEntries = sizeof(sStringTranslationTable) / sizeof(StringTranslation);
1201   for(int i(0); i < iNumStringEntries; ++i) {
1202     sStringTranslationTable[i].pWidget = glade_xml_get_widget(pGladeWidgets, sStringTranslationTable[i].szWidgetName);
1203     if(sStringTranslationTable[i].szHelperName)
1204       sStringTranslationTable[i].pHelper = glade_xml_get_widget(pGladeWidgets, sStringTranslationTable[i].szHelperName);
1205
1206     dasher_preferences_populate_list(GTK_TREE_VIEW(sStringTranslationTable[i].pWidget), sStringTranslationTable[i].iParameter, sStringTranslationTable[i].pHelper);
1207     g_signal_connect(sStringTranslationTable[i].pWidget, "realize", (GCallback)on_widget_realize, &sStringTranslationTable[i].iParameter);
1208   }
1209 }
1210
1211 extern "C" gboolean refresh_foreach_function(GtkTreeModel *pModel, GtkTreePath *pPath, GtkTreeIter *pIter, gpointer pUserData) {
1212
1213   gpointer *pPointers = (gpointer *)pUserData;
1214
1215   gchar *szTarget = (gchar *)pPointers[0];
1216   gchar *szComparison;
1217   gtk_tree_model_get(pModel, pIter, 2, &szComparison, -1);
1218
1219   if(!strcmp(szTarget, szComparison)) {
1220     // Todo: set selection here?
1221     gtk_tree_view_set_cursor((GtkTreeView *)pPointers[1], pPath, NULL, false);
1222
1223     gtk_tree_view_scroll_to_cell((GtkTreeView *)pPointers[1], pPath, NULL, true, 0.5, 0.0);
1224
1225     return true;
1226   }
1227
1228   return false;
1229 }
1230
1231 void RefreshWidget(gint iParameter) {
1232 #ifndef WITH_MAEMO
1233   int iNumBoolEntries = sizeof(sBoolTranslationTable) / sizeof(BoolTranslation);
1234   for(int i(0); i < iNumBoolEntries; ++i) {
1235     if((iParameter == -1) || (sBoolTranslationTable[i].iParameter == iParameter)) {
1236       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sBoolTranslationTable[i].pWidget), dasher_app_settings_get_bool(g_pDasherAppSettings, sBoolTranslationTable[i].iParameter));
1237     }
1238   }
1239 #endif
1240
1241   // TODO: I believe that this is being called initially before the
1242   // widgets are realised, so the selection isn't being correctly
1243   // brought into view
1244   int iNumStringEntries = sizeof(sStringTranslationTable) / sizeof(StringTranslation);
1245   for(int i(0); i < iNumStringEntries; ++i) {
1246     if((iParameter == -1) || (sStringTranslationTable[i].iParameter == iParameter)) {
1247       GtkTreeModel *pModel = gtk_tree_view_get_model(GTK_TREE_VIEW(sStringTranslationTable[i].pWidget));
1248
1249       const void *pUserData[2];
1250       pUserData[0] = dasher_app_settings_get_string(g_pDasherAppSettings, sStringTranslationTable[i].iParameter);
1251       pUserData[1] = GTK_TREE_VIEW(sStringTranslationTable[i].pWidget);
1252
1253       if(sStringTranslationTable[i].pWidget && GTK_WIDGET_REALIZED(sStringTranslationTable[i].pWidget))
1254         gtk_tree_model_foreach(pModel, refresh_foreach_function, pUserData);
1255     }
1256   }
1257 }
1258
1259 extern "C" void RefreshParameter(GtkWidget *pWidget, gpointer pUserData) {
1260 #ifndef WITH_MAEMO
1261   int iNumBoolEntries = sizeof(sBoolTranslationTable) / sizeof(BoolTranslation);
1262
1263   for(int i(0); i < iNumBoolEntries; ++i) {
1264     if((pWidget == NULL) || (sBoolTranslationTable[i].pWidget == pWidget)) {
1265       if(GTK_TOGGLE_BUTTON(sBoolTranslationTable[i].pWidget)->active != dasher_app_settings_get_bool(g_pDasherAppSettings, sBoolTranslationTable[i].iParameter)) {
1266         dasher_app_settings_set_bool(g_pDasherAppSettings, sBoolTranslationTable[i].iParameter, GTK_TOGGLE_BUTTON(sBoolTranslationTable[i].pWidget)->active);
1267       }
1268     }
1269   }
1270 #endif
1271 }
1272
1273 void dasher_preferences_populate_list(GtkTreeView *pView, int iParameter, GtkWidget *pHelper) {
1274   // TODO: Need to kill helpers on list depopulation
1275
1276   const gchar *szCurrentValue(gtk_dasher_control_get_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), iParameter));
1277
1278   GArray *pFilterArray = gtk_dasher_control_get_allowed_values(GTK_DASHER_CONTROL(pDasherWidget), iParameter);
1279
1280   GtkListStore *pStore = gtk_list_store_new(6, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER);
1281   gtk_tree_view_set_model(pView, GTK_TREE_MODEL(pStore));
1282
1283   GtkCellRenderer *pRenderer;
1284   GtkTreeViewColumn *pColumn;
1285
1286   pRenderer = gtk_cell_renderer_text_new();
1287   pColumn = gtk_tree_view_column_new_with_attributes("Action", pRenderer, "text", 2, NULL);
1288   gtk_tree_view_append_column(pView, pColumn);
1289
1290   GtkTreeIter oIter;
1291   GtkTreeIter oSelectedIter;
1292   GtkTreeSelection *pSelection = gtk_tree_view_get_selection(pView);
1293
1294   GtkWidget **pHelperWindowRef = new GtkWidget *;
1295
1296   for(unsigned int i(0); i < pFilterArray->len; ++i) {
1297     const gchar *szCurrentFilter = g_array_index(pFilterArray, gchar *, i);
1298     gchar *szName = new gchar[strlen(szCurrentFilter) + 1];
1299     strcpy(szName, szCurrentFilter);
1300
1301     gtk_list_store_append(pStore, &oIter);
1302     GtkWidget *pHelperWindow;
1303
1304     if(pHelper) {
1305       pHelperWindow = dasher_preferences_dialogue_get_helper(g_pPreferencesDialogue, iParameter, szName);
1306       g_signal_connect(G_OBJECT(pHelper), "clicked", G_CALLBACK(show_helper_window), pHelperWindowRef);
1307     }
1308     else
1309       pHelperWindow = NULL;
1310
1311     // This is potentially horrible - maybe rethink in the future;
1312     gtk_list_store_set(pStore, &oIter, 0, iParameter, 1, pHelper, 2, szName, 3, szName, 4, pHelperWindow, 5, pHelperWindowRef, -1);
1313
1314     if(!strcmp(szCurrentFilter, szCurrentValue)) {
1315       gtk_tree_selection_select_iter(pSelection, &oIter);
1316       if(pHelper) {
1317         gtk_widget_set_sensitive(GTK_WIDGET(pHelper), pHelperWindow != NULL);
1318         *pHelperWindowRef = pHelperWindow;
1319       }
1320     }
1321   }
1322
1323
1324   g_signal_connect(pSelection, "changed", (GCallback)on_list_selection, 0);
1325 }
1326
1327 extern "C" void on_list_selection(GtkTreeSelection *pSelection, gpointer pUserData) {
1328   GtkTreeIter oIter;
1329   GtkTreeModel *pModel;
1330
1331   if(gtk_tree_selection_get_selected(pSelection, &pModel, &oIter)) {
1332     int iParameter;
1333     gpointer pHelper;
1334     gpointer pHelperWindow;
1335     gpointer pHelperWindowRef;
1336     gchar *szValue;
1337     gtk_tree_model_get(pModel, &oIter, 0, &iParameter, 1, &pHelper, 2, &szValue, 4, &pHelperWindow, 5, &pHelperWindowRef, -1);
1338
1339     gtk_dasher_control_set_parameter_string(GTK_DASHER_CONTROL(pDasherWidget), iParameter, szValue);
1340
1341     if(pHelper) {
1342       gtk_widget_set_sensitive(GTK_WIDGET(pHelper), pHelperWindow != NULL);
1343       *((GtkWidget **)pHelperWindowRef) = (GtkWidget *)pHelperWindow;
1344     }
1345   }
1346 }
1347
1348 extern "C" void on_action_toggle(GtkCellRendererToggle *pRenderer, gchar *szPath, gpointer pUserData) {
1349   gint *pColumnIndex = (gint *)pUserData;
1350
1351   GtkTreeIter oIter;
1352   gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(g_pStore), &oIter, szPath);
1353
1354   gboolean bSelected;
1355   gint iID;
1356   gtk_tree_model_get(GTK_TREE_MODEL(g_pStore), &oIter, ACTIONS_ID_COLUMN, &iID, *pColumnIndex, &bSelected, -1);
1357
1358   gtk_list_store_set(g_pStore, &oIter, *pColumnIndex, !bSelected, -1);
1359
1360   switch(*pColumnIndex) {
1361   case ACTIONS_SHOW_COLUMN:
1362     dasher_editor_action_set_show(g_pEditor, iID, !bSelected);
1363     break;
1364   case ACTIONS_CONTROL_COLUMN:
1365     dasher_editor_action_set_control(g_pEditor, iID, !bSelected);
1366     break;
1367   case ACTIONS_AUTO_COLUMN:
1368     dasher_editor_action_set_auto(g_pEditor, iID, !bSelected);
1369     break;
1370   }
1371 }
1372
1373 extern "C" void on_widget_realize(GtkWidget *pWidget, gpointer pUserData) {
1374    gint *pParameter = (gint *)pUserData;
1375    RefreshWidget(*pParameter);
1376 }
1377
1378 GtkWidget *dasher_preferences_dialogue_get_helper(DasherPreferencesDialogue *pSelf, int iParameter, const gchar *szValue) {
1379   SModuleSettings *pSettings;
1380   int iCount;
1381
1382   if(!gtk_dasher_control_get_module_settings(GTK_DASHER_CONTROL(pDasherWidget), szValue, &pSettings, &iCount))
1383     return NULL;
1384
1385   return module_settings_window_new(g_pDasherAppSettings, szValue, pSettings, iCount);
1386 }
1387
1388 void dasher_preferences_populate_font_buttons(DasherPreferencesDialogue *pSelf, GladeXML * pGladeWidgets) {
1389   GtkWidget *pDasherFontButton = glade_xml_get_widget(pGladeWidgets, "dasherfontbutton");
1390
1391   PangoFontDescription *pFont = pango_font_description_from_string(dasher_app_settings_get_string(g_pDasherAppSettings, SP_DASHER_FONT));
1392   gtk_widget_modify_font(pDasherFontButton, pFont);
1393
1394   gtk_button_set_label(GTK_BUTTON(pDasherFontButton), dasher_app_settings_get_string(g_pDasherAppSettings, SP_DASHER_FONT));
1395
1396   GtkWidget *pEditFontButton = glade_xml_get_widget(pGladeWidgets, "editfontbutton");
1397   gtk_button_set_label(GTK_BUTTON(pEditFontButton), dasher_app_settings_get_string(g_pDasherAppSettings, APP_SP_EDIT_FONT));
1398 }