00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifdef __cplusplus
00027 extern "C" {
00028 #endif
00029
00030 #include <gnome.h>
00031 #include <libgnome/libgnome.h>
00032 #include <gconf/gconf-client.h>
00033 #include <gdk/gdk.h>
00034
00035 #include "config.h"
00036 #include "gnome-res.h"
00037
00038
00039 extern int debug_level;
00040 #define BE_VERBOSE (debug_level > 3)
00041
00042 #ifdef BE_VERBOSE
00043 # define DEBUG_VERBOSE(format, args...) do { if (BE_VERBOSE) g_print ("** (" __FILE__ ": %s) Gnome-Res-DEBUG **: \n - " format, __FUNCTION__, ##args); } while(0)
00044 #else
00045 # define DEBUG_VERBOSE(format, args...) ;
00046 #endif
00047
00048
00049 extern int force_gconf_defaults;
00050
00051 #define PREF_CONFDLG_XSIZE 500
00052 #define PREF_CONFDLG_YSIZE 400
00053 #define PREF_VAR_PADDING 4
00054 #define PREF_VAR_USIZE 150
00055 #define PREF_OPT_USIZE 150
00056 #define PREF_IN_VBOX_PACK_MODE FALSE, TRUE, 1
00057 #define PREF_IN_HBOX_PACK_MODE TRUE, TRUE, PREF_VAR_PADDING
00058
00059
00060
00061 static void gnome_res_show_info_callback (GtkWidget *widget, gpointer message);
00062 static void gnome_res_apply_info_callback (GtkDialog* dialog,
00063 gint button_number,
00064 gpointer gnome_res_pref
00065 );
00066 static void gnome_res_get_option_callback (GtkWidget *menuitem, gpointer res);
00067 #if 0
00068 static void gnome_res_new_user_druid_prepare (GtkWidget *w, gpointer druid, gpointer gp_self);
00069 #endif
00070 static void gnome_res_new_user_druid_next (GtkWidget *w, gpointer druid, gpointer gp_self);
00071 static void gnome_res_new_user_druid_back (GtkWidget *w, gpointer druid, gpointer gp_self);
00072 static void gnome_res_new_user_druid_finished (GtkWidget *w, gpointer druid, gpointer gp_self);
00073 static void gnome_res_new_user_druid_cancel (GtkWidget *w, gpointer druid, gpointer gp_self);
00074
00075
00076
00077 gchar *gnome_res_get_resource_string_from_variable (GnomeResEntryInfoType *res);
00078 void gnome_res_make_resource_variable_edit_field (GnomeResEntryInfoType *res, GtkWidget *hbox);
00079
00080
00081 void gnome_res_new_user_druid_construct (GnomeResNewUserDruid *self);
00082 gint gnome_res_new_user_druid_construct_page (GnomeResNewUserDruid *self);
00083 void gnome_res_new_user_druid_destroy_druidpages (GnomeResNewUserDruid *self);
00084
00085 #define GCONF_APP_PREFIX "/apps/gxsm2/preferences/default"
00086
00087 GnomeResPreferences *gnome_res_preferences_new (GnomeResEntryInfoType *res_def){
00088 GnomeResPreferences *self = g_new (GnomeResPreferences, 1);
00089 self->res_def = res_def;
00090 DEBUG_VERBOSE ("gnome_res_preferences_new\n");
00091 self->pref_ok_message = NULL;
00092 self->pref_apply_message = NULL;
00093 self->dialog = NULL;
00094 self->running = FALSE;
00095 self->destroy_on_close = TRUE;
00096 self->pref_apply_callback = NULL;
00097 self->pref_apply_callback_data = NULL;
00098 return self;
00099 }
00100
00101 void gnome_res_destroy (GnomeResPreferences *self){
00102 DEBUG_VERBOSE ("gnome_res_destroy\n");
00103 if (self->running)
00104 gtk_widget_destroy (GTK_WIDGET (self->dialog));
00105 if (self->pref_ok_message)
00106 g_free (self->pref_ok_message);
00107 if (self->pref_apply_message)
00108 g_free (self->pref_apply_message);
00109 g_free (self);
00110 DEBUG_VERBOSE ("gnome_res_destroy done.\n");
00111 }
00112
00113 void gnome_res_set_ok_message (GnomeResPreferences *self, const gchar *ok_msg){
00114 if (self->pref_ok_message)
00115 g_free (self->pref_ok_message);
00116 self->pref_ok_message = g_strdup (ok_msg);
00117 }
00118
00119 void gnome_res_set_apply_message (GnomeResPreferences *self, const gchar *apply_msg){
00120 if (self->pref_apply_message)
00121 g_free (self->pref_apply_message);
00122 self->pref_apply_message = g_strdup (apply_msg);
00123 }
00124
00125 void gnome_res_set_apply_callback (GnomeResPreferences *self, void (*cb)(gpointer), gpointer data){
00126 self->pref_apply_callback = cb;
00127 self->pref_apply_callback_data = data;
00128 }
00129
00130 void gnome_res_set_destroy_on_close (GnomeResPreferences *self, int flg){
00131 self->destroy_on_close = flg;
00132 }
00133
00134 gchar *gnome_res_keytranslate (const gchar *name){
00135 gchar *name_key = g_strdelimit (g_strdup (name), ".", '/');
00136 gchar *key = g_strconcat (GCONF_APP_PREFIX, "/", name_key, NULL);
00137 g_free (name_key);
00138 return key;
00139 }
00140
00141
00142
00143
00144
00145
00146 void gnome_res_read_user_config (GnomeResPreferences *self){
00147 GnomeResEntryInfoType *res;
00148 gchar *respath, *p;
00149 gchar *vec[3], *tmp;
00150 GConfClient *client = gconf_client_get_default ();
00151
00152 DEBUG_VERBOSE ("gnome_res_read_user_config\n");
00153 if (self->res_def->path)
00154 respath = gnome_res_keytranslate (self->res_def->path);
00155 else
00156 respath = gnome_res_keytranslate ("Unknown/ResSetHasNoValidationKey");
00157
00158 if (!gconf_client_get_string (client, GCONF_APP_PREFIX "/GXSM_Version/oldest", NULL)
00159 || !gconf_client_get_string (client, respath, NULL)
00160 || force_gconf_defaults){
00161 GtkWidget *idlg = gtk_message_dialog_new (NULL,
00162 GTK_DIALOG_DESTROY_WITH_PARENT,
00163 GTK_MESSAGE_INFO,
00164 GTK_BUTTONS_CLOSE,
00165 "Config data too old or not yet set,\n"
00166 "creating GXSM G-Configuration section:\n"
00167 "'%s'\n"
00168 "new from build-in defaults. Please review!",
00169 respath);
00170
00171 g_signal_connect_swapped (GTK_OBJECT (idlg), "response",
00172 G_CALLBACK (gtk_widget_destroy),
00173 GTK_OBJECT (idlg));
00174 gtk_widget_show (idlg);
00175
00176 DEBUG_VERBOSE ("Applying GXSM gconf defaults\n");
00177 gconf_client_set_string (client, GCONF_APP_PREFIX "/GXSM_Version/oldest", VERSION, NULL);
00178 gconf_client_set_string (client, respath, "OK - remove this key to reset this section to defaults!", NULL);
00179 if (force_gconf_defaults)
00180 force_gconf_defaults = 2;
00181 else
00182 force_gconf_defaults = 1;
00183 }
00184 g_free (respath);
00185 gconf_client_set_string (client, GCONF_APP_PREFIX "/GXSM_Version/current", VERSION, NULL);
00186
00187 for (res = self->res_def; res->type != GNOME_RES_LAST; ++res){
00188 if (res->type == GNOME_RES_FIRST) ++res;
00189 if (res->type == GNOME_RES_IGNORE_INFO) continue;
00190 if (res->type == GNOME_RES_IGNORE_INFO) continue;
00191 if (!res->path) continue;
00192
00193 if (BE_VERBOSE) g_print ("Res->Path=%s\n", res->path);
00194
00195 respath = gnome_res_keytranslate (res->path);
00196
00197 if (BE_VERBOSE) g_print ("ResPath=%s = %s\n", respath, res->vdefault);
00198 switch (res->type){
00199 case GNOME_RES_BOOL:
00200 if (BE_VERBOSE) g_print ("-BOOL-\n");
00201 if (force_gconf_defaults)
00202 gconf_client_set_bool (client, respath, !strcasecmp (res->vdefault, "true") || !strcasecmp (res->vdefault, "yes"), NULL);
00203
00204 * ((int*) (res->var)) = gconf_client_get_bool (client, respath, NULL);
00205 break;
00206 case GNOME_RES_STRING:
00207 if (BE_VERBOSE) g_print ("-STRING-\n");
00208 if (force_gconf_defaults)
00209 gconf_client_set_string (client, respath, res->vdefault, NULL);
00210
00211 p = gconf_client_get_string (client, respath, NULL);
00212 if (p)
00213 strcpy ((gchar*)res->var, p);
00214 else{
00215 strcpy ((gchar*)res->var, res->vdefault);
00216 gconf_client_set_string (client, respath, (gchar*)res->vdefault, NULL);
00217 }
00218 break;
00219 case GNOME_RES_INT:
00220 if (BE_VERBOSE) g_print ("-INT-\n");
00221 if (force_gconf_defaults)
00222 gconf_client_set_int (client, respath, atoi (res->vdefault), NULL);
00223
00224 * ((int*) (res->var)) = gconf_client_get_int (client, respath, NULL);
00225 break;
00226 case GNOME_RES_FLOAT:
00227 case GNOME_RES_FLOAT_W_UNIT:
00228 if (BE_VERBOSE) g_print ("-FLOAT/_W_UNIT-\n");
00229 if (force_gconf_defaults)
00230 gconf_client_set_float (client, respath, atof (res->vdefault), NULL);
00231
00232 * ((float*) (res->var)) = gconf_client_get_float (client, respath, NULL);
00233 break;
00234 case GNOME_RES_FLOAT_VEC3:
00235 case GNOME_RES_FLOAT_VEC4:
00236 if (BE_VERBOSE) g_print ("-FLOAT_VEC3/4-\n");
00237 if (force_gconf_defaults)
00238 gconf_client_set_string (client, respath, res->vdefault, NULL);
00239
00240 p = gconf_client_get_string (client, respath, NULL);
00241 if (!p){
00242 strcpy ((gchar*)res->var, res->vdefault);
00243 gconf_client_set_string (client, respath, (gchar*)res->vdefault, NULL);
00244 }
00245
00246 ((float*) (res->var))[0] = atof( strtok_r(p, ", ", vec));
00247 tmp = strtok_r(NULL, ", ", vec);
00248 if (tmp){
00249 ((float*) (res->var))[1] = atof(tmp);
00250 tmp = strtok_r(NULL, ", ", vec);
00251 if (tmp){
00252 ((float*) (res->var))[2] = atof(tmp);
00253
00254 if (res->type == GNOME_RES_FLOAT_VEC4){
00255 tmp = strtok_r(NULL, ", ", vec);
00256 if (tmp)
00257 ((float*) (res->var))[3] = atof(tmp);
00258 }
00259 }
00260 }
00261 break;
00262 default:
00263 if (BE_VERBOSE) g_print ("-non-\n");
00264 break;
00265 }
00266 g_free (respath);
00267 }
00268
00269 if (BE_VERBOSE) g_print ("Read User Config done.\n");
00270
00271 if (force_gconf_defaults == 2)
00272 force_gconf_defaults = 1;
00273 else
00274 force_gconf_defaults = 0;
00275 }
00276
00277
00278
00279
00280
00281
00282 void gnome_res_write_user_config (GnomeResPreferences *self){
00283 GnomeResEntryInfoType *res;
00284 gchar *respath;
00285 gchar *vecstr=NULL;
00286 gchar *vec[3], *tmp;
00287 GConfClient *client = gconf_client_get_default ();
00288
00289 DEBUG_VERBOSE ("gnome_res_write_user_config\n");
00290
00291 for (res = self->res_def; res->type != GNOME_RES_LAST; ++res){
00292 if (res->type == GNOME_RES_FIRST) ++res;
00293 if (res->type == GNOME_RES_IGNORE_INFO) continue;
00294 respath = gnome_res_keytranslate (res->path);
00295
00296 if (BE_VERBOSE) g_print ("ResPath=%s = %s\n", respath, res->vdefault);
00297
00298 switch (res->type){
00299 case GNOME_RES_BOOL:
00300 if (res->entry)
00301 * ((int*) (res->var)) = strcasecmp (gtk_entry_get_text (GTK_ENTRY (res->entry)), "true") == 0;
00302 if (res->tmp)
00303 * ((int*) (res->var)) = strcasecmp (res->tmp, "true") == 0;
00304 gconf_client_set_bool (client, respath, (* ((int*) (res->var)))?TRUE:FALSE, NULL);
00305 break;
00306 case GNOME_RES_STRING:
00307 if (res->entry)
00308 strcpy ((gchar*)res->var, gtk_entry_get_text (GTK_ENTRY (res->entry)));
00309 if (res->tmp)
00310 strcpy ((gchar*)res->var, res->tmp);
00311 gconf_client_set_string (client, respath, (gchar*)res->var, NULL);
00312 break;
00313 case GNOME_RES_INT:
00314 if (res->entry)
00315 * ((int*) (res->var)) = atoi (gtk_entry_get_text (GTK_ENTRY (res->entry)));
00316 if (res->tmp)
00317 * ((int*) (res->var)) = atoi (res->tmp);
00318 gconf_client_set_int (client, respath, * ((int*) (res->var)), NULL);
00319 break;
00320 case GNOME_RES_FLOAT:
00321 case GNOME_RES_FLOAT_W_UNIT:
00322 if (res->entry)
00323 * ((float*) (res->var)) = atof (gtk_entry_get_text (GTK_ENTRY (res->entry)));
00324 if (res->tmp)
00325 * ((float*) (res->var)) = atof (res->tmp);
00326 gconf_client_set_float (client, respath, * ((float*) (res->var)), NULL);
00327 break;
00328 case GNOME_RES_FLOAT_VEC3:
00329 case GNOME_RES_FLOAT_VEC4:
00330 vecstr=NULL;
00331 if (res->entry)
00332 vecstr = g_strdup (gtk_entry_get_text (GTK_ENTRY (res->entry)));
00333 if (res->tmp){
00334 if (vecstr) g_free (vecstr);
00335 vecstr = g_strdup (res->tmp);
00336 }
00337 if (vecstr){
00338 gconf_client_set_string (client, respath, vecstr, NULL);
00339
00340 ((float*) (res->var))[0] = atof( strtok_r(vecstr, ", ", vec));
00341 tmp = strtok_r(NULL, ", ", vec);
00342 if (tmp){
00343 ((float*) (res->var))[1] = atof(tmp);
00344 tmp = strtok_r(NULL, ", ", vec);
00345 if (tmp){
00346 ((float*) (res->var))[2] = atof(tmp);
00347
00348 if (res->type == GNOME_RES_FLOAT_VEC4){
00349 tmp = strtok_r(NULL, ", ", vec);
00350 if (tmp)
00351 ((float*) (res->var))[3] = atof(tmp);
00352 }
00353 }
00354 }
00355 g_free (vecstr);
00356 }
00357 break;
00358 default:
00359 break;
00360 }
00361 g_free (respath);
00362 }
00363 }
00364
00365 static void gnome_res_show_info_callback (GtkWidget *widget, gpointer message){
00366 GtkWidget *dialog = gtk_message_dialog_new (NULL,
00367 GTK_DIALOG_DESTROY_WITH_PARENT,
00368 GTK_MESSAGE_INFO,
00369 GTK_BUTTONS_CLOSE,
00370 message);
00371 g_signal_connect_swapped (GTK_OBJECT (dialog), "response",
00372 G_CALLBACK (gtk_widget_destroy),
00373 GTK_OBJECT (dialog));
00374 gtk_widget_show (dialog);
00375 }
00376
00377 static void gnome_res_apply_info_callback (GtkDialog *dialog,
00378 gint response,
00379 gpointer gp_self){
00380 GnomeResPreferences *self = (GnomeResPreferences *) gp_self;
00381 switch (response){
00382 case GTK_RESPONSE_ACCEPT:
00383 gnome_res_write_user_config (self);
00384 gtk_widget_destroy (GTK_WIDGET (dialog));
00385 if (self->pref_ok_message){
00386 GtkWidget *dialog = gtk_message_dialog_new (NULL,
00387 GTK_DIALOG_DESTROY_WITH_PARENT,
00388 GTK_MESSAGE_INFO,
00389 GTK_BUTTONS_OK,
00390 self->pref_ok_message);
00391 gtk_dialog_run (GTK_DIALOG (dialog));
00392 gtk_widget_destroy (dialog);
00393 }
00394 self->running = FALSE;
00395 if (self->destroy_on_close)
00396 gnome_res_destroy (self);
00397 if (self->pref_apply_callback)
00398 (*self->pref_apply_callback)(self->pref_apply_callback_data);
00399 break;
00400 case GTK_RESPONSE_APPLY:
00401 gnome_res_write_user_config (self);
00402 if (self->pref_apply_message){
00403 GtkWidget *dialog = gtk_message_dialog_new (NULL,
00404 GTK_DIALOG_DESTROY_WITH_PARENT,
00405 GTK_MESSAGE_INFO,
00406 GTK_BUTTONS_OK,
00407 self->pref_apply_message);
00408 gtk_dialog_run (GTK_DIALOG (dialog));
00409 gtk_widget_destroy (dialog);
00410 }
00411 if (self->pref_apply_callback)
00412 (*self->pref_apply_callback)(self->pref_apply_callback_data);
00413 break;
00414 case GTK_RESPONSE_CANCEL:
00415 gtk_widget_destroy (GTK_WIDGET (dialog));
00416 self->running = FALSE;
00417 if (self->destroy_on_close)
00418 gnome_res_destroy (self);
00419 break;
00420 }
00421 }
00422
00423 gchar *gnome_res_get_resource_string_from_variable (GnomeResEntryInfoType *res){
00424
00425 switch (res->type){
00426 case GNOME_RES_BOOL:
00427 return g_strdup_printf ("%s", * ((int*) (res->var)) ? "true":"false");
00428 case GNOME_RES_STRING:
00429 return g_strdup_printf ("%s", ((gchar*) (res->var)));
00430 case GNOME_RES_INT:
00431 return g_strdup_printf ("%d", * ((int*) (res->var)));
00432 case GNOME_RES_FLOAT:
00433 return g_strdup_printf ("%g", * ((float*) (res->var)));
00434 case GNOME_RES_FLOAT_W_UNIT:
00435 return g_strdup_printf ("%g %s", * ((float*) (res->var)), *res->options);
00436 case GNOME_RES_FLOAT_VEC3:
00437 return g_strdup_printf ("%g, %g, %g",
00438 ((float*) (res->var))[0],
00439 ((float*) (res->var))[1],
00440 ((float*) (res->var))[2]);
00441 case GNOME_RES_FLOAT_VEC4:
00442 return g_strdup_printf ("%g, %g, %g, %g",
00443 ((float*) (res->var))[0],
00444 ((float*) (res->var))[1],
00445 ((float*) (res->var))[2],
00446 ((float*) (res->var))[3]);
00447 default:
00448 break;
00449 }
00450 return g_strdup ("Illegal Ressource Type");
00451 }
00452
00453 void gnome_res_adjustment_callback(GtkAdjustment *adj, GnomeResEntryInfoType *res){
00454 * ((float*) res->var) = (float) adj->value;
00455
00456 if (((GnomeResEntryInfoType *) res)->tmp)
00457 g_free (((GnomeResEntryInfoType *) res)->tmp);
00458
00459 ((GnomeResEntryInfoType *) res)->tmp = g_strdup_printf ("%g", adj->value);
00460
00461 if (res->changed_callback)
00462 (*res->changed_callback)(res->moreinfo);
00463 }
00464
00465 void gnome_res_colorchange_callback(GnomeColorPicker *colorsel,
00466 guint r, guint g, guint b, guint a,
00467 GnomeResEntryInfoType *res){
00468 gdouble color[4];
00469 gnome_color_picker_get_d (colorsel, &color[0], &color[1], &color[2], &color[3]);
00470
00471 ((float *)(res->var))[0] = (float) color[0];
00472 ((float *)(res->var))[1] = (float) color[1];
00473 ((float *)(res->var))[2] = (float) color[2];
00474 ((float *)(res->var))[3] = (float) color[3];
00475
00476 if (((GnomeResEntryInfoType *) res)->tmp)
00477 g_free (((GnomeResEntryInfoType *) res)->tmp);
00478
00479 ((GnomeResEntryInfoType *) res)->tmp = g_strdup_printf ("%g, %g, %g, %g",
00480 color[0], color[1], color[2], color[3]);
00481 if (res->changed_callback)
00482 (*res->changed_callback)(res->moreinfo);
00483 }
00484
00485
00486 void gnome_res_fontchange_callback(GnomeFontPicker *gfp, gchar *arg1, GnomeResEntryInfoType *res){
00487
00488 if (((GnomeResEntryInfoType *) res)->tmp)
00489 g_free (((GnomeResEntryInfoType *) res)->tmp);
00490
00491 ((GnomeResEntryInfoType *) res)->tmp = g_strdup (gnome_font_picker_get_font_name (gfp));
00492
00493 if (res->changed_callback)
00494 (*res->changed_callback)(res->moreinfo);
00495 }
00496
00497
00498 void gnome_res_make_resource_variable_edit_field (GnomeResEntryInfoType *res,
00499 GtkWidget *hbox){
00500 GtkWidget *VarName;
00501 GtkWidget *variable=NULL;
00502 int defaultidx;
00503 int i;
00504 gchar **option;
00505
00506
00507 VarName = gtk_label_new (res->path);
00508 gtk_widget_set_usize (VarName, PREF_VAR_USIZE, -1);
00509 gtk_widget_show (VarName);
00510 gtk_label_set_justify (GTK_LABEL (VarName), GTK_JUSTIFY_LEFT);
00511 gtk_misc_set_alignment (GTK_MISC (VarName), 0.0, 0.5);
00512 gtk_misc_set_padding (GTK_MISC (VarName), PREF_VAR_PADDING, 0);
00513
00514 gtk_box_pack_start (GTK_BOX (hbox), VarName, PREF_IN_HBOX_PACK_MODE);
00515
00516 res->entry = NULL;
00517 res->tmp = NULL;
00518
00519 switch (res->edit_type){
00520 case GNOME_RES_EDIT_NO: break;
00521 case GNOME_RES_EDIT_OPTIONS:
00522
00523 if (res->options && res->type != GNOME_RES_FLOAT_W_UNIT){
00524 GtkWidget *wid, *menu, *menuitem;
00525
00526 wid = gtk_option_menu_new ();
00527 gtk_widget_set_usize (wid, PREF_OPT_USIZE, -1);
00528 gtk_container_add (GTK_CONTAINER (hbox), wid);
00529
00530 menu = gtk_menu_new ();
00531
00532
00533 defaultidx=0;
00534 for (i=0, option = res->options; *option; ++option, ++i){
00535 if (res->option_text_format){
00536 gchar *menuitemtext = g_strdup_printf (res->option_text_format, *option, res->option_data[i]);
00537 menuitem = gtk_menu_item_new_with_label (menuitemtext);
00538 g_free (menuitemtext);
00539 }
00540 else
00541 menuitem = gtk_menu_item_new_with_label (*option);
00542
00543 gtk_menu_append (GTK_MENU (menu), menuitem);
00544
00545 gtk_object_set_data (GTK_OBJECT (menuitem), "entrydata", (gpointer)*option);
00546 gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
00547 GTK_SIGNAL_FUNC (gnome_res_get_option_callback),
00548 (gpointer) res);
00549 {
00550 gchar *s;
00551 if (strcmp (*option, s=gnome_res_get_resource_string_from_variable (res)) == 0)
00552 defaultidx=i;
00553 g_free (s);
00554 }
00555
00556 }
00557 gtk_option_menu_set_menu (GTK_OPTION_MENU (wid), menu);
00558 gtk_option_menu_set_history (GTK_OPTION_MENU (wid), defaultidx);
00559 }
00560 break;
00561 case GNOME_RES_EDIT_ENTRY:
00562 {
00563 gchar *resdata;
00564 variable = gtk_entry_new ();
00565 res->entry = variable;
00566
00567 resdata = gnome_res_get_resource_string_from_variable (res);
00568
00569 gtk_entry_set_text (GTK_ENTRY (variable), resdata);
00570 g_free (resdata);
00571 }
00572 break;
00573 case GNOME_RES_EDIT_VALSLIDER:
00574 {
00575 GtkObject *adj = gtk_adjustment_new ( (gfloat) *((float*) (res->var)),
00576 (gfloat) atof (res->options[0]),
00577 (gfloat) atof (res->options[1]),
00578 (gfloat) atof (res->options[2]),
00579 (gfloat) atof (res->options[3]),
00580 (gfloat) 0);
00581 variable = gtk_hscale_new (GTK_ADJUSTMENT (adj));
00582 gtk_scale_set_value_pos (GTK_SCALE (variable), GTK_POS_LEFT);
00583 gtk_scale_set_digits (GTK_SCALE (variable), (gint) atoi (res->options[4]));
00584 gtk_range_set_update_policy (GTK_RANGE (variable), GTK_UPDATE_DELAYED);
00585
00586 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
00587 GTK_SIGNAL_FUNC (gnome_res_adjustment_callback), (gpointer) res);
00588 }
00589 break;
00590 case GNOME_RES_EDIT_COLORSEL:
00591 {
00592 variable = gnome_color_picker_new ();
00593 if (res->name)
00594 gnome_color_picker_set_title (GNOME_COLOR_PICKER (variable), res->name);
00595 gnome_color_picker_set_use_alpha (GNOME_COLOR_PICKER (variable), TRUE);
00596 gnome_color_picker_set_d (GNOME_COLOR_PICKER (variable),
00597 (gdouble)((float *)(res->var))[0],
00598 (gdouble)((float *)(res->var))[1],
00599 (gdouble)((float *)(res->var))[2],
00600 (gdouble)((float *)(res->var))[3]);
00601 gtk_signal_connect (GTK_OBJECT (variable), "color_set",
00602 GTK_SIGNAL_FUNC (gnome_res_colorchange_callback),
00603 (gpointer) res);
00604 }
00605 break;
00606 case GNOME_RES_EDIT_FONTSEL:
00607 {
00608 variable = gnome_font_picker_new ();
00609 if (res->name)
00610 gnome_font_picker_set_title (GNOME_FONT_PICKER (variable), res->name);
00611 gnome_font_picker_set_mode (GNOME_FONT_PICKER (variable), GNOME_FONT_PICKER_MODE_FONT_INFO);
00612 gnome_font_picker_set_preview_text (GNOME_FONT_PICKER (variable), "ABCabc123");
00613 gnome_font_picker_set_font_name (GNOME_FONT_PICKER (variable), res->var);
00614 gtk_signal_connect (GTK_OBJECT (variable), "font_set",
00615 GTK_SIGNAL_FUNC (gnome_res_fontchange_callback),
00616 (gpointer) res);
00617 }
00618 break;
00619 }
00620 if (variable)
00621 gtk_box_pack_start (GTK_BOX (hbox), variable, PREF_IN_HBOX_PACK_MODE);
00622 }
00623
00624
00625 static void gnome_res_get_option_callback (GtkWidget *menuitem, gpointer res){
00626 if (((GnomeResEntryInfoType *) res)->tmp)
00627 g_free (((GnomeResEntryInfoType *) res)->tmp);
00628
00629 ((GnomeResEntryInfoType *) res)->tmp = g_strdup (
00630 (gchar*)gtk_object_get_data (GTK_OBJECT (menuitem), "entrydata")
00631 );
00632 }
00633
00634
00635
00636
00637 void gnome_res_run_change_user_config (GnomeResPreferences *self, const gchar *dialog_title){
00638 GtkWidget *notebook;
00639 GtkWidget *scrolled_contents;
00640 GtkWidget *vbox;
00641 GtkWidget *hbox;
00642 GtkWidget *help;
00643 int pageno;
00644
00645 GnomeResEntryInfoType *res;
00646 const gchar *pagename;
00647
00648 if (self->running) return;
00649 self->running = TRUE;
00650
00651 DEBUG_VERBOSE ("gnome_res_run_change_user_config\n");
00652
00653 self->dialog = gtk_dialog_new_with_buttons (_(dialog_title),
00654 NULL,
00655 (GtkDialogFlags)(GTK_DIALOG_DESTROY_WITH_PARENT),
00656 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
00657 GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
00658 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
00659 NULL);
00660
00661 gtk_window_get_resizable (GTK_WINDOW (self->dialog));
00662
00663 gtk_widget_set_size_request (self->dialog, PREF_CONFDLG_XSIZE, PREF_CONFDLG_YSIZE);
00664
00665 notebook = gtk_notebook_new ();
00666 gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
00667
00668 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self->dialog)->vbox),
00669 notebook, TRUE, TRUE, GNOME_PAD);
00670
00671 for (res = self->res_def, pageno=0; res->type != GNOME_RES_LAST; ++pageno){
00672 if (res->type == GNOME_RES_FIRST) ++res;
00673 DEBUG_VERBOSE ("ResEdit page=%d\n", pageno);
00674 pagename = res->group;
00675 scrolled_contents = gtk_scrolled_window_new (NULL, NULL);
00676 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_contents),
00677 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
00678 vbox = gtk_vbox_new (FALSE, 0);
00679 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_contents), vbox);
00680
00681 for (; res->type != GNOME_RES_LAST && strcmp (res->group, pagename)==0; ++res){
00682 DEBUG_VERBOSE ("ResEdit res=%s\n", res->path);
00683 res->entry = NULL;
00684 if (res->type == GNOME_RES_SEPARATOR){
00685 gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new(), PREF_IN_VBOX_PACK_MODE);
00686 if (res->comment){
00687 help = gtk_label_new (res->comment);
00688 gtk_label_set_justify (GTK_LABEL (help), GTK_JUSTIFY_LEFT);
00689 gtk_box_pack_start (GTK_BOX (vbox), help, PREF_IN_HBOX_PACK_MODE);
00690 gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new(), PREF_IN_VBOX_PACK_MODE);
00691 }
00692 continue;
00693 }
00694 if (res->type == GNOME_RES_IGNORE_INFO) continue;
00695
00696 hbox = gtk_hbox_new (FALSE, 0);
00697
00698 gnome_res_make_resource_variable_edit_field (res, hbox);
00699
00700 help = gtk_button_new_with_label (_("Help"));
00701 gtk_box_pack_start (GTK_BOX (hbox), help, PREF_IN_HBOX_PACK_MODE);
00702 gtk_signal_connect (GTK_OBJECT (help), "clicked",
00703 GTK_SIGNAL_FUNC (gnome_res_show_info_callback),
00704 (void*)res->comment);
00705
00706 gtk_box_pack_start (GTK_BOX (vbox), hbox, PREF_IN_VBOX_PACK_MODE);
00707
00708 }
00709 gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
00710 scrolled_contents,
00711 gtk_label_new (pagename));
00712 }
00713
00714 gtk_signal_connect (GTK_OBJECT (self->dialog), "response",
00715 GTK_SIGNAL_FUNC (gnome_res_apply_info_callback),
00716 (gpointer*) self);
00717
00718 gtk_object_set_data (GTK_OBJECT (self->dialog), "self", (gpointer) self);
00719 gtk_widget_show_all (self->dialog);
00720 }
00721
00722
00723
00724
00725
00726
00727
00728 GnomeResNewUserDruid *gnome_res_new_user_druid_new (GnomeResEntryInfoType *res_def, const gchar *title){
00729 return gnome_res_new_user_druid_new_with_vals (res_def, title, NULL, NULL,
00730 "Welcome", "Setup", "Done", "Have fun!");
00731 }
00732
00733 GnomeResNewUserDruid *gnome_res_new_user_druid_new_with_vals (GnomeResEntryInfoType *res_def,
00734 const gchar *title,
00735 GdkPixbuf *logo,
00736 GdkPixbuf *watermark,
00737 const gchar *welcome,
00738 const gchar *intro_text,
00739 const gchar *finish,
00740 const gchar *final_text
00741 ){
00742 GnomeResNewUserDruid *self = g_new (GnomeResNewUserDruid, 1);
00743 DEBUG_VERBOSE ("gnome_res_new_user_druid_new_with_vals: 1 \n");
00744
00745 self->res_pref = gnome_res_preferences_new (res_def);
00746 self->title = g_strdup (title);
00747 self->logo = logo;
00748 self->watermark = watermark;
00749 self->welcome = g_strdup (welcome);
00750 self->intro_text = g_strdup (intro_text);
00751 self->finish = g_strdup (finish);
00752 self->final_text = g_strdup (final_text);
00753 self->startpage = NULL;
00754 self->page = NULL;
00755 self->finishpage = NULL;
00756 self->pageindex = 0;
00757 self->pagescreated = 0;
00758
00759 gnome_res_read_user_config (self->res_pref);
00760
00761 self->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
00762 gtk_window_set_title (GTK_WINDOW (self->window), self->title);
00763
00764 gnome_res_new_user_druid_construct (self);
00765
00766 gtk_container_add (GTK_CONTAINER (self->window), self->druid);
00767
00768 return self;
00769 }
00770
00771 void gnome_res_new_user_druid_destroy (GnomeResNewUserDruid *self){
00772 DEBUG_VERBOSE ("gnome_res_new_user_druid_destroy: Druid destroy, free\n");
00773 g_free (self->title);
00774 g_free (self->welcome);
00775 g_free (self->intro_text);
00776 g_free (self->finish);
00777 g_free (self->final_text);
00778 gnome_res_destroy (self->res_pref);
00779 g_free (self);
00780 }
00781
00782
00783
00784
00785
00786 #define NO_SELECT_PAGES
00787 void gnome_res_new_user_druid_construct (GnomeResNewUserDruid *self){
00788 DEBUG_VERBOSE ("gnome_res_new_user_druid_construct: ..1\n");
00789 self->druid = gnome_druid_new ();
00790
00791 self->startpage = gnome_druid_page_edge_new_with_vals (
00792 GNOME_EDGE_START, TRUE,
00793 self->welcome, self->intro_text, self->logo, self->watermark, NULL);
00794 gnome_druid_append_page (
00795 GNOME_DRUID (self->druid), GNOME_DRUID_PAGE (self->startpage));
00796 gtk_object_set_data (GTK_OBJECT (self->startpage), "self", (gpointer) self);
00797
00798 gtk_signal_connect (GTK_OBJECT (self->startpage), "cancel",
00799 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_cancel),
00800 (gpointer) self);
00801 #ifndef NO_SELECT_PAGES
00802 gtk_signal_connect (GTK_OBJECT (self->startpage), "next",
00803 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_next),
00804 (gpointer) self);
00805 #endif
00806
00807 #ifdef NO_SELECT_PAGES
00808 do{
00809 gnome_res_new_user_druid_construct_page (self);
00810
00811 if (self->page){
00812 ++self->pagescreated;
00813 DEBUG_VERBOSE ("NEXT: adding page\n");
00814 gnome_druid_append_page (GNOME_DRUID (self->druid),
00815 GNOME_DRUID_PAGE (self->page));
00816 gtk_object_set_data (GTK_OBJECT (self->page), "self", (gpointer) self);
00817 }
00818 }while (self->page);
00819 #endif
00820
00821
00822 self->finishpage = gnome_druid_page_edge_new_with_vals (
00823 GNOME_EDGE_FINISH, TRUE,
00824 self->finish, self->final_text, self->logo, self->watermark, NULL);
00825
00826 gnome_druid_append_page
00827 (GNOME_DRUID (self->druid), GNOME_DRUID_PAGE (self->finishpage));
00828 gtk_object_set_data (GTK_OBJECT (self->finishpage), "self", (gpointer) self);
00829 gtk_object_set_data (GTK_OBJECT (self->finishpage), "beforeself", (gpointer) self->startpage);
00830 gtk_object_set_data (GTK_OBJECT (self->startpage), "behindeself", (gpointer) self->finishpage);
00831
00832 gtk_signal_connect (GTK_OBJECT (self->finishpage), "finish",
00833 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_finished),
00834 (gpointer) self);
00835 gtk_signal_connect (GTK_OBJECT (self->finishpage), "cancel",
00836 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_cancel),
00837 (gpointer) self);
00838 #ifndef NO_SELECT_PAGES
00839 gtk_signal_connect (GTK_OBJECT (self->startpage), "back",
00840 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_back),
00841 (gpointer) self);
00842 #endif
00843 }
00844
00845 gint gnome_res_new_user_druid_construct_page (GnomeResNewUserDruid *self){
00846 static GnomeResEntryInfoType *res=NULL;
00847 GtkWidget *scrolled_window = NULL;
00848 GtkWidget *vbox;
00849 GtkWidget *hbox;
00850 GtkWidget *help;
00851 int num;
00852 const gchar *pagename;
00853
00854
00855 DEBUG_VERBOSE ("gnome_res_new_user_druid_construct_page\n");
00856
00857 self->page = NULL;
00858 if (!res) res = self->res_pref->res_def;
00859 if (res->type == GNOME_RES_LAST) return FALSE;
00860
00861 for (; res->type != GNOME_RES_LAST; ){
00862 if (res->type == GNOME_RES_FIRST) ++res;
00863 DEBUG_VERBOSE ("DruidPageConstruct: path=%s group=%s\n", res->path, res->group);
00864 #ifndef NO_SELECT_PAGES
00865 if (res->depend_func)
00866 if (! (*res->depend_func)()){
00867 DEBUG_VERBOSE ("skipping, depfkt does not match!\n");
00868 ++res;
00869 continue;
00870 }
00871 #endif
00872 pagename = res->group;
00873 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
00874 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
00875 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
00876 vbox = gtk_vbox_new (FALSE, 0);
00877 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), vbox);
00878
00879 for (num=0; res->type != GNOME_RES_LAST && strcmp (res->group, pagename)==0; ++res){
00880 DEBUG_VERBOSE ("in group, path=%s\n", res->path);
00881 res->entry = NULL;
00882 if (res->level == GNOME_RES_LEVEL_AUTO) continue;
00883 #ifndef NO_SELECT_PAGES
00884 if (res->depend_func)
00885 if (! (*res->depend_func)()){
00886 DEBUG_VERBOSE ("skipping, depfkt does not match!\n");
00887 continue;
00888 }
00889 #endif
00890 ++num;
00891
00892 if (res->type == GNOME_RES_IGNORE_INFO){
00893 gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), PREF_IN_VBOX_PACK_MODE);
00894
00895 hbox = gtk_hbox_new (FALSE, 0);
00896
00897 help = gtk_label_new (res->comment);
00898 gtk_label_set_justify (GTK_LABEL (help), GTK_JUSTIFY_LEFT);
00899
00900
00901
00902
00903
00904
00905 gtk_box_pack_start (GTK_BOX (hbox), help, PREF_IN_HBOX_PACK_MODE);
00906 gtk_box_pack_start (GTK_BOX (vbox), hbox, PREF_IN_VBOX_PACK_MODE);
00907
00908 }else{
00909
00910 gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), PREF_IN_VBOX_PACK_MODE);
00911
00912 hbox = gtk_hbox_new (FALSE, 0);
00913
00914 help = gtk_label_new (res->comment);
00915 gtk_label_set_justify (GTK_LABEL (help), GTK_JUSTIFY_LEFT);
00916 gtk_misc_set_alignment (GTK_MISC (help), 0.0, 0.5);
00917 gtk_box_pack_start (GTK_BOX (hbox), help, PREF_IN_HBOX_PACK_MODE);
00918 gtk_box_pack_start (GTK_BOX (vbox), hbox, PREF_IN_VBOX_PACK_MODE);
00919
00920 hbox = gtk_hbox_new (FALSE, 0);
00921
00922 gnome_res_make_resource_variable_edit_field (res, hbox);
00923
00924 gtk_box_pack_start (GTK_BOX (vbox), hbox, PREF_IN_VBOX_PACK_MODE);
00925 }
00926 }
00927 if (num){
00928 self->page = gnome_druid_page_standard_new_with_vals (pagename, self->logo, self->watermark);
00929 gtk_box_pack_start (GTK_BOX ((GNOME_DRUID_PAGE_STANDARD (self->page))->vbox),
00930 GTK_WIDGET (scrolled_window), TRUE, TRUE, 0);
00931 break;
00932 }
00933 }
00934 return self->page ? TRUE:FALSE;
00935 }
00936
00937 GnomeResDruidFinishType gnome_res_new_user_druid_run_druids (GnomeResNewUserDruid *self){
00938 DEBUG_VERBOSE ("gnome_res_new_user_druid_run_druids\n");
00939
00940 self->finishmode = GNOME_RES_DRUID_RUNNING;
00941 gtk_widget_show_all (GTK_WIDGET (self->window));
00942
00943 gtk_main ();
00944
00945 return self->finishmode;
00946 }
00947
00948 void gnome_res_new_user_druid_destroy_druidpages (GnomeResNewUserDruid *self) {
00949 DEBUG_VERBOSE ("gnome_res_new_user_druid_destroy_druidpages: Druid destroy druids\n");
00950 gtk_object_destroy (GTK_OBJECT (self->druid));
00951 DEBUG_VERBOSE ("Druid destroy window\n");
00952 gtk_widget_destroy (self->window);
00953
00954
00955
00956
00957
00958 DEBUG_VERBOSE ("Druid destroy done.\n");
00959 }
00960
00961 #if 0
00962 static void gnome_res_new_user_druid_prepare (GtkWidget *w, gpointer druid, gpointer gp_self) {
00963 GnomeResNewUserDruid *self = (GnomeResNewUserDruid *) gp_self;
00964 DEBUG_VERBOSE ("PREPARE: %d (%d)\n", self->pageindex, self->pagescreated);
00965 }
00966 #endif
00967
00968 static void gnome_res_new_user_druid_next (GtkWidget *w, gpointer druid, gpointer gp_self) {
00969 GnomeResNewUserDruid *self = (GnomeResNewUserDruid *) gp_self;
00970 DEBUG_VERBOSE ("NEXTv: %d (%d)\n", self->pageindex, self->pagescreated);
00971
00972 gnome_res_write_user_config (self->res_pref);
00973
00974 if (++self->pageindex > self->pagescreated){
00975 GtkWidget *BackPage = self->page ? self->page : self->startpage;
00976 DEBUG_VERBOSE ("NEXT: checking/creating new page\n");
00977
00978 gnome_res_new_user_druid_construct_page (self);
00979
00980 if (self->page){
00981 ++self->pagescreated;
00982 DEBUG_VERBOSE ("NEXT: adding page\n");
00983 gnome_druid_insert_page (GNOME_DRUID (self->druid),
00984 GNOME_DRUID_PAGE (BackPage),
00985 GNOME_DRUID_PAGE (self->page));
00986
00987 gtk_object_set_data (GTK_OBJECT (self->page), "self", (gpointer) self);
00988 gtk_object_set_data (GTK_OBJECT (self->page), "before_self", (gpointer) BackPage);
00989 gtk_object_set_data (GTK_OBJECT (self->page), "behind_self", (gpointer) self->finishpage);
00990 gtk_object_set_data (GTK_OBJECT (BackPage), "behind_self", (gpointer) self->page);
00991
00992 gtk_signal_connect (GTK_OBJECT (self->page), "cancel",
00993 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_cancel),
00994 (gpointer) self);
00995 gtk_signal_connect (GTK_OBJECT (self->page), "next",
00996 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_next),
00997 (gpointer) self);
00998 gtk_signal_connect (GTK_OBJECT (self->page), "back",
00999 GTK_SIGNAL_FUNC (gnome_res_new_user_druid_back),
01000 (gpointer) self);
01001 gtk_widget_show_all (GTK_WIDGET (self->page));
01002
01003 DEBUG_VERBOSE ("NEXT: setting new page\n");
01004 gnome_druid_set_page (GNOME_DRUID (self->druid), GNOME_DRUID_PAGE (self->page));
01005 }else{
01006 DEBUG_VERBOSE ("NEXT: no more pages, going to finishpage\n");
01007 --self->pageindex;
01008 self->page = BackPage;
01009 gnome_druid_set_page (GNOME_DRUID (self->druid), GNOME_DRUID_PAGE (self->finishpage));
01010 }
01011 }else{
01012 DEBUG_VERBOSE ("NEXT: pages already created, going to this page\n");
01013 self->page = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (self->page), "behind_self");
01014 gnome_druid_set_page (GNOME_DRUID (self->druid), GNOME_DRUID_PAGE (self->page));
01015 }
01016 DEBUG_VERBOSE ("NEXTn: %d (%d)\n", self->pageindex, self->pagescreated);
01017 }
01018
01019 static void gnome_res_new_user_druid_back (GtkWidget *w, gpointer druid, gpointer gp_self) {
01020 GnomeResNewUserDruid *self = (GnomeResNewUserDruid *) gp_self;
01021 DEBUG_VERBOSE ("BACKv: %d (%d)\n", self->pageindex--, self->pagescreated);
01022 self->page = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (self->page), "before_self");
01023 gnome_druid_set_page (GNOME_DRUID (self->druid), GNOME_DRUID_PAGE (self->page));
01024 DEBUG_VERBOSE ("BACKn: %d (%d)\n", self->pageindex, self->pagescreated);
01025 }
01026
01027 static void gnome_res_new_user_druid_finished (GtkWidget *w, gpointer druid, gpointer gp_self) {
01028 GnomeResNewUserDruid *self = (GnomeResNewUserDruid *) gp_self;
01029 DEBUG_VERBOSE ("gnome_res_new_user_druid_finished\n");
01030 self->finishmode = GNOME_RES_DRUID_FINISH;
01031 gnome_res_write_user_config (self->res_pref);
01032 gnome_res_new_user_druid_destroy_druidpages (self);
01033 gtk_main_quit ();
01034 }
01035
01036 void gnome_res_new_user_druid_cancel (GtkWidget *w, gpointer druid, gpointer gp_self) {
01037 GnomeResNewUserDruid *self = (GnomeResNewUserDruid *) gp_self;
01038 DEBUG_VERBOSE ("gnome_res_new_user_druid_cancel\n");
01039
01040 self->finishmode = GNOME_RES_DRUID_CANCEL;
01041 gnome_res_new_user_druid_destroy_druidpages (self);
01042 gtk_main_quit ();
01043
01044 }
01045
01046
01047 #ifdef __cplusplus
01048 }
01049 #endif
