1 #ifdef COPYRIGHT_INFORMATION
2 #include "gplv3.h"
3 #endif
4 /*
5 * Copyright (c) 2006-2012 Edscott Wilson Garcia <edscott@users.sf.net>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library;
19 */
20 #include "primary-options.h"
21 #include "xmltree.h"
22
23
24 #define LS_OPTIONS get_ls_options()
25 #define CP_OPTIONS get_cp_options()
26 #define MV_OPTIONS get_mv_options()
27 #define LN_OPTIONS get_ln_options()
28 #define RM_OPTIONS get_rm_options()
29 #define SHRED_OPTIONS get_shred_options()
30 /*
31 #define LS_OPTIONS rfm_void(RFM_MODULE_DIR, "callbacks","get_ls_options")
32 #define CP_OPTIONS rfm_void(RFM_MODULE_DIR, "callbacks","get_cp_options")
33 #define MV_OPTIONS rfm_void(RFM_MODULE_DIR, "callbacks","get_mv_options")
34 #define LN_OPTIONS rfm_void(RFM_MODULE_DIR, "callbacks","get_ln_options")
35 #define RM_OPTIONS rfm_void(RFM_MODULE_DIR, "callbacks","get_rm_options")
36 #define SHRED_OPTIONS rfm_void(RFM_MODULE_DIR, "callbacks","get_shred_options")
37 */
38
rfm_check_button_new()39 static GtkWidget *rfm_check_button_new(){
40 return gtk_check_button_new ();
41 }
42 static void
rfm_check_button_set_active(GtkWidget * button,gboolean state)43 rfm_check_button_set_active(GtkWidget *button, gboolean state){
44 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), state);
45 }
46 static void
scroll_to_top(void * user_data)47 scroll_to_top(void *user_data){
48 rfm_threadwait(); //sleep(1);
49 widgets_t *widgets_p = user_data;
50 rfm_context_function(rfm_scroll_to_top, widgets_p);
51 }
52
53
54 void *
55 mcs_set_var (const gchar * setting_name, const gchar * setting_value);
56
57 #define SETTINGS_TIMERVAL 750
58
59 static void
clear_bgimage(GtkButton * button,gpointer data)60 clear_bgimage (GtkButton * button, gpointer data) {
61 settings_t *settings_p=data;
62 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(settings_p->desktopimage_button), "gtk gives a warning if we use NULL here (that is not good) so we just use this text to set to NULL");
63 }
64
65 void
margin_changed(GtkSpinButton * spinbutton,gpointer data)66 margin_changed (GtkSpinButton *spinbutton, gpointer data) {
67 settings_t *settings_p=g_object_get_data(G_OBJECT(spinbutton), "settings_p");
68 if(!settings_p || settings_p->disable_options){
69 return;
70 }
71 gint which_margin = GPOINTER_TO_INT(data);
72
73
74 if(rfm_options[which_margin].value)
75 g_free (rfm_options[which_margin].value);
76
77 gdouble value=gtk_spin_button_get_value (spinbutton);
78 NOOP ("margin:changed(): %4.0lf\n", value);
79 rfm_options[which_margin].value = g_strdup_printf ("%lf", value);
80 mcs_manager_set_string (mcs_manager, rfm_options[which_margin].name,
81 CHANNEL, rfm_options[which_margin].value);
82 mcs_manager_notify (mcs_manager, CHANNEL);
83
84 return;
85
86 }
87
88 void
preview_size_changed(GtkSpinButton * spinbutton,gpointer data)89 preview_size_changed (GtkSpinButton *spinbutton, gpointer data) {
90 settings_t *settings_p=g_object_get_data(G_OBJECT(spinbutton), "settings_p");
91 if(!settings_p || settings_p->disable_options){
92 return;
93 }
94
95 if(rfm_options[RFM_PREVIEW_IMAGE_SIZE].value)
96 g_free (rfm_options[RFM_PREVIEW_IMAGE_SIZE].value);
97
98 gdouble value=gtk_spin_button_get_value (spinbutton);
99 NOOP ("RFM_PREVIEW_IMAGE_SIZE:changed(): %4.0lf\n", value);
100 gint iv = value;
101 rfm_options[RFM_PREVIEW_IMAGE_SIZE].value = g_strdup_printf ("%d", iv);
102 mcs_manager_set_string (mcs_manager, rfm_options[RFM_PREVIEW_IMAGE_SIZE].name,
103 CHANNEL, rfm_options[RFM_PREVIEW_IMAGE_SIZE].value);
104 mcs_manager_notify (mcs_manager, CHANNEL);
105
106 return;
107
108 }
109
110 static gboolean
transparency_changed(GtkRange * range,GtkScrollType scroll,gdouble value,gpointer user_data)111 transparency_changed (GtkRange * range,
112 GtkScrollType scroll,
113 gdouble value,
114 gpointer user_data)
115 {
116 settings_t *settings_p=g_object_get_data(G_OBJECT(range), "settings_p");
117 if(settings_p->disable_options)
118 return FALSE;
119 int i = (int)((long)user_data);
120 if(rfm_options[i].value)
121 g_free (rfm_options[i].value);
122 rfm_options[i].value = g_strdup_printf ("%lf", value);
123 mcs_manager_set_string (mcs_manager, rfm_options[i].name,
124 CHANNEL, rfm_options[i].value);
125 mcs_manager_notify (mcs_manager, CHANNEL);
126
127 return FALSE;
128 }
129
130 static gint
settings_monitor(gpointer data)131 settings_monitor (gpointer data) {
132 NOOP("g_timeout: settings-module.i settings_monitor()\n");
133 mcs_shm_t *mcs_shm_p = (mcs_shm_t *) mp->m;
134 if(shm_settings_serial < 0)
135 return FALSE;
136 if(shm_settings_serial != mcs_shm_p->serial) {
137 NOOP(stderr, "+++ settings_monitor: refreshing environment...\n");
138 int i;
139 for(i = 0; i < RFM_OPTIONS; i++) {
140 // false positive. We are not comparing the array, we are comparing
141 // the preset value within the array of structures, which may or may
142 // not be null.
143 // coverity[array_null : FALSE]
144 if(mcs_shm_p->data[i].value) {
145 g_free (rfm_options[i].value);
146 rfm_options[i].value = g_strdup (mcs_shm_p->data[i].value);
147 rfm_setenv (rfm_options[i].name, rfm_options[i].value, TRUE);
148 } else {
149 rfm_setenv (rfm_options[i].name, NULL, TRUE);
150 }
151 if (strlen(rfm_options[i].value)){
152 NOOP ("settings_monitor(): serial %d (was %d) %s->%s\n",
153 mcs_shm_p->serial, shm_settings_serial,
154 rfm_options[i].name, rfm_options[i].value);
155 }
156
157 }
158 shm_settings_serial = mcs_shm_p->serial;
159 } else {
160 COMMENT("shm_settings_serial OK\n");
161 }
162 return TRUE;
163 }
164
165 static int
mcs_shm_fileread(void)166 mcs_shm_fileread (void) {
167 static gchar *rcfile = NULL;
168
169 if(!rcfile) {
170 rcfile = g_build_filename (MCS_SHM_PLUGIN_FILE, NULL);
171 }
172
173 if(rfm_g_file_test (rcfile, G_FILE_TEST_EXISTS)) {
174 FILE *f;
175 NOOP("mcs_shm_fileread(): %s\n", rcfile);
176 f = fopen (rcfile, "r");
177 if(f) {
178 size_t items_read = fread (mp->m, sizeof (mcs_shm_t), 1, f);
179 if(items_read == 1){
180 msync (mp->m, sizeof (mcs_shm_t), MS_SYNC);
181 } else {
182 DBG ("mcs_shm_fileread() fread: %s\n", strerror (errno));
183 }
184 fclose (f);
185 }
186 return 1;
187 }
188 return 0;
189 }
190
191 static int
mcs_shm_filewrite(void)192 mcs_shm_filewrite (void) {
193 FILE *f;
194 static gchar *rcfile = NULL;
195
196 if(!rcfile) {
197 rcfile = g_build_filename (MCS_SHM_PLUGIN_FILE, NULL);
198 }
199 NOOP ("mcs_shm_filewrite(): %s\n", rcfile);
200 msync (mp->m, sizeof (mcs_shm_t), MS_SYNC);
201 f = fopen (rcfile, "w");
202 if(f) {
203 mcs_shm_t *mcs_shm_p = (mcs_shm_t *) mp->m;
204 mcs_shm_p->serial++;
205 if(fwrite (mp->m, sizeof (mcs_shm_t), 1, f) < 1)
206 DBG ("fwrite: %s\n", strerror (errno));
207 fclose (f);
208 return 1;
209 }
210 msync (mp->m, sizeof (mcs_shm_t), MS_SYNC);
211 return 0;
212 }
213
214 static void
mcs_shm_bringforth(void)215 mcs_shm_bringforth (void) {
216 int i,
217 j;
218 mcs_shm_t *mcs_shm_p = (mcs_shm_t *) mp->m;
219 COMMENT ("mcs_shm_bringforth\n");
220 for(i = 0; i < RFM_OPTIONS; i++) {
221 g_free (rfm_options[i].value);
222 rfm_options[i].value = g_strdup ("");
223 }
224 for(i = 0; i < RFM_OPTIONS; i++){
225 for(j = 0; j < RFM_OPTIONS; j++) {
226 // false positive. We are not comparing the array, we are comparing
227 // the preset value within the array of structures, which may or may
228 // not be null.
229 // coverity[array_null : FALSE]
230 if(rfm_options[i].name && mcs_shm_p->data[j].name) {
231 if(strcmp (rfm_options[i].name, mcs_shm_p->data[j].name))
232 continue;
233 g_free (rfm_options[i].value);
234 rfm_options[i].value = g_strdup (mcs_shm_p->data[j].value);
235 if (strlen(rfm_options[i].value)) {
236 NOOP ("mcs_shm_bringforth: %s->%s\n",
237 rfm_options[i].name, rfm_options[i].value);
238 }
239 break;
240 }
241 }
242 }
243 }
244
245 static void
mcs_shm_init(void)246 mcs_shm_init (void) {
247 int i;
248 mcs_shm_t *mcs_shm_p = (mcs_shm_t *) mp->m;
249 COMMENT ("mcs_shm_init\n");
250 for(i = 0; i < RFM_OPTIONS; i++) {
251 memset (mcs_shm_p->data[i].name, 0, SHM_STRING_LENGTH);
252 memset (mcs_shm_p->data[i].value, 0, SHM_VALUE_LENGTH);
253 strncpy (mcs_shm_p->data[i].name, rfm_options[i].name, SHM_STRING_LENGTH-1);
254 if(rfm_options[i].value) {
255 strncpy (mcs_shm_p->data[i].value, rfm_options[i].value, SHM_VALUE_LENGTH-1);
256 mcs_shm_p->data[i].value[SHM_VALUE_LENGTH - 1] = 0;
257 }
258 COMMENT ("*SETTINGS: initialising %s->%s\n",
259 rfm_options[i].name, rfm_options[i].value);
260 }
261 msync (mp->m, sizeof (mcs_shm_t), MS_SYNC);
262 }
263
264 static void
start_desktop(gboolean on)265 start_desktop (gboolean on) {
266 // Automatic on/off is only applicable for local displays.
267 if (!localhost_check()) {
268 return;
269 }
270
271 Window xid;
272 GError *error = NULL;
273 if(on) {
274 rfm_global_t *rfm_global_p = rfm_global();
275 Atom selection_atom = XInternAtom (rfm_global_p->Xdisplay, "RODENT_DESK_ATOM", False);
276 if((xid = XGetSelectionOwner (rfm_global_p->Xdisplay, selection_atom))) {
277 NOOP ("start_desktop(): rodent-desk already running\n");
278 } else if(!g_spawn_command_line_async ("rodent-desk", &error)) {
279 DBG ("start_desktop(): %s\n", error->message);
280 } else {
281 NOOP("start_desktop(): rodent-desk\n");
282 }
283 } else {
284 if(!g_spawn_command_line_async ("killall -TERM rodent-desk", &error)) {
285 DBG ("%s\n", error->message);
286 g_error_free (error);
287 }
288 }
289
290 }
291
292 static void
mcs_manager_set_string(McsManager * mcs_m,const gchar * setting_name,const gchar * channel,const gchar * setting_value)293 mcs_manager_set_string (McsManager * mcs_m,
294 const gchar * setting_name,
295 const gchar * channel,
296 const gchar * setting_value)
297 {
298 mcs_shm_t *mcs_shm_p = (mcs_shm_t *) mp->m;
299 int i;
300 COMMENT ("mcs_manager_set_string\n");
301
302 for(i = 0; i < RFM_OPTIONS; i++) {
303 COMMENT ("%d/%d %s==%s?\n",
304 i+1, RFM_OPTIONS, setting_name, mcs_shm_p->data[i].name);
305 if(strcmp (setting_name, mcs_shm_p->data[i].name) == 0) {
306 memset (mcs_shm_p->data[i].value, 0, SHM_VALUE_LENGTH);
307 if(setting_value) {
308 if(strlen (setting_value) > 0) {
309 NOOP (stderr, "mcs_manager_set_string(): %s -> %s (%zd)\n",
310 setting_name, setting_value, strlen (setting_value));
311 }
312 if(i == RFM_ENABLE_DESKTOP) {
313 if(strlen (setting_value) > 0) {
314 NOOP (stderr, "mcs_manager_set_string(): Start desktop (%ld)\n",
315 (long)strlen (setting_value));
316 start_desktop (TRUE);
317 } else {
318 NOOP (stderr, "mcs_manager_set_string(): Kill desktop (%ld)\n",
319 (long)strlen (setting_value));
320 start_desktop (FALSE);
321 }
322 }
323 #ifdef HAVE_SETENV
324 setenv ( mcs_shm_p->data[i].name, setting_value, 1);
325 #endif
326 strncpy (mcs_shm_p->data[i].value, setting_value, SHM_VALUE_LENGTH);
327 mcs_shm_p->data[i].value[SHM_VALUE_LENGTH - 1] = 0;
328 gchar *oldvalue = rfm_options[i].value;
329 rfm_options[i].value = g_strdup (setting_value);
330 g_free (oldvalue);
331 }
332 }
333 }
334 msync (mp->m, sizeof (mcs_shm_t), MS_SYNC);
335 /* here we update the shmblock */
336 return;
337 }
338
339 static void
mcs_manager_notify(McsManager * mcs_m,const gchar * channel)340 mcs_manager_notify (McsManager * mcs_m, const gchar * channel) {
341 /* here we ++ the shmblock serial (or something), this should be
342 * monitored by other instances so that changes are ACK.*/
343 COMMENT ("mcs_manager_notify\n");
344 mcs_shm_t *mcs_shm_p = (mcs_shm_t *) mp->m;
345 mcs_shm_p->serial++;
346 msync (mp->m, sizeof (mcs_shm_t), MS_SYNC);
347 mcs_shm_filewrite ();
348 return;
349 }
350
351 /* the dialog ******************************************/
352 /*static void
353 add_spacer (GtkBox * box) {
354
355 GtkWidget *eventbox = gtk_alignment_new (0, 0, 0, 0);
356
357 gtk_widget_set_size_request (eventbox, SKIP, SKIP);
358 gtk_widget_show (eventbox);
359 gtk_box_pack_start (box, eventbox, FALSE, TRUE, 0);
360 }*/
361
362 static void update_tree (GtkTreeModel *model, gint id);
363
364 static gboolean
test_command(const gchar * command)365 test_command(const gchar *command){
366 if (!command) return FALSE;
367 gchar *c=g_strdup(command);
368 if (strchr(c, ' ')) *strchr(c, ' ') = 0;
369 gchar *cmd = g_find_program_in_path (c);
370 g_free(c);
371 if (!cmd) return FALSE;
372 g_free(cmd);
373 return TRUE;
374 }
375
376
get_program_options(gint i)377 static gchar **get_program_options(gint i){
378 if (i >= RFM_OPTIONS) return NULL;
379 environ_t *environ_v = rfm_get_environ();
380 return environ_v[i].env_options;
381 }
382
383 static gboolean
environment_changed(GtkCellRendererText * cell,const gchar * path_string,const gchar * new_text,gpointer data)384 environment_changed (GtkCellRendererText * cell,
385 const gchar * path_string,
386 const gchar * new_text,
387 gpointer data) {
388 settings_t *settings_p=data;
389 if(settings_p->disable_options)
390 return FALSE;
391
392 GtkTreeModel *model = GTK_TREE_MODEL(settings_p->model);
393 GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
394 GtkTreeIter iter;
395
396 gint *column;
397
398 column = g_object_get_data (G_OBJECT (cell), "column");
399
400 gtk_tree_model_get_iter (model, &iter, path);
401
402 if(GPOINTER_TO_INT (column) == COLUMN_VALUE) {
403 COMMENT ("column=%d path=%s newtext=%s",
404 GPOINTER_TO_INT (column), path_string, new_text);
405
406 gint i;
407 gchar *old_text;
408
409 gtk_tree_model_get (model, &iter, column, &old_text, -1);
410 g_free (old_text);
411 old_text = NULL;
412 i = gtk_tree_path_get_indices (path)[0];
413
414 if(new_text && strlen (new_text) >= SHM_VALUE_LENGTH) {
415 DBG ("strlen($%s) < %d not met. Ignoring it.\n", rfm_options[i].name, SHM_VALUE_LENGTH);
416 gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, rfm_options[i].value, -1);
417 return FALSE;
418 }
419 // bitflag tests
420 gchar **aa=get_program_options(i);
421
422 if (aa) {
423 gboolean notfound = TRUE;
424 for(; aa && *aa; aa++){
425 if (new_text && strcmp(*aa, new_text)==0){
426 notfound = FALSE;
427 break;
428 }
429 }
430 if (notfound){
431 gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, rfm_options[i].value, -1);
432 return FALSE;
433 }
434 }
435
436 /* test for valid commands */
437 if(i == TERMINAL_CMD || i == EDITOR) {
438 gboolean dump = FALSE;
439 if(!new_text || !test_command(new_text)){
440 dump = TRUE;
441 }
442 if(dump) {
443
444 gchar *g=g_strdup_printf("%s: Command not found", (new_text)?new_text:"");
445 rfm_show_text(settings_p->widgets_p);
446 rfm_diagnostics(settings_p->widgets_p, "xffm/stock_dialog-error", NULL);
447 rfm_diagnostics(settings_p->widgets_p, "xffm_tag/stderr", g, "\n", NULL);
448 g_free(g);
449 gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, rfm_options[i].value, -1);
450 return FALSE;
451 }
452 }
453 /* test for valid iconsizes */
454 if(i == RFM_DEFAULT_ICON_SIZE) {
455 // New values entered in advanced mode: should they be
456 // input in translated or nontranslated form?
457 // Non translated, of course.
458 gboolean dump = TRUE;
459 if(new_text) {
460 const gchar **p=rfm_get_icon_sizes();
461 for (;p && *p; p++){
462 if (strcmp(*p, new_text) == 0){
463 dump = FALSE;
464 break;
465 }
466 }
467 }
468 if(dump) {
469 gtk_list_store_set (GTK_LIST_STORE (model),
470 &iter, column, rfm_options[i].value, -1);
471 return FALSE;
472 }
473 }
474 if(i == RFM_FIXED_FONT_SIZE
475 || i == RFM_VARIABLE_FONT_SIZE
476 || i == RFM_FIXED_FONT_FAMILY
477 || i == RFM_VARIABLE_FONT_FAMILY
478 ) {
479 // New values entered in advanced mode: should they be
480 // input in translated or nontranslated form?
481 // Non translated, of course.
482 gboolean dump = TRUE;
483 if(new_text) {
484 const gchar **p=rfm_get_font_sizes();
485 for (;p && *p; p++){
486 if (strcmp(*p, new_text) == 0){
487 dump = FALSE;
488 break;
489 }
490 }
491 }
492 if(dump) {
493 gtk_list_store_set (GTK_LIST_STORE (model),
494 &iter, column, rfm_options[i].value, -1);
495 return FALSE;
496 }
497 }
498
499 if(rfm_options[i].value) {
500 g_free (rfm_options[i].value);
501 rfm_options[i].value = NULL;
502 }
503 if(new_text && strlen (new_text)) {
504 rfm_options[i].value = g_strdup (new_text);
505 } else {
506 rfm_options[i].value = g_strdup ("");
507 }
508 COMMENT ("environment_changed: %s->%s\n",
509 rfm_options[i].name, rfm_options[i].value);
510 gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, rfm_options[i].value, -1);
511 mcs_manager_set_string (mcs_manager, rfm_options[i].name, CHANNEL, rfm_options[i].value);
512 mcs_manager_notify (mcs_manager, CHANNEL);
513 /*write_options(); */
514 }
515 gtk_tree_path_free (path);
516
517 return FALSE;
518 }
519 static gboolean animation_stop=FALSE;
520 /* the dialog */
521 static void
dialog_delete(GtkWidget * dialog,gpointer data)522 dialog_delete (GtkWidget * dialog, gpointer data) {
523 GError *error = NULL;
524 if(GPOINTER_TO_INT(data) == 1) {
525 if (rfm_void(RFM_MODULE_DIR, "icons", "module_active") ){
526 g_spawn_command_line_async ("rodent-iconmgr", &error);
527 } else {
528 gchar *text = g_strdup_printf("<b>%s</b>\n\n%s: <i>%s</i>\n",
529 _("List of disabled plugins"), _("Icon Themes"), _("Disabled"));
530 rfm_confirm(NULL, GTK_MESSAGE_INFO, text, NULL, NULL);
531 g_free(text);
532 return;
533 }
534 } else if(GPOINTER_TO_INT(data) == 2) {
535 /* thumbnail cache */
536 gchar *cache_dir = g_build_filename (RFM_THUMBNAIL_DIR, NULL);
537 NOOP ("dialog_delete(): clearing thumbnail cache: %s", cache_dir);
538 gchar *command = g_strdup_printf ("rm -rf \"%s\"", cache_dir);
539 g_spawn_command_line_async (command, &error);
540 g_free (cache_dir);
541 g_free (command);
542 }
543
544 // writeout current config, to disable welcome dialog.
545 mcs_shm_filewrite();
546
547
548 widgets_t *widgets_p=g_object_get_data(G_OBJECT(dialog), "widgets_p");
549 if (widgets_p) {
550 g_free(widgets_p);
551 }
552 g_object_set_data(G_OBJECT(dialog), "widgets_p", NULL);
553 gtk_widget_hide(dialog);
554 animation_stop = TRUE;
555 settings_t *settings_p=g_object_get_data(G_OBJECT(dialog), "settings_p");
556 g_free(settings_p);
557 g_object_set_data(G_OBJECT(dialog), "settings_p", NULL);
558 settings_dialog=NULL;
559 gtk_widget_destroy (dialog);
560 //
561 //rfm_unload_module("xmltree");
562
563 }
564
565 static void
update_bitflag_entry(settings_t * settings_p,gint id)566 update_bitflag_entry (settings_t *settings_p, gint id) {
567 GtkEntry *entry =
568 g_object_get_data(G_OBJECT(settings_p->dialog), rfm_options[id].name);
569 gchar *new_text = rfm_options[id].value;
570 if (GTK_IS_ENTRY(entry)) gtk_entry_set_text(GTK_ENTRY(entry), new_text?new_text:"");
571 }
572
573 static void
update_bitflag_combo(settings_t * settings_p,gint id)574 update_bitflag_combo (settings_t *settings_p, gint id) {
575 gchar **aa=get_program_options(id);
576 gint item=0;
577 if (aa) {
578 gchar *new_text = rfm_options[id].value;
579 gboolean notfound = TRUE;
580 for(; aa && *aa; aa++,item++){
581 if (strcmp(*aa, new_text)==0){
582 notfound = FALSE;
583 break;
584 }
585 }
586 if (notfound) {
587 NOOP("aa not found %s\n", new_text);
588 return ;
589 }
590 GtkComboBox *combo_box =
591 g_object_get_data(G_OBJECT(settings_p->dialog), rfm_options[id].name);
592
593 NOOP(stderr, "update_bitflag_combo() %s box=0x%x\n", rfm_options[id].name, GPOINTER_TO_INT(combo_box));
594 if (GTK_IS_COMBO_BOX(combo_box)) gtk_combo_box_set_active (combo_box, item);
595
596 } else {
597 NOOP("update_bitflag_combo(): get_program_options(%s) is NULL\n", rfm_options[id].name);
598 }
599
600 }
601
602 static void
update_combo(GtkComboBox * combo_box,gint id,gboolean translated)603 update_combo (GtkComboBox * combo_box, gint id, gboolean translated) {
604 const gchar *string=(translated)?_(rfm_options[id].value):rfm_options[id].value;
605 gint item=0;
606
607 GSList *list=g_object_get_data(G_OBJECT(combo_box), "list");
608 GSList *tmp=list;
609 for (;tmp && tmp->data; tmp=tmp->next, item++){
610 if (strcmp(string, (gchar *)tmp->data)==0) {
611 break;
612 }
613 }
614
615 // Is the string in the combobox list?
616 gboolean in_combobox = (item < g_slist_length(list));
617 // Yes. Then it must be selected.
618 if (in_combobox) {
619 if (GTK_IS_COMBO_BOX(combo_box))gtk_combo_box_set_active (combo_box, item);
620 } else {
621 // No. The string is not in the combobox list, the string must
622 // be inserted and selected.
623 COMMENT("Adding %s\n", string);
624 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
625 gtk_combo_box_insert_text (combo_box, 0, string);
626 #else
627 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(combo_box), 0, string);
628 #endif
629 if (GTK_IS_COMBO_BOX(combo_box))gtk_combo_box_set_active (combo_box, 0);
630 }
631 }
632
633 static void
update_tree(GtkTreeModel * model,gint id)634 update_tree (GtkTreeModel *model, gint id) {
635 GtkTreePath *treepath = gtk_tree_path_new_from_indices (id, -1);
636 GtkTreeIter iter;
637 if(gtk_tree_model_get_iter (model, &iter, treepath)) {
638 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
639 COLUMN_VALUE, g_strdup (rfm_options[id].value),
640 COLUMN_EDITABLE, TRUE, -1);
641 }
642 gtk_tree_path_free (treepath);
643 }
644
get_spin_value(gint i)645 gdouble get_spin_value(gint i){
646 gdouble value=0;
647 environ_t *environ_v = rfm_get_environ();
648 if (getenv(environ_v[i].env_var) && strlen(getenv(environ_v[i].env_var))) {
649 value = atof(getenv(environ_v[i].env_var));
650 COMMENT("got env_var=%s\n", getenv(environ_v[i].env_var));
651 } else if (environ_v[i].env_string) {
652 value = atof(environ_v[i].env_string);
653 COMMENT("got env_string=%s\n", environ_v[i].env_string);
654 }
655 return value;
656 }
657
658 static void
set_bit_toggles(settings_t * settings_p,const gchar * boxname,RfmProgramOptions * options_p,gint option_flag)659 set_bit_toggles( settings_t *settings_p, const gchar *boxname, RfmProgramOptions *options_p, gint option_flag) {
660 GObject *box = g_object_get_data(G_OBJECT(settings_p->dialog), boxname);
661 if (!box || !G_IS_OBJECT (box)) {
662 DBG("Not an object: %s\n", boxname);
663 return;
664 }
665 errno = 0;
666 gint64 flag = strtoll(rfm_options[option_flag].value, NULL, 16);
667 if (errno) flag = 0;
668 gint i;
669 for (i=0;options_p && options_p->option; options_p++, i++){
670 if (strcmp(options_p->option,"submodule-indent")==0) continue;
671 if (strcmp(options_p->option,"submodule-unindent")==0) continue;
672 if (strcmp(options_p->option,"submodule-label")==0) continue;
673
674 const gchar *name = options_p->option;
675 GtkWidget *button = g_object_get_data(box, name);
676 if (button){
677 gint64 k = flag & (ONE64<<i);
678 rfm_check_button_set_active(button, k?TRUE:FALSE);
679 } else {
680 DBG("No toggle button for %s\n", name);
681 }
682 }
683
684 }
685
686 static void
update_combo_entry(settings_t * settings_p)687 update_combo_entry(settings_t *settings_p) {
688 #ifdef GNU_CP
689 update_bitflag_combo (settings_p, RFM_CP_backup);
690 update_bitflag_combo (settings_p, RFM_CP_preserve);
691 update_bitflag_combo (settings_p, RFM_CP_no_preserve);
692 update_bitflag_combo (settings_p, RFM_CP_reflink);
693 update_bitflag_combo (settings_p, RFM_CP_sparse);
694 update_bitflag_combo (settings_p, RFM_CP_suffix);
695 #endif
696 #ifdef GNU_MV
697 update_bitflag_combo (settings_p, RFM_MV_backup);
698 update_bitflag_combo (settings_p, RFM_MV_suffix);
699 #endif
700
701 #ifdef GNU_LN
702 update_bitflag_combo (settings_p, RFM_LN_backup);
703 update_bitflag_combo (settings_p, RFM_LN_suffix);
704 #endif
705
706 #ifdef GNU_RM
707 update_bitflag_combo (settings_p, RFM_RM_interactive);
708 #endif
709
710 #ifdef GNU_LS
711 update_bitflag_entry (settings_p, RFM_LS_ignore);
712 update_bitflag_entry (settings_p, RFM_LS_tabsize);
713 update_bitflag_entry (settings_p, RFM_LS_blocksize);
714 update_bitflag_combo (settings_p, RFM_LS_format);
715 update_bitflag_entry (settings_p, RFM_LS_hide);
716 update_bitflag_combo (settings_p, RFM_LS_istyle);
717 update_bitflag_combo (settings_p, RFM_LS_qstyle);
718 update_bitflag_combo (settings_p, RFM_LS_sort);
719 update_bitflag_combo (settings_p, RFM_LS_time);
720 update_bitflag_combo (settings_p, RFM_LS_tstyle);
721 update_bitflag_entry (settings_p, RFM_LS_width);
722 #endif
723
724 gchar *shred_bin = g_find_program_in_path("shred");
725 if (shred_bin) {
726 update_bitflag_combo (settings_p, RFM_SHRED_iterations);
727 update_bitflag_combo (settings_p, RFM_SHRED_size);
728 g_free(shred_bin);
729 }
730
731 }
732
733 GtkWidget *toggle_button[RFM_OPTIONS];
734 static void
set_option_buttons(settings_t * settings_p)735 set_option_buttons ( settings_t *settings_p) {
736
737 int i;
738 settings_p->disable_options = TRUE;
739
740 set_bit_toggles(settings_p, "ls_box", LS_OPTIONS,RFM_LS_FLAGS);
741 set_bit_toggles(settings_p, "cp_box", CP_OPTIONS, RFM_CP_FLAGS);
742 set_bit_toggles(settings_p, "mv_box", MV_OPTIONS, RFM_MV_FLAGS);
743 set_bit_toggles(settings_p, "ln_box", LN_OPTIONS, RFM_LN_FLAGS);
744 set_bit_toggles(settings_p, "rm_box", RM_OPTIONS, RFM_RM_FLAGS);
745 gchar *shred_bin = g_find_program_in_path("shred");
746 if (shred_bin) {
747 set_bit_toggles(settings_p, "shred_box", SHRED_OPTIONS, RFM_SHRED_FLAGS);
748 g_free(shred_bin);
749 }
750
751 set_bit_toggles(settings_p, "plugins_box", rfm_get_lite_plugin_options(), RFM_PLUGIN_FLAGS);
752 set_bit_toggles(settings_p, "modules_box", rfm_get_lite_module_options(), RFM_MODULE_FLAGS);
753
754 update_combo_entry(settings_p);
755
756 // spin buttons:
757 for (i = RFM_DESKTOP_TOP_MARGIN; i <= RFM_DESKTOP_LEFT_MARGIN; i++){
758 gdouble value = get_spin_value(i);
759 gtk_spin_button_set_value (
760 GTK_SPIN_BUTTON(settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN]),
761 value);
762 update_tree (GTK_TREE_MODEL(settings_p->model), i);
763 }
764 {
765 gdouble value = rfm_get_preview_image_size();
766 gtk_spin_button_set_value (
767 GTK_SPIN_BUTTON(settings_p->preview_size_spinbutton),
768 value);
769 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_PREVIEW_IMAGE_SIZE);
770 }
771 for(i = 0; i < RFM_OPTIONS; i++)
772 if(toggle_button[i]) {
773 if(rfm_options[i].value && strlen (rfm_options[i].value)) {
774 gtk_toggle_button_set_active ((GtkToggleButton *)
775 toggle_button[i], TRUE);
776 } else {
777 gtk_toggle_button_set_active ((GtkToggleButton *)
778 toggle_button[i], FALSE);
779 }
780 GtkTreePath *treepath = gtk_tree_path_new_from_indices (i, -1);
781 GtkTreeIter iter;
782 if(gtk_tree_model_get_iter (
783 GTK_TREE_MODEL(settings_p->model), &iter, treepath))
784 {
785 gtk_list_store_set (settings_p->model, &iter,
786 COLUMN_VALUE, g_strdup (rfm_options[i].value),
787 COLUMN_EDITABLE, TRUE, -1);
788 }
789 gtk_tree_path_free (treepath);
790 }
791 update_combo (GTK_COMBO_BOX(settings_p->fontsize_box), RFM_FIXED_FONT_SIZE, TRUE);
792 update_combo (GTK_COMBO_BOX(settings_p->vfontsize_box), RFM_VARIABLE_FONT_SIZE, TRUE);
793 update_combo (GTK_COMBO_BOX(settings_p->fontfamily_box), RFM_FIXED_FONT_FAMILY, TRUE);
794 update_combo (GTK_COMBO_BOX(settings_p->vfontfamily_box), RFM_VARIABLE_FONT_FAMILY, TRUE);
795 update_combo (GTK_COMBO_BOX(settings_p->iconsize_box), RFM_DEFAULT_ICON_SIZE, TRUE);
796 update_combo (GTK_COMBO_BOX(settings_p->terminal_box), TERMINAL_CMD, FALSE);
797 update_combo (GTK_COMBO_BOX(settings_p->editor_box), EDITOR, FALSE);
798 if(getenv ("RFM_DESKTOP_DIR") && strlen (getenv ("RFM_DESKTOP_DIR"))) {
799 COMMENT("set_option_buttons: setting %s\n",getenv ("RFM_DESKTOP_DIR"));
800 gtk_entry_set_text (GTK_ENTRY (settings_p->desktopdir_entry),
801 getenv ("RFM_DESKTOP_DIR"));
802 }
803 if(getenv ("RFM_DESKTOP_IMAGE") && strlen (getenv ("RFM_DESKTOP_IMAGE"))) {
804 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (settings_p->desktopimage_button),
805 getenv ("RFM_DESKTOP_IMAGE"));
806 }
807 if(getenv ("RFM_DESKTOP_COLOR") && strlen (getenv ("RFM_DESKTOP_COLOR"))) {
808 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=4
809 GdkRGBA color;
810 if(gdk_rgba_parse (&color, getenv ("RFM_DESKTOP_COLOR") )) {
811 gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(settings_p->desktopcolor_button), &color);
812 }
813
814 #else
815 GdkColor color;
816 if(gdk_color_parse (getenv ("RFM_DESKTOP_COLOR"), &color)) {
817 gtk_color_button_set_color (
818 GTK_COLOR_BUTTON(settings_p->desktopcolor_button), &color);
819 }
820 #endif
821 }
822 if(getenv ("RFM_ICONVIEW_COLOR") && strlen (getenv ("RFM_ICONVIEW_COLOR")))
823 {
824 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=4
825 GdkRGBA color;
826 if(gdk_rgba_parse (&color, getenv ("RFM_ICONVIEW_COLOR") )) {
827 gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(settings_p->iconviewcolor_button), &color);
828 }
829
830 #else
831 GdkColor color;
832 if(gdk_color_parse (getenv ("RFM_ICONVIEW_COLOR"), &color)) {
833 gtk_color_button_set_color (
834 GTK_COLOR_BUTTON(settings_p->desktopcolor_button), &color);
835 }
836 #endif
837 }
838 update_tree (GTK_TREE_MODEL(settings_p->model), VERSION_CONTROL);
839
840 #ifdef GNU_CP
841
842 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_FLAGS);
843 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_FLAGS);
844 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_MV_FLAGS);
845 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LN_FLAGS);
846 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_RM_FLAGS);
847 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_SHRED_FLAGS);
848 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_PLUGIN_FLAGS);
849 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_MODULE_FLAGS);
850
851 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_backup);
852 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_preserve);
853 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_no_preserve);
854 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_reflink);
855 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_sparse);
856 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_CP_suffix);
857 #endif
858
859 #ifdef GNU_MV
860 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_MV_backup);
861 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_MV_suffix);
862 #endif
863
864 #ifdef GNU_LN
865 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LN_backup);
866 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LN_suffix);
867 #endif
868
869 #ifdef GNU_RM
870 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_RM_interactive);
871 #endif
872
873 #ifdef GNU_LS
874 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_ignore);
875 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_tabsize);
876 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_blocksize);
877 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_format);
878 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_hide);
879 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_istyle);
880 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_qstyle);
881 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_sort);
882 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_time);
883 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_tstyle);
884 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_LS_width);
885 #endif
886
887 shred_bin = g_find_program_in_path("shred");
888 if (shred_bin) {
889 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_SHRED_iterations);
890 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_SHRED_size);
891 g_free(shred_bin);
892 }
893
894
895
896 update_tree (GTK_TREE_MODEL(settings_p->model),RFM_FIXED_FONT_SIZE );
897 update_tree (GTK_TREE_MODEL(settings_p->model),RFM_VARIABLE_FONT_SIZE );
898 update_tree (GTK_TREE_MODEL(settings_p->model),RFM_FIXED_FONT_FAMILY );
899 update_tree (GTK_TREE_MODEL(settings_p->model),RFM_VARIABLE_FONT_FAMILY );
900 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_DEFAULT_ICON_SIZE);
901 update_tree (GTK_TREE_MODEL(settings_p->model), TERMINAL_CMD);
902 update_tree (GTK_TREE_MODEL(settings_p->model), EDITOR);
903 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_DESKTOP_DIR);
904 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_DESKTOP_IMAGE);
905 update_tree (GTK_TREE_MODEL(settings_p->model), RFM_DESKTOP_COLOR);
906
907
908
909 settings_p->disable_options = FALSE;
910
911 }
912
913
914
915 static void
option_toggled(GtkToggleButton * togglebutton,gpointer user_data)916 option_toggled (GtkToggleButton * togglebutton, gpointer user_data) {
917 NOOP(stderr, "at option_toggled...\n");
918 settings_t *settings_p=g_object_get_data(G_OBJECT(togglebutton), "settings_p");
919 if(settings_p->disable_options) return;
920 gint i = GPOINTER_TO_INT(user_data);
921 NOOP(stderr, "at option_toggled...%d\n", i);
922
923 if(rfm_options[i].value) {
924 g_free (rfm_options[i].value);
925 }
926
927 if (i==RFM_USE_GTK_ICON_THEME) {
928 GtkSettings *settings = gtk_settings_get_default();
929 g_object_get( G_OBJECT(settings),
930 "gtk-icon-theme-name", &(rfm_options[i].value),
931 NULL);
932 rfm_show_text(settings_p->widgets_p);
933 rfm_diagnostics(settings_p->widgets_p, "xffm/stock_dialog-info", NULL);
934 rfm_diagnostics(settings_p->widgets_p, "xffm_tag/stderr", _("Please restart application for full changes to take effect"), ".\n ", NULL);
935 }
936
937 if(gtk_toggle_button_get_active (togglebutton)) {
938 if (i==RFM_USE_GTK_ICON_THEME) {
939 GtkSettings *settings = gtk_settings_get_default();
940 g_object_get( G_OBJECT(settings),
941 "gtk-icon-theme-name", &(rfm_options[i].value),
942 NULL);
943 rfm_diagnostics(settings_p->widgets_p, "xffm/stock_dialog-info", NULL);
944 rfm_diagnostics(settings_p->widgets_p, "xffm_tag/stderr", _("Please restart application for full changes to take effect"), ".\n ", NULL);
945 #if 0
946 // First we zap the thumbnail directory
947 // (composite icons are thumbnailed cached)
948 gchar *thumbnails = g_build_path(RFM_THUMBNAIL_DIR,NULL);
949 pid_t pid = fork();
950 if (!pid){
951 gchar *argv[]={"rm", "-rf", thumbnails, NULL};
952 execvp(argv[0], argv);
953 _exit(123);
954 }
955 gint status;
956 waitpid(pid, &status, 0);
957 #endif
958 // This guy should regenerate the cache...
959 // But is already done in rodent-fm
960 // rfm_void(RFM_MODULE_DIR,"icons", "create_cache");
961 }
962 else {
963 rfm_options[i].value = g_strdup ("yes");
964 }
965 } else {
966 rfm_options[i].value = g_strdup ("");
967 }
968 mcs_manager_set_string (mcs_manager, rfm_options[i].name,
969 CHANNEL, rfm_options[i].value);
970 mcs_manager_notify (mcs_manager, CHANNEL);
971 /*write_options(); */
972
973 }
974
bit_option_toggled(GtkToggleButton * togglebutton,gpointer * something_here,gpointer data)975 static void bit_option_toggled (GtkToggleButton * togglebutton,
976 #if GTK_MAJOR_VERSION>=3
977 gpointer *something_here,
978 #endif
979 gpointer data) {
980 settings_t *settings_p=g_object_get_data(G_OBJECT(togglebutton), "settings_p");
981 if(settings_p->disable_options) return;
982
983 NOOP("notify:active signal...\n");
984
985 gint i;
986 gint64 new_value = 0;
987 const gchar *box_name = data;
988
989 GObject *box = g_object_get_data(G_OBJECT(settings_p->dialog), box_name);
990 RfmProgramOptions *options_p = g_object_get_data(box, "options_p");
991 for (i=0;options_p && options_p->option; options_p++,i++){
992 const gchar *name = options_p->option;
993 GtkWidget *button = g_object_get_data(box, name);
994 if (button) {
995 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) new_value |= (ONE64<<i);
996 }
997 }
998 i = GPOINTER_TO_INT(g_object_get_data(box, "var_name"));
999 if(rfm_options[i].value) {
1000 g_free (rfm_options[i].value);
1001 }
1002 rfm_options[i].value = g_strdup_printf ("0x%llx", (long long)new_value);
1003 NOOP(stderr, "bitflag toggle %s\n", rfm_options[i].value);
1004 mcs_manager_set_string (mcs_manager, rfm_options[i].name,
1005 CHANNEL, rfm_options[i].value);
1006 mcs_manager_notify (mcs_manager, CHANNEL);
1007 }
1008
1009 static void
switch_page(GtkNotebook * notebook,GtkWidget * page,guint page_num,gpointer user_data)1010 switch_page (GtkNotebook * notebook, GtkWidget * page, guint page_num, gpointer user_data) {
1011 settings_t *settings_p=g_object_get_data(G_OBJECT(notebook), "settings_p");
1012 // if (page_num < )
1013 {
1014 COMMENT("pagenum=%d",page_num);
1015 set_option_buttons (settings_p);
1016
1017 }
1018 }
1019
1020 static void
gint_changed(GtkComboBox * combo_box,gint id)1021 gint_changed (GtkComboBox * combo_box, gint id) {
1022 settings_t *settings_p=g_object_get_data(G_OBJECT(combo_box), "settings_p");
1023 if(settings_p->disable_options){
1024 return;
1025 }
1026 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1027 gchar *gint_selected_translated = gtk_combo_box_get_active_text (combo_box);
1028 #else
1029 gchar *gint_selected_translated = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box));
1030 #endif
1031 if (!gint_selected_translated) {
1032 DBG("gint_changed(): this should never happen\n");
1033 return;
1034 }
1035 gchar *gint_selected=NULL;
1036 if (strcmp(_("Normal"), gint_selected_translated)==0){
1037 gint_selected=g_strdup("Normal");
1038 } else
1039 if (strcmp(_("Compact"), gint_selected_translated)==0){
1040 gint_selected=g_strdup("Compact");
1041 } else
1042 if (strcmp(_("Details"), gint_selected_translated)==0){
1043 gint_selected=g_strdup("Details");
1044 } else
1045 if (strcmp(_("Big"), gint_selected_translated)==0){
1046 gint_selected=g_strdup("Big");
1047 } else
1048 if (strcmp(_("Huge"), gint_selected_translated)==0){
1049 gint_selected=g_strdup("Huge");
1050 } else {
1051 gint_selected=g_strdup("");
1052 }
1053
1054 if(rfm_options[id].value){
1055 g_free (rfm_options[id].value);
1056 }
1057 rfm_options[id].value = gint_selected;
1058 COMMENT ("gint_changed: %s->%s\n", rfm_options[id].name, rfm_options[id].value);
1059
1060 mcs_manager_set_string (mcs_manager, rfm_options[id].name, CHANNEL, gint_selected);
1061 mcs_manager_notify (mcs_manager, CHANNEL);
1062 rfm_show_text(settings_p->widgets_p);
1063 rfm_diagnostics(settings_p->widgets_p, "xffm/stock_dialog-info", NULL);
1064 rfm_diagnostics(settings_p->widgets_p, "xffm_tag/stderr", _("Please be patient"), ": ",
1065 _("Reload All Tabs in All Windows"), ". ", NULL);
1066 rfm_diagnostics(settings_p->widgets_p, "xffm_tag/blue", _("Default Size"), " --> ", gint_selected_translated, "\n",NULL);
1067 g_free(gint_selected_translated);
1068 }
1069
1070 static void
path_changed(GtkComboBox * combo_box,gint id)1071 path_changed (GtkComboBox * combo_box, gint id) {
1072 settings_t *settings_p=g_object_get_data(G_OBJECT(combo_box), "settings_p");
1073 if(settings_p->disable_options)
1074 return;
1075 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1076 gchar *path_selected = gtk_combo_box_get_active_text (combo_box);
1077 #else
1078 gchar *path_selected = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box));
1079 #endif
1080 if(!test_command(path_selected)) {
1081 gchar *m = g_strdup_printf ("%s (%s): %s", strerror (ENOEXEC), path_selected,
1082 strerror (ENOENT));
1083 rfm_confirm (NULL, GTK_MESSAGE_ERROR, m, NULL, NULL);
1084 g_free (m);
1085 return;
1086 }
1087
1088 if(rfm_options[id].value)
1089 g_free (rfm_options[id].value);
1090 rfm_options[id].value = path_selected;
1091 COMMENT ("path_changed: %s->%s\n", rfm_options[id].name, rfm_options[id].value);
1092
1093 mcs_manager_set_string (mcs_manager, rfm_options[id].name, CHANNEL, path_selected);
1094 mcs_manager_notify (mcs_manager, CHANNEL);
1095 }
1096
1097 static void
terminal_changed(GtkComboBox * combo_box,gpointer user_data)1098 terminal_changed (GtkComboBox * combo_box, gpointer user_data) {
1099 path_changed (combo_box, TERMINAL_CMD);
1100 }
1101
1102 static void
editor_changed(GtkComboBox * combo_box,gpointer user_data)1103 editor_changed (GtkComboBox * combo_box, gpointer user_data) {
1104 path_changed (combo_box, EDITOR);
1105 }
1106
1107 static void
iconsize_changed(GtkComboBox * combo_box,gpointer user_data)1108 iconsize_changed(GtkComboBox * combo_box, gpointer user_data) {
1109 gint_changed (combo_box, RFM_DEFAULT_ICON_SIZE);
1110 }
1111
1112 static void
fontsize_f(GtkComboBox * combo_box,gpointer user_data,gint item)1113 fontsize_f(GtkComboBox * combo_box, gpointer user_data, gint item) {
1114 settings_t *settings_p=g_object_get_data(G_OBJECT(combo_box), "settings_p");
1115 if(settings_p->disable_options){
1116 return;
1117 }
1118 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1119 gchar *selected = gtk_combo_box_get_active_text (combo_box);
1120 #else
1121 gchar *selected = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box));
1122 #endif
1123 if (!selected) {
1124 DBG("fontsize_changed(): this should never happen\n");
1125 return;
1126 }
1127 if(rfm_options[item].value){
1128 g_free (rfm_options[item].value);
1129 }
1130 rfm_options[item].value = selected;
1131 COMMENT ("fontsize_f(): %s->%s\n",
1132 rfm_options[item].name,
1133 rfm_options[item].value);
1134
1135 mcs_manager_set_string (mcs_manager,
1136 rfm_options[item].name,
1137 CHANNEL, selected);
1138 mcs_manager_notify (mcs_manager, CHANNEL);
1139 }
1140
1141 static void
fontfamily_changed(GtkComboBox * combo_box,gpointer user_data)1142 fontfamily_changed(GtkComboBox * combo_box, gpointer user_data){
1143 fontsize_f(combo_box, user_data, RFM_FIXED_FONT_FAMILY);
1144 }
1145 static void
vfontfamily_changed(GtkComboBox * combo_box,gpointer user_data)1146 vfontfamily_changed(GtkComboBox * combo_box, gpointer user_data){
1147 fontsize_f(combo_box, user_data, RFM_VARIABLE_FONT_FAMILY);
1148 }
1149 static void
vfontsize_changed(GtkComboBox * combo_box,gpointer user_data)1150 vfontsize_changed(GtkComboBox * combo_box, gpointer user_data) {
1151 fontsize_f(combo_box, user_data, RFM_VARIABLE_FONT_SIZE);
1152 }
1153 static void
fontsize_changed(GtkComboBox * combo_box,gpointer user_data)1154 fontsize_changed(GtkComboBox * combo_box, gpointer user_data) {
1155 fontsize_f(combo_box, user_data, RFM_FIXED_FONT_SIZE);
1156 }
1157
1158 static gboolean
entry_changed(GtkWidget * entry,GdkEvent * event,gpointer data)1159 entry_changed (GtkWidget *entry, GdkEvent *event, gpointer data){
1160 const gchar *value = gtk_entry_get_text(GTK_ENTRY(entry));
1161 gint i = GPOINTER_TO_INT(data);
1162 if(rfm_options[i].value) g_free (rfm_options[i].value);
1163
1164 rfm_options[i].value = g_strdup (value);
1165
1166 mcs_manager_set_string (mcs_manager, rfm_options[i].name, CHANNEL, rfm_options[i].value);
1167 mcs_manager_notify (mcs_manager, CHANNEL);
1168
1169 rfm_setenv (rfm_options[i].name, rfm_options[i].value, TRUE);
1170
1171 return FALSE;
1172 }
1173
1174 static void
combo_changed(GtkComboBox * combo_box,gpointer data)1175 combo_changed (GtkComboBox * combo_box, gpointer data) {
1176 settings_t *settings_p=g_object_get_data(G_OBJECT(combo_box), "settings_p");
1177 if(settings_p->disable_options) return;
1178 gint i = GPOINTER_TO_INT(data);
1179 if(rfm_options[i].value) g_free (rfm_options[i].value);
1180
1181 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1182 rfm_options[i].value =
1183 g_strdup (gtk_combo_box_get_active_text (combo_box));
1184 #else
1185 rfm_options[i].value =
1186 g_strdup (gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box)));
1187 #endif
1188
1189 mcs_manager_set_string (mcs_manager, rfm_options[i].name, CHANNEL, rfm_options[i].value);
1190 mcs_manager_notify (mcs_manager, CHANNEL);
1191 rfm_setenv (rfm_options[i].name, rfm_options[i].value, TRUE);
1192 }
1193
1194 static void
deskdir_entry(GtkEntry * entry,gpointer user_data)1195 deskdir_entry (GtkEntry * entry, gpointer user_data) {
1196 settings_t *settings_p=user_data;
1197 if(settings_p->disable_options) return;
1198 const gchar *new_value=gtk_entry_get_text(entry);
1199 if (!new_value) new_value="";
1200 if (strchr(new_value, '/') && new_value[strlen(new_value)-1]=='/') {
1201 gchar *v=g_strdup(new_value);
1202 *strrchr(v, '/')=0;
1203 gtk_entry_set_text(entry, v);
1204 g_free(v);
1205 new_value=gtk_entry_get_text(entry);
1206 }
1207
1208
1209 if (strcmp(new_value, rfm_options[RFM_DESKTOP_DIR].value)==0){
1210 return;
1211 }
1212 if(rfm_options[RFM_DESKTOP_DIR].value){
1213 g_free (rfm_options[RFM_DESKTOP_DIR].value);
1214 }
1215 rfm_options[RFM_DESKTOP_DIR].value = g_strdup(new_value);
1216
1217 COMMENT ("2.file_set: %s->%s\n", rfm_options[RFM_DESKTOP_DIR].name, rfm_options[RFM_DESKTOP_DIR].value);
1218 mcs_manager_set_string (mcs_manager, rfm_options[RFM_DESKTOP_DIR].name,
1219 CHANNEL, rfm_options[RFM_DESKTOP_DIR].value);
1220 mcs_manager_notify (mcs_manager, CHANNEL);
1221 }
1222
1223 static void
deskdir_filechooser(GtkButton * button,gpointer user_data)1224 deskdir_filechooser (GtkButton * button, gpointer user_data) {
1225 settings_t *settings_p = user_data;
1226 GtkWidget *dialog = gtk_file_chooser_dialog_new (
1227 _("Select Folder"),
1228 NULL, //parent
1229 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1230 _("Cancel"),
1231 GTK_RESPONSE_CANCEL,
1232 _("Open"),
1233 GTK_RESPONSE_ACCEPT,
1234 NULL);
1235 gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER (dialog), FALSE);
1236 gtk_file_chooser_set_preview_widget_active (GTK_FILE_CHOOSER (dialog), FALSE);
1237 // XXX gtk_file_chooser_set_show_hidden isn't working. Gtk bug or what?
1238 gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER (dialog), TRUE);
1239 g_object_set(G_OBJECT(dialog), "show-hidden", TRUE, NULL);
1240
1241 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), rfm_options[RFM_DESKTOP_DIR].value);
1242
1243 gint response = rfm_dialog_run_response(dialog);
1244
1245 if(response == GTK_RESPONSE_ACCEPT) {
1246 gchar *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1247 COMMENT ("Got %s\n", filename);
1248 // if entry changed, set entry
1249 gtk_entry_set_text(GTK_ENTRY(settings_p->desktopdir_entry), filename);
1250 // entry activate callback, do your thing
1251 deskdir_entry (GTK_ENTRY(settings_p->desktopdir_entry), settings_p);
1252 g_free (filename);
1253 }
1254 gtk_widget_destroy (dialog);
1255
1256 }
1257
1258 static void
file_set(GtkFileChooserButton * chooser,gpointer user_data)1259 file_set (GtkFileChooserButton * chooser, gpointer user_data) {
1260 settings_t *settings_p=g_object_get_data(G_OBJECT(chooser), "settings_p");
1261 if(settings_p->disable_options)
1262 return;
1263 gint i = GPOINTER_TO_INT(user_data);
1264 gchar *g=gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(chooser));
1265 COMMENT ("1.file_set: %s->%s (got: %s)\n", rfm_options[i].name, rfm_options[i].value, g);
1266
1267
1268 if(rfm_options[i].value){
1269 g_free (rfm_options[i].value);
1270 }
1271 rfm_options[i].value = g;
1272
1273 COMMENT ("2.file_set: %s->%s\n", rfm_options[i].name, rfm_options[i].value);
1274 mcs_manager_set_string (mcs_manager, rfm_options[i].name,
1275 CHANNEL, rfm_options[i].value);
1276 mcs_manager_notify (mcs_manager, CHANNEL);
1277 }
1278
1279 static void
value_clear(GtkButton * button,gpointer user_data)1280 value_clear(GtkButton * button, gpointer user_data){
1281 gint i=GPOINTER_TO_INT(user_data);
1282 if(rfm_options[i].value){
1283 g_free (rfm_options[i].value);
1284 }
1285 rfm_options[i].value = g_strdup("");
1286
1287 COMMENT ("bg_image_clear: %s->%s\n", rfm_options[i].name, rfm_options[i].value);
1288 mcs_manager_set_string (mcs_manager, rfm_options[i].name,
1289 CHANNEL, rfm_options[i].value);
1290 mcs_manager_notify (mcs_manager, CHANNEL);
1291
1292 }
1293
1294 static void
color_changed(GtkColorButton * chooser,gpointer user_data)1295 color_changed (GtkColorButton * chooser, gpointer user_data) {
1296 settings_t *settings_p=g_object_get_data(G_OBJECT(chooser), "settings_p");
1297 if(settings_p->disable_options)
1298 return;
1299 int i = (int)((long)user_data);
1300 if(rfm_options[i].value)
1301 g_free (rfm_options[i].value);
1302 #if GTK_MAJOR_VERSION==3
1303 GdkRGBA rgba;
1304 gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(chooser), &rgba);
1305 int red = 65535 * rgba.red;
1306 int green = 65535 * rgba.green;
1307 int blue = 65535 * rgba.blue;
1308 rfm_options[i].value = g_strdup_printf("#%04x%04x%04x",
1309 red, green, blue);
1310 #else
1311 GdkColor color;
1312 gtk_color_button_get_color ((GtkColorButton *) chooser, &color);
1313 rfm_options[i].value = gdk_color_to_string (&color);
1314 #endif
1315 mcs_manager_set_string (mcs_manager, rfm_options[i].name,
1316 CHANNEL, rfm_options[i].value);
1317 mcs_manager_notify (mcs_manager, CHANNEL);
1318 }
1319
1320
1321 static void
command_help(GtkWidget * button,gpointer data)1322 command_help (GtkWidget * button, gpointer data) {
1323 GtkWidget *dialog=g_object_get_data(G_OBJECT(button), "dialog");
1324 widgets_t *widgets_p=g_object_get_data(G_OBJECT(dialog), "widgets_p");
1325 gchar *argv[]={data, "--help", NULL};
1326 rfm_clear_text (widgets_p);
1327 rfm_show_text (widgets_p);
1328 rfm_thread_run_argv_full (widgets_p, argv, FALSE, NULL, rfm_operate_stdout, NULL, scroll_to_top);
1329 //argv[1] = "--version";
1330 //rfm_thread_run_argv_full (widgets_p, argv, FALSE, NULL, rfm_operate_stdout, NULL, rfm_null_function);
1331
1332 // rfm_thread_run_argv_full (widgets_p, argv, FALSE, NULL, rfm_markup_stdout_f, NULL, rfm_null_function);
1333 //rfm_thread_run_argv_with_stderr (widgets_p, argv, FALSE, rfm_dump_output);
1334 }
1335
1336
1337
1338 static void
rtfm(GtkWidget * button,gpointer data)1339 rtfm (GtkWidget * button, gpointer data) {
1340 GtkWidget *dialog=g_object_get_data(G_OBJECT(button), "dialog");
1341 widgets_t *widgets_p=g_object_get_data(G_OBJECT(dialog), "widgets_p");
1342 gchar *argv[]={"man", data, NULL};
1343 rfm_clear_text (widgets_p);
1344 rfm_show_text (widgets_p);
1345 rfm_thread_run_argv_full (widgets_p, argv, FALSE, NULL, rfm_operate_stdout, NULL, scroll_to_top);
1346 // rfm_thread_run_argv_full (widgets_p, argv, FALSE, NULL, stdout_f2, NULL, rfm_null_function);
1347 //rfm_thread_run_argv_with_stderr (widgets_p, argv, FALSE, rfm_dump_output);
1348 }
1349 // FIXME: these two functions are in xmltree
1350 static gchar *
mod_string(guint mask)1351 mod_string(guint mask){
1352 if (!mask) return NULL;
1353 gchar *mod=g_strdup("");
1354 if (mask & GDK_SHIFT_MASK) {
1355 gchar *g = g_strconcat (mod,_("Shift"), "+", NULL);
1356 g_free(mod);
1357 mod = g;
1358 }
1359 if (mask & GDK_CONTROL_MASK) {
1360 gchar *g = g_strconcat (mod,_("Control"), "+", NULL);
1361 g_free(mod);
1362 mod = g;
1363 }
1364 if (mask & GDK_MOD1_MASK) {
1365 gchar *g = g_strconcat (mod,_("Alt"), "+", NULL);
1366 g_free(mod);
1367 mod = g;
1368 }
1369 if (strlen(mod)==0) {
1370 g_free(mod);
1371 mod = g_strdup_printf ("0x%x+", mask);
1372 }
1373 return mod;
1374 }
key_string(guint keyval)1375 static gchar *key_string(guint keyval){
1376 gchar *key=NULL;
1377 if ((keyval > 0x40 && keyval < 0x5b) ||(keyval >0x02f && keyval < 0x03a)) {
1378 key = g_strdup_printf("%c", keyval);
1379 }
1380 else if (keyval > 0x60 && keyval < 0x7b) {
1381 key = g_strdup_printf("%c", keyval);
1382 }
1383 else if (keyval > 0xffbd && keyval < 0xffca) { // function keys f1-f12
1384 key = g_strdup_printf("F%d", keyval-0xffbd);
1385 }
1386 else { // other keys
1387 switch (keyval){
1388 case GDK_KEY_Home: key = g_strdup(_("Home")); break;
1389 case GDK_KEY_Left: key = g_strdup(_("Left")); break;
1390 case GDK_KEY_Up: key = g_strdup(_("Up")); break;
1391 case GDK_KEY_Right: key = g_strdup(_("Right")); break;
1392 case GDK_KEY_Down: key = g_strdup(_("Down")); break;
1393 case GDK_KEY_Page_Up: key = g_strdup(_("Page up")); break;
1394 case GDK_KEY_Page_Down: key = g_strdup(_("Page down")); break;
1395 case GDK_KEY_End: key = g_strdup(_("End")); break;
1396 case GDK_KEY_Begin: key = g_strdup(_("Begin")); break;
1397 case GDK_KEY_Delete: key = g_strdup(_("Delete")); break;
1398 case GDK_KEY_Insert: key = g_strdup(_("Insert")); break;
1399 case GDK_KEY_equal: key = g_strdup(_("Equal")); break;
1400 case GDK_KEY_plus: key = g_strdup(_("Plus")); break;
1401 case GDK_KEY_minus: key = g_strdup(_("Minus")); break;
1402 case GDK_KEY_KP_Add: key = g_strdup(_("Add")); break;
1403 case GDK_KEY_KP_Subtract: key = g_strdup(_("Subtract")); break;
1404 }
1405 }
1406 if (!key) key = g_strdup_printf("0x%x", keyval);
1407 return key;
1408 }
1409
1410 static void
set_default_keybindings(xmltree_t * xmltree_p)1411 set_default_keybindings (xmltree_t *xmltree_p){
1412 NOOP(stderr, "keybindings:\n");
1413 RodentCallback *p = (RodentCallback *) rfm_natural(RFM_MODULE_DIR, "callbacks", NULL, "get_menu_callback");
1414 xmltree_item *top_item_p = XMLTREE_get_tag_item(xmltree_p, NULL, "keys");
1415 if (!top_item_p) top_item_p = XMLTREE_tag_item_add(xmltree_p, NULL, "keys");
1416
1417 if (!p) DBG("unable to get menu_callback_p\n");
1418
1419 for (; p && p->function_id >= 0; p++){
1420 NOOP(stderr, "checking: %s\n", p->string);
1421 gchar *function_id_s = g_strdup_printf("%d", p->function_id);
1422 gchar *mod=mod_string(p->mask);
1423 gchar *key=key_string(p->key);
1424 const gchar *icon = p->icon;
1425 if (!icon && p->type == CHECKITEM_TYPE)icon = "xffm/emblem_synchronized";
1426 else if (!icon && p->type == RADIOITEM_TYPE)icon = "xffm/emblem_favorite";
1427 xmltree_item *Tag_item_p=NULL;
1428
1429 GSList *list = XMLTREE_get_tag_item_list(xmltree_p, top_item_p, "keybind");
1430 GSList *tmp = list;
1431 gboolean found = FALSE;
1432 for (;tmp && tmp->data; tmp = tmp->next){
1433 Tag_item_p = tmp->data;
1434 xmltree_attribute *a = XMLTREE_get_attribute(Tag_item_p, "function_id");
1435 const gchar *value = XMLTREE_get_attribute_value(a);
1436 if (value && strcasecmp(value, function_id_s)==0){
1437 found = TRUE;
1438 break;
1439 }
1440 }
1441 g_slist_free(list);
1442 if (found){
1443 g_free(function_id_s);
1444 // Replace text item with current translation
1445 // add function will add if not present and replace if present.
1446 XMLTREE_set_attribute_parent(xmltree_p, Tag_item_p);
1447 XMLTREE_attribute_item_add(xmltree_p, "text", _(p->string));
1448 continue;
1449 }
1450 // Function id not found
1451
1452 Tag_item_p = XMLTREE_tag_item_add(xmltree_p, top_item_p, "keybind");
1453 gchar *key_s = g_strdup_printf("%d", p->key);
1454 gchar *mask_s = g_strdup_printf("%d", p->mask);
1455 gchar *sequence = g_strdup_printf("%s%s", (mod)?mod:"", key);
1456 // This item is just to check validation routine during test runs
1457 // attribute_item_add(Tag_p, Tag_item_p, "string", p->string, NULL);
1458 XMLTREE_set_attribute_parent(xmltree_p, Tag_item_p);
1459 XMLTREE_attribute_item_add(xmltree_p, "icon_id", _(p->icon) );
1460 XMLTREE_attribute_item_add(xmltree_p, "text", _(p->string) );
1461 XMLTREE_attribute_item_add(xmltree_p, "Keybinding", sequence );
1462 XMLTREE_attribute_item_add(xmltree_p, "key", key_s );
1463 XMLTREE_attribute_item_add(xmltree_p, "mask", mask_s );
1464 XMLTREE_attribute_item_add(xmltree_p, "function_id", function_id_s );
1465 NOOP(stderr, "adding: %s\n", p->string);
1466 g_free(key);
1467 g_free(mod);
1468 g_free(key_s);
1469 g_free(mask_s);
1470 g_free(function_id_s);
1471 }
1472 }
1473
1474
1475 static void
k_callback(GtkButton * button,gpointer data)1476 k_callback (GtkButton * button, gpointer data) {
1477 void *xmltree = XMLTREE_new();
1478 XMLTREE_set_defaults_function(xmltree, set_default_keybindings, xmltree);
1479 XMLTREE_set_title(xmltree, _("Configuration of keybindings"));
1480
1481 gchar *xmlfile = g_build_filename(KEYBINDINGS_FILE, NULL);
1482 XMLTREE_set_xml(xmltree, xmlfile);
1483 g_free(xmlfile);
1484
1485 gchar *schemafile = g_build_filename(KEYBINDINGS_SCHEMA, NULL);
1486 XMLTREE_set_schema(xmltree, schemafile);
1487 g_free(schemafile);
1488
1489 XMLTREE_set_editable_attribute(xmltree, "Keybinding", XMLTREE_key_type);
1490 XMLTREE_text_activates_top_attribute(xmltree, 1);
1491
1492 //set_default_keybindings (xmltree);
1493
1494 XMLTREE_run(xmltree);
1495 XMLTREE_free(xmltree);
1496
1497
1498 //rfm_rational(RFM_MODULE_DIR, "xmltree", (void *)button, (void *)data, "xmltree");
1499 }
1500
1501
1502 gint
rfm_dialog_run_response(GtkWidget * dialog)1503 rfm_dialog_run_response(GtkWidget *dialog){
1504 gint response = GTK_RESPONSE_NONE;
1505
1506 // gtk_dialog_run() is thread unfriendly if readlock on population
1507 // is enabled. Hold on read lock may block release of gdk mutex.
1508
1509 response = gtk_dialog_run (GTK_DIALOG (dialog));
1510
1511 return response;
1512 }
1513
1514 void
t_callback(GtkButton * button,gpointer data)1515 t_callback (GtkButton * button, gpointer data) {
1516 gint64 rfm_toolbar = DEFAULT_TOOLBAR_BUTTONS;
1517 const gchar *rfm_toolbar_s = getenv("RFM_TOOLBAR");
1518 if (rfm_toolbar_s && strlen(rfm_toolbar_s)){
1519 errno = 0;
1520 rfm_toolbar = strtoll(rfm_toolbar_s, NULL, 16);
1521 if (errno){
1522 DBG("t_callback(): %s\n", strerror(errno));
1523 rfm_toolbar = DEFAULT_TOOLBAR_BUTTONS;
1524 }
1525 }
1526
1527 gint response = GTK_RESPONSE_NONE;
1528 GtkWidget *dialog = gtk_dialog_new_with_buttons (
1529 _("Toolbar Settings"), NULL,
1530 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1531 _("Cancel"), GTK_RESPONSE_CANCEL,
1532 _("Ok"), GTK_RESPONSE_YES,
1533 NULL);
1534 if(!dialog){
1535 DBG("t_callback(): cannot create dialog\n");
1536 return;
1537 }
1538 gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
1539 GtkWidget *box = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
1540 GtkWidget *frame = gtk_frame_new("");
1541 gtk_container_add(GTK_CONTAINER(box), frame);
1542 gtk_widget_show(frame);
1543 GtkWidget *t_label = gtk_label_new("");
1544 gchar *markup = g_strdup_printf("<b>%s</b>",
1545 _("Configure which items should appear in the toolbar(s)."));
1546 gtk_label_set_markup(GTK_LABEL(t_label), markup);
1547 g_free(markup);
1548 gtk_widget_show(t_label);
1549 gtk_frame_set_label_widget(GTK_FRAME(frame),t_label);
1550 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_NONE);
1551 box = rfm_vbox_new(TRUE, 3);
1552 gtk_container_add(GTK_CONTAINER(frame), box);
1553 gtk_widget_show(box);
1554
1555 GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1556 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
1557 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1558 gtk_widget_set_size_request(scrolled_window, -1 , 375);
1559 gtk_box_pack_start (GTK_BOX (box), scrolled_window, TRUE, TRUE, 0);
1560 GtkWidget *content = rfm_vbox_new(TRUE, 3);
1561 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=8
1562 gtk_container_add(GTK_CONTAINER(scrolled_window), content);
1563
1564 #else
1565 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),content);
1566 #endif
1567 gtk_widget_show(scrolled_window);
1568 gtk_widget_show(content);
1569
1570 GtkWidget *check_button[BUTTON_OVERFLOW_ID];
1571 gint i;
1572 RodentButtonDefinition *button_callback_p =
1573 rodent_get_button_definitions();
1574 for (i=0; i<BUTTON_OVERFLOW_ID; i++){
1575 const gchar *string = (button_callback_p+i)->callback.string;
1576 const gchar *icon = (button_callback_p+i)->callback.icon;
1577 const gchar *text = (button_callback_p+i)->text;
1578
1579 GtkWidget *hbox = rfm_hbox_new(FALSE, 2);
1580 gtk_box_pack_start (GTK_BOX(content), hbox, FALSE, FALSE, 0);
1581 gtk_widget_show(hbox);
1582 check_button[i] = gtk_check_button_new();
1583 gtk_box_pack_start (GTK_BOX(hbox), check_button[i], FALSE, FALSE, 0);
1584 gtk_widget_show(check_button[i]);
1585
1586 if (rfm_toolbar &(ONE64<<(button_callback_p+i)->id)) {
1587 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button[i]), TRUE);
1588 }
1589
1590 GdkPixbuf *pb = rfm_get_pixbuf(icon, 18);
1591 if (pb) {
1592 GtkWidget *image = gtk_image_new_from_pixbuf(pb);
1593 g_object_unref(pb);
1594 gtk_box_pack_start (GTK_BOX(hbox), image, FALSE, FALSE, 0);
1595 gtk_widget_show(image);
1596 }else if (text){
1597 GtkWidget *label = gtk_label_new("");
1598 gchar *markup = g_strdup_printf("<span foreground=\"black\" background=\"white\" size=\"xx-small\">%s</span>", _(text));
1599 gtk_label_set_markup(GTK_LABEL(label), markup);
1600 g_free(markup);
1601 gtk_widget_show (label);
1602 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
1603 }
1604 GtkWidget *label = gtk_label_new(_(string));
1605 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
1606 gtk_widget_show(label);
1607 }
1608 gtk_widget_show_all (dialog);
1609 // This does not work for fvwm2 (shucks)
1610 // gdk_window_set_keep_above(gtk_widget_get_window(dialog), TRUE);
1611 // This works for fvwm2
1612 gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
1613 gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(settings_dialog));
1614
1615 response = rfm_dialog_run_response(dialog);
1616
1617 gtk_widget_hide (dialog);
1618
1619 if(response == GTK_RESPONSE_YES){
1620 rfm_toolbar = 0;
1621 for (i=0; i<BUTTON_OVERFLOW_ID; i++){
1622 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_button[i]))){
1623 rfm_toolbar |= (ONE64<<(button_callback_p+i)->id);
1624 }
1625 }
1626
1627 gchar *rfm_toolbar_v = g_strdup_printf("0x%llx", (long long) rfm_toolbar);
1628 mcs_set_var("RFM_TOOLBAR", rfm_toolbar_v);
1629 g_free(rfm_toolbar_v);
1630 // set environ
1631 }
1632 gtk_widget_destroy (dialog);
1633
1634 return ;
1635
1636 }
1637
1638 static GtkWidget *
label_new(void)1639 label_new (void) {
1640 GtkWidget *label;
1641 label = gtk_label_new ("");
1642 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1643 return (label);
1644 }
1645
1646 static void
mk_bit_toggles(settings_t * settings_p,GtkWidget * vbox,const gchar * boxname,gint id,RfmProgramOptions * options_p)1647 mk_bit_toggles(settings_t *settings_p, GtkWidget *vbox,
1648 const gchar *boxname, gint id, RfmProgramOptions *options_p){
1649
1650 g_object_set_data(G_OBJECT(settings_p->dialog), boxname, vbox);
1651 g_object_set_data(G_OBJECT(vbox), "var_name", GINT_TO_POINTER(id));
1652 g_object_set_data(G_OBJECT(vbox), "options_p", options_p);
1653
1654 GtkGrid *grid;
1655 #if GTK_MAJOR_VERSION>=3
1656 grid = GTK_GRID(gtk_grid_new());
1657 #else
1658 grid = GTK_TABLE(gtk_table_new (1, 1, TRUE));
1659 #endif
1660
1661 gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, FALSE, 0);
1662
1663 gboolean indent = FALSE;
1664 gint row=0;
1665
1666 if (!options_p) DBG("mk_bit_toggles(%s): options_p is NULL.\n", boxname);
1667 for (;options_p && options_p->option; options_p++){
1668 if (strcmp(options_p->option,"submodule-indent")==0) {
1669 indent = TRUE;
1670 continue;
1671 }
1672 if (strcmp(options_p->option,"submodule-unindent")==0) {
1673 indent = FALSE;
1674 continue;
1675 }
1676 GtkWidget *button_box = rfm_hbox_new(FALSE, 0);
1677 const gchar *label = (options_p->text)?options_p->text:options_p->option;
1678 if (strcmp(options_p->option,"submodule-label")==0){
1679 GtkWidget *w = gtk_label_new("");
1680 gchar *t = g_strdup_printf("<i>%s:</i>", label);
1681 gtk_label_set_markup(GTK_LABEL(w), t);
1682 g_free(t);
1683 gtk_grid_attach(grid, w, 0, row, 1, 1);
1684 row++;
1685 continue;
1686 }
1687 if (indent){
1688 GtkWidget *w = gtk_label_new(" ");
1689 gtk_box_pack_start (GTK_BOX(button_box), w, FALSE, FALSE, 0);
1690 }
1691 GtkWidget *t_button = rfm_check_button_new ();
1692
1693 gtk_widget_set_sensitive(t_button, options_p->sensitive);
1694 gtk_widget_set_sensitive(button_box, options_p->sensitive);
1695 gtk_box_pack_start (GTK_BOX(button_box), t_button, FALSE, FALSE, 0);
1696 if (options_p->option && strlen(options_p->option)){
1697 GtkWidget *option_text = gtk_label_new("");
1698 gchar *markup = g_strdup_printf("<span weight=\"bold\">%s</span>",
1699 options_p->option);
1700 gtk_label_set_markup(GTK_LABEL(option_text), markup);
1701 g_free(markup);
1702 gtk_box_pack_start (GTK_BOX(button_box), option_text,
1703 FALSE, FALSE, 0);
1704 }
1705
1706 g_object_set_data(G_OBJECT(t_button), "settings_p", settings_p);
1707 const gchar *name = options_p->option;
1708 g_object_set_data(G_OBJECT(vbox), name, t_button);
1709
1710
1711
1712 #if GTK_MAJOR_VERSION>=3
1713 g_signal_connect (t_button, "notify::active",
1714 G_CALLBACK (bit_option_toggled), (void *)boxname);
1715
1716 #else
1717 g_signal_connect (t_button, "toggled",
1718 G_CALLBACK (bit_option_toggled), (void *)boxname);
1719 #endif
1720
1721 gboolean combo_choice = FALSE;
1722 if (options_p->choices){
1723 combo_choice = TRUE;
1724 GtkWidget *box = rfm_hbox_new(FALSE,0);
1725 GtkWidget *cbox;
1726 if (GPOINTER_TO_INT(options_p->choices) == -1) {
1727 NOOP(stderr, "entry for %s\n", rfm_options[options_p->choice_id].name);
1728 cbox = gtk_entry_new();
1729 } else {
1730 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1731 cbox = gtk_combo_box_new_text ();
1732 #else
1733 cbox = gtk_combo_box_text_new ();
1734 #endif
1735 }
1736 gtk_widget_set_sensitive(box, options_p->sensitive);
1737 gtk_widget_set_sensitive(cbox, options_p->sensitive);
1738 g_object_set_data(G_OBJECT(settings_p->dialog),
1739 rfm_options[options_p->choice_id].name, cbox);
1740 NOOP(stderr, "set %s box=0x%x\n", rfm_options[options_p->choice_id].name,
1741 GPOINTER_TO_INT(cbox));
1742
1743 gchar **p=options_p->choices;
1744 gint place = 0;
1745 if (GPOINTER_TO_INT(options_p->choices) == -1) {
1746 environ_t *environ_v = rfm_get_environ();
1747 if (getenv(environ_v[options_p->sensitive].env_var)) {
1748 gtk_entry_set_text(GTK_ENTRY(cbox),
1749 getenv(environ_v[options_p->sensitive].env_var));
1750 }
1751 g_signal_connect (cbox, "key-release-event", G_CALLBACK (entry_changed), GINT_TO_POINTER(options_p->choice_id));
1752 } else {
1753 for (;p && *p; p++){
1754 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1755 gtk_combo_box_insert_text (GTK_COMBO_BOX(cbox),
1756 place++, *p);
1757 #else
1758 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(cbox),
1759 place++, *p);
1760 #endif
1761 }
1762 gtk_combo_box_set_active (GTK_COMBO_BOX(cbox), 0);
1763 g_signal_connect (cbox, "changed", G_CALLBACK (combo_changed), GINT_TO_POINTER(options_p->choice_id));
1764 }
1765 g_object_set_data(G_OBJECT(cbox), "settings_p", settings_p);
1766 gtk_box_pack_start (GTK_BOX(box), cbox, FALSE, FALSE, 0);
1767
1768 gtk_box_pack_start (GTK_BOX(button_box), box, FALSE, FALSE, 0);
1769 gtk_widget_set_sensitive(cbox, options_p->sensitive);
1770 }
1771 gtk_grid_attach(grid, button_box, 0, row, 1,1);
1772
1773 row++;
1774 if (options_p->text) {
1775 gchar *text =(strstr(options_p->text, "%d"))?
1776 g_strdup_printf(_(options_p->text), 3):
1777 g_strdup(_(options_p->text));
1778 // Let's do some kinky stuff here...
1779 gchar **kinky;
1780
1781 // Replace tabs for spaces.
1782 gchar *text_p = text;
1783 for (; text_p && *text_p; text_p++){
1784 if (*text_p == '\t') *text_p = ' ';
1785 }
1786 // collapse extra spaces...
1787 if (strstr(text, " ")){
1788 kinky = g_strsplit(text, " ", -1);
1789 gchar **k = kinky;
1790 gchar *collapsed = g_strdup("");
1791 for (;k && *k;k++) if (strlen(*k)) {
1792 NOOP(stderr, "concating \"%s\"\n", *k);
1793 gchar *g = g_strconcat(collapsed, " ", *k, NULL);
1794 g_free(collapsed);
1795 collapsed = g;
1796 }
1797 g_strfreev(kinky);
1798 g_free(text);
1799 text = collapsed;
1800 }
1801
1802 //
1803 // 1. Split on \n
1804 if (strchr(text, '\n')){
1805 kinky = g_strsplit(text, "\n", -1);
1806 } else {
1807 kinky = (gchar **)malloc(sizeof(gchar *)*2);
1808 if (!kinky) g_error("malloc: %s\n", strerror(errno));
1809 memset(kinky, 0, sizeof(gchar *) *2);
1810 kinky[0] = g_strdup(text);
1811
1812 }
1813
1814
1815 gchar **k = kinky;
1816 //if (options_p->sensitive)
1817 for (;k && *k;k++){
1818 GtkWidget *w = label_new();
1819 gtk_widget_set_sensitive(w, options_p->sensitive);
1820 const gchar *spacing =" ";
1821 gchar *markup;
1822 if (combo_choice) spacing = " ";
1823 if (k != kinky) {
1824 spacing = " ";
1825 markup = g_strdup_printf("%s<span style=\"italic\">%s</span>", spacing, *k);
1826 } else if (options_p->option && strlen(options_p->option)) {
1827 markup = g_strdup_printf("%s<span style=\"italic\">%s</span>", spacing, *k);
1828
1829 } else {
1830 markup = g_strdup_printf("<span weight=\"bold\">%s</span>", *k);
1831 }
1832
1833 gtk_label_set_markup(GTK_LABEL(w), markup);
1834 g_free(markup);
1835 if (combo_choice){
1836 gtk_grid_attach(grid, w, 0, row, 1,1);
1837 row++;
1838 } else if (k == kinky) {
1839 gtk_box_pack_start (GTK_BOX(button_box), w,
1840 FALSE, FALSE, 0);
1841
1842 } else {
1843 gtk_grid_attach(grid, w, 0, row, 1,1);
1844 row++;
1845 }
1846
1847 }
1848 g_free(text);
1849 g_strfreev(kinky);
1850 } else {
1851 row++;
1852 }
1853 gtk_widget_set_sensitive(button_box, options_p->sensitive);
1854 }
1855 }
1856
1857
1858 static void
subtitle(GtkWidget * parent,GtkWidget * dialog,const gchar * text,gchar * button_command)1859 subtitle(GtkWidget *parent, GtkWidget *dialog, const gchar *text, gchar *button_command){
1860
1861 GtkWidget *label_box=rfm_hbox_new(FALSE, 0);
1862 gtk_box_pack_start ((GtkBox *) parent, label_box, FALSE, FALSE, 0);
1863 gchar *tab_text = g_strdup_printf ("<b><i>%s</i></b> ", text);
1864 GtkWidget *label = gtk_label_new (tab_text);
1865 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1866 //gtk_frame_set_label_widget (GTK_FRAME (framebox), label);
1867 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1868 gtk_box_pack_start ((GtkBox *) label_box, label, FALSE, FALSE, 0);
1869 if (button_command){
1870 GtkWidget *button;
1871 gboolean do_help_button=FALSE;
1872 #ifdef GNU_LS
1873 if (strcmp(button_command, "ls")==0) do_help_button=TRUE;
1874 #endif
1875
1876 #ifdef GNU_CP
1877 if (strcmp(button_command, "cp")==0) do_help_button=TRUE;
1878 #endif
1879
1880 #ifdef GNU_LN
1881 if (strcmp(button_command, "ln")==0) do_help_button=TRUE;
1882 #endif
1883
1884 #ifdef GNU_MV
1885 if (strcmp(button_command, "mv")==0) do_help_button=TRUE;
1886 #endif
1887
1888 #ifdef GNU_RM
1889 if (strcmp(button_command, "rm")==0) do_help_button=TRUE;
1890 #endif
1891 if (strcmp(button_command, "shred")==0) do_help_button=TRUE;
1892
1893 if (do_help_button) {
1894 button = rfm_dialog_button ("xffm/stock_dialog-question", NULL);
1895 g_object_set_data(G_OBJECT(button), "dialog", dialog);
1896 g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (command_help), button_command);
1897 gchar *g=g_strdup_printf("%s --help", button_command);
1898 rfm_add_custom_tooltip(button, NULL, g);
1899 g_free(g);
1900 gtk_box_pack_start ((GtkBox *) label_box, button, FALSE, FALSE, 0);
1901 gtk_widget_show(button);
1902 } else {
1903 button = rfm_dialog_button ("xffm/stock_dialog-question", NULL);
1904 g_object_set_data(G_OBJECT(button), "dialog", dialog);
1905 g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (rtfm), button_command);
1906 gchar *g=g_strdup_printf("man %s", button_command);
1907 rfm_add_custom_tooltip(button, NULL, g);
1908 g_free(g);
1909 gtk_box_pack_start ((GtkBox *) label_box, button, FALSE, FALSE, 0);
1910 gtk_widget_show(button);
1911 }
1912 }
1913 gtk_widget_show_all (label_box);
1914 g_free(tab_text);
1915 }
1916
1917 static GtkWidget *
create_tab(GtkNotebook * notebook,char * label,char * frame_label)1918 create_tab (GtkNotebook * notebook, char *label, char *frame_label) {
1919 GtkWidget *tab_label1 = gtk_label_new (label);
1920 gtk_widget_show (tab_label1);
1921 GtkWidget *page_box = rfm_vbox_new (FALSE, 6);
1922 GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL);
1923 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
1924 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1925 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1926 gtk_widget_show (sw);
1927 if(gtk_notebook_append_page (notebook, sw, tab_label1) < 0) {
1928 g_error ("Cannot append page to gtk_notebook!");
1929 }
1930
1931 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=8
1932 gtk_container_add(GTK_CONTAINER(sw), page_box);
1933
1934 #else
1935 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw),page_box);
1936 #endif
1937 gtk_widget_show (page_box);
1938
1939 // deprecated: add_spacer (GTK_BOX (page_box));
1940
1941 GtkWidget *header = gtk_label_new ("");
1942 gchar *g = g_strdup_printf("<b>%s</b>", frame_label);
1943 gtk_label_set_markup (GTK_LABEL(header), g);
1944 g_free(g);
1945 GtkWidget *hbox = rfm_hbox_new(FALSE, 3);
1946 gtk_box_pack_start (GTK_BOX (page_box), hbox, FALSE, FALSE, 0);
1947 gtk_box_pack_start (GTK_BOX (hbox), header, FALSE, FALSE, 0);
1948 GtkWidget *vbox = rfm_vbox_new (FALSE, 2);
1949 gtk_box_pack_start (GTK_BOX (page_box), vbox, FALSE, FALSE, 0);
1950
1951 gtk_widget_show (vbox);
1952 g_object_set_data(G_OBJECT(vbox), "page", sw);
1953 #if 0
1954 GtkWidget *frame = xfce_framebox_new (frame_label, TRUE);
1955 GtkWidget *frame = rfm_vbox_new (frame_label, TRUE);
1956 gtk_widget_show (frame);
1957 gtk_box_pack_start (GTK_BOX (page_box), frame, FALSE, FALSE, 0);
1958
1959 GtkWidget *vbox = rfm_vbox_new (FALSE, 6);
1960 xfce_framebox_add (XFCE_FRAMEBOX (frame), vbox);
1961 #endif
1962 return vbox;
1963
1964 }
1965
1966 static GtkWidget *
make_gint_combo_box(GtkWidget * vbox,gint id,const gchar ** options,void * callback)1967 make_gint_combo_box (GtkWidget * vbox, gint id, const gchar **options, void *callback) {
1968 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1969 // this is deprecated...
1970 GtkWidget *box = gtk_combo_box_new_text ();
1971 #else
1972 GtkWidget *box = gtk_combo_box_text_new ();
1973 #endif
1974 int place = 0;
1975 GtkWidget *hbox = rfm_hbox_new (FALSE, 6);
1976 gchar *text;
1977 environ_t *environ_v = rfm_get_environ();
1978 if (id == RFM_DEFAULT_ICON_SIZE) {
1979 text = g_strdup_printf("%s (%s)",
1980 _(environ_v[id].env_text), _("default"));
1981 } else {
1982 text = g_strdup(_(environ_v[id].env_text));
1983 }
1984 GtkWidget *label = gtk_label_new (text);
1985 g_free(text);
1986 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
1987 GSList *list=NULL;
1988
1989 const gchar **p=options;
1990 if(getenv (environ_v[id].env_var)
1991 && strlen (getenv (environ_v[id].env_var))) {
1992 for (;p && *p; p++){
1993 if (strcmp(*p, environ_v[id].env_var)==0) {
1994 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
1995 gtk_combo_box_insert_text (GTK_COMBO_BOX(box),
1996 place++, _(environ_v[id].env_var));
1997 #else
1998 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(box),
1999 place++, _(environ_v[id].env_var));
2000 #endif
2001 list=g_slist_prepend(list, _(environ_v[id].env_var));
2002 break;
2003 }
2004 }
2005
2006 }
2007
2008 for(p = options; *p; p++) {
2009 if(place == 0) {
2010 /* default values. Null values are not functionally acceptable */
2011 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2012 gtk_combo_box_insert_text (GTK_COMBO_BOX(box), place++, _(*p));
2013 #else
2014 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(box), place++, _(*p));
2015 #endif
2016 list=g_slist_prepend(list, (void *)_(*p));
2017 if(!rfm_options[id].value || !strlen (rfm_options[id].value)) {
2018 g_free (rfm_options[id].value);
2019 rfm_options[id].value = g_strdup (_(*p));
2020 mcs_manager_set_string (mcs_manager, rfm_options[id].name,
2021 CHANNEL, *p);
2022 mcs_manager_notify (mcs_manager, CHANNEL);
2023 }
2024 } else {
2025 list=g_slist_append(list, (void *)_(*p));
2026 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2027 gtk_combo_box_append_text (GTK_COMBO_BOX(box), _(*p));
2028 #else
2029 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(box), _(*p));
2030 #endif
2031 }
2032 }
2033
2034 g_object_set_data(G_OBJECT(box), "list", list);
2035 gtk_combo_box_set_active (GTK_COMBO_BOX(box), 0);
2036 gtk_box_pack_start (GTK_BOX(hbox), box, FALSE, FALSE, 0);
2037 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2038 g_signal_connect (box, "changed", G_CALLBACK (callback), NULL);
2039 return box;
2040 }
2041
2042 static GtkWidget *
make_exec_combo_box(GtkWidget * vbox,gint id,const gchar ** options,void * callback)2043 make_exec_combo_box (GtkWidget * vbox, gint id, const gchar **options, void *callback) {
2044 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2045 GtkWidget *box = gtk_combo_box_new_text ();
2046 #else
2047 GtkWidget *box = gtk_combo_box_text_new ();
2048 #endif
2049 GtkWidget *hbox = rfm_hbox_new (FALSE, 6);
2050 environ_t *environ_v = rfm_get_environ();
2051 GtkWidget *label = gtk_label_new (_(environ_v[id].env_text));
2052 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2053 GSList *list=NULL;
2054 gint place=0;
2055
2056 if(getenv (environ_v[id].env_var)
2057 && strlen (getenv (environ_v[id].env_var))) {
2058 if(test_command(getenv (environ_v[id].env_var)) ){
2059 gchar *path = g_strdup (getenv (environ_v[id].env_var));
2060 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2061 gtk_combo_box_insert_text (GTK_COMBO_BOX(box), place++, path);
2062 #else
2063 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(box), place++, path);
2064 #endif
2065 list=g_slist_prepend(list, path);
2066 }
2067 }
2068 const gchar **p;
2069 for(p = options; *p; p++) {
2070 if(test_command(*p)) {
2071 if(place){
2072 list=g_slist_append(list, (void *)*p);
2073 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2074 gtk_combo_box_append_text (GTK_COMBO_BOX(box), (void *)*p);
2075
2076 #else
2077 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(box), (void *)*p);
2078 #endif
2079 } else {
2080 list=g_slist_prepend(list, (void *)*p);
2081 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2082 gtk_combo_box_insert_text (GTK_COMBO_BOX(box), place++, *p);
2083 #else
2084 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(box), place++, *p);
2085 #endif
2086 if(!rfm_options[id].value || !strlen (rfm_options[id].value)) {
2087 g_free (rfm_options[id].value);
2088 }
2089 rfm_options[id].value = g_strdup (*p);
2090 mcs_manager_set_string (mcs_manager, rfm_options[id].name,
2091 CHANNEL, *p);
2092 mcs_manager_notify (mcs_manager, CHANNEL);
2093 }
2094 }
2095 }
2096
2097 g_object_set_data(G_OBJECT(box), "list", list);
2098 gtk_combo_box_set_active (GTK_COMBO_BOX(box), 0);
2099 gtk_box_pack_start (GTK_BOX(hbox), box, FALSE, FALSE, 0);
2100 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2101 g_signal_connect (box, "changed", G_CALLBACK (callback), NULL);
2102 return box;
2103 }
2104
2105 static GtkWidget *
make_string_combo_box(gchar ** options,const gchar * id,void * data)2106 make_string_combo_box (gchar **options, const gchar *id, void *data) {
2107 GtkWidget *combo_box;
2108 gchar **p=options;
2109 gboolean first=TRUE;
2110 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2111 combo_box = gtk_combo_box_new_text ();
2112 for (;p && *p; p++){
2113 if (first){
2114 gtk_combo_box_insert_text (GTK_COMBO_BOX(combo_box), 0, *p);
2115 first = FALSE;
2116 } else gtk_combo_box_append_text (GTK_COMBO_BOX(combo_box), *p);
2117 }
2118 #else
2119 combo_box = gtk_combo_box_text_new ();
2120 for (;p && *p; p++){
2121 if (first){
2122 gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT(combo_box), 0, *p);
2123 first = FALSE;
2124 } else gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(combo_box), *p);
2125 }
2126 #endif
2127 g_object_set_data(G_OBJECT(combo_box), id, data);
2128
2129 return combo_box;
2130 }
2131
2132 static GtkWidget *
make_file_chooser_button(int id,gboolean is_folder,GtkWidget * hbox)2133 make_file_chooser_button (int id, gboolean is_folder, GtkWidget * hbox) {
2134 environ_t *environ_v = rfm_get_environ();
2135 GtkWidget *label = gtk_label_new (_(environ_v[id].env_text));
2136 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2137 GtkWidget *button;
2138 if(is_folder) {
2139 button = gtk_file_chooser_button_new (_("Select a folder"),
2140 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
2141 } else {
2142 button = gtk_file_chooser_button_new (_("Select Files..."),
2143 GTK_FILE_CHOOSER_ACTION_OPEN);
2144 }
2145
2146
2147 if (rfm_options[id].value &&
2148 rfm_g_file_test(rfm_options[id].value, G_FILE_TEST_EXISTS)){
2149 COMMENT(stderr, "1.make_file_chooser_button: setting %s->%s\n",rfm_options[id].name,rfm_options[id].value);
2150 if (rfm_g_file_test(rfm_options[id].value, G_FILE_TEST_IS_DIR)){
2151 gtk_file_chooser_set_current_folder (
2152 GTK_FILE_CHOOSER (button), rfm_options[id].value);
2153 } else {
2154 gtk_file_chooser_set_filename (
2155 GTK_FILE_CHOOSER (button), rfm_options[id].value);
2156 }
2157 }
2158 gtk_file_chooser_button_set_title ((GtkFileChooserButton *) (button),
2159 (const gchar *)_(environ_v[id].env_text));
2160 gtk_file_chooser_button_set_width_chars ((GtkFileChooserButton *) button, 15);
2161 gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 0);
2162
2163
2164
2165 g_signal_connect (button,
2166 "file-set", G_CALLBACK (file_set), GINT_TO_POINTER(id));
2167 return button;
2168 }
2169 static void
sit_message(const gchar * file)2170 sit_message(const gchar *file){
2171 widgets_t *widgets_p = rfm_get_widget("widgets_p");
2172 rfm_diagnostics(widgets_p, "xffm/stock_dialog-info",NULL);
2173 gchar *text = g_strdup_printf(_("Creating a new file (%s)"), file);
2174 rfm_diagnostics(widgets_p, "xffm_tag/blue", text, "\n",NULL);
2175 g_free(text);
2176 }
2177
2178 static GtkWidget *
get_example_image(void)2179 get_example_image(void){
2180 GtkWidget *image=NULL;
2181 GdkPixbuf *pixbuf;
2182 GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
2183 gchar *example = NULL;
2184 if (icon_theme) example = gtk_icon_theme_get_example_icon_name(icon_theme);
2185 GtkIconInfo *icon_info = NULL;
2186 if (example && icon_theme) {
2187 icon_info = gtk_icon_theme_lookup_icon(icon_theme, example, SIZE_DIALOG, 0);
2188 }
2189
2190 if (icon_info){
2191 const gchar *path = gtk_icon_info_get_filename(icon_info);
2192 pixbuf=rfm_get_pixbuf(path, SIZE_DIALOG);
2193 } else {
2194 pixbuf=rfm_get_pixbuf("xffm/emblem_unreadable", SIZE_DIALOG);
2195 }
2196 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=8
2197 if (icon_info)g_object_unref(G_OBJECT(icon_info));
2198 #else
2199 if (icon_info) gtk_icon_info_free (icon_info);
2200 #endif
2201
2202 if (pixbuf) {
2203 image=gtk_image_new_from_pixbuf(pixbuf);
2204 }
2205 if (image) {
2206 rfm_add_custom_tooltip(image, pixbuf, _("example"));
2207 }
2208
2209 return image;
2210 }
2211
2212 static void
update_icon_example(GtkWidget * image_box)2213 update_icon_example(GtkWidget *image_box){
2214 if (!image_box){
2215 DBG("update_icon_example(): image_box should not be NULL\n");
2216 return;
2217 }
2218 GList *list = gtk_container_get_children(GTK_CONTAINER(image_box));
2219 if (list) {
2220 GtkWidget *image = list->data;
2221 if (image && GTK_IS_WIDGET(image)) {
2222 gtk_container_remove(GTK_CONTAINER(image_box), image);
2223 }
2224 }
2225 g_list_free(list);
2226 GtkWidget *image = get_example_image();
2227 gtk_container_add (GTK_CONTAINER(image_box), image);
2228 gtk_widget_show(image);
2229 }
2230
2231 #if GTK_MAJOR_VERSION>=3
2232 static void
write_keyfile(GKeyFile * key_file,const gchar * file)2233 write_keyfile(GKeyFile *key_file, const gchar *file){
2234 TRACE( "group_options_write_keyfile: %s\n", file);
2235 // Write out key_file:
2236 gsize file_length;
2237 gchar *file_string = g_key_file_to_data (key_file, &file_length, NULL);
2238 gchar *config_directory = g_path_get_dirname(file);
2239 if (!g_file_test(config_directory, G_FILE_TEST_IS_DIR)){
2240 TRACE( "creating directory %s\n", config_directory);
2241 g_mkdir_with_parents(config_directory, 0700);
2242 }
2243 g_free(config_directory);
2244 gint fd = creat(file, O_WRONLY | S_IRWXU);
2245 if (fd >= 0){
2246 if (write(fd, file_string, file_length) < 0){
2247 DBG("write_keyfile(): cannot write to %s: %s\n", file, strerror(errno));
2248 }
2249 close(fd);
2250 } else {
2251 DBG("write_keyfile(): cannot open %s for write: %s\n", file, strerror(errno));
2252 }
2253 }
2254
2255 #define GTK3_SETTINGS_KEYFILE g_get_user_config_dir(),"gtk-3.0","settings.ini"
2256 static void
save_icon_theme(GtkComboBox * combo_box,gpointer data)2257 save_icon_theme(GtkComboBox *combo_box, gpointer data){
2258 gchar *themename =
2259 gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo_box));// 2.24
2260
2261 GtkSettings *settings = gtk_settings_get_default();
2262 g_object_set( G_OBJECT(settings),
2263 "gtk-icon-theme-name", themename,
2264 NULL);
2265 GKeyFile *key_file = g_key_file_new();
2266 gchar *file = g_build_filename(GTK3_SETTINGS_KEYFILE, NULL);
2267 gboolean loaded = g_key_file_load_from_file(key_file, file,
2268 G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, NULL);
2269 if (!loaded) sit_message(file);
2270 settings_t *settings_p=g_object_get_data(G_OBJECT(combo_box), "settings_p");
2271 update_icon_example(g_object_get_data(G_OBJECT(combo_box), "image_box"));
2272
2273 g_key_file_set_string (key_file, "Settings", "gtk-icon-theme-name", themename);
2274 write_keyfile(key_file, file);
2275 g_free(file);
2276 g_free(themename);
2277 GtkToggleButton *togglebutton = data;
2278 NOOP(stderr, "toggle state is %d\n", gtk_toggle_button_get_active (togglebutton));
2279 //if(gtk_toggle_button_get_active (togglebutton))
2280 {
2281 gboolean state = settings_p->disable_options;
2282 settings_p->disable_options = FALSE;
2283 option_toggled (togglebutton, GINT_TO_POINTER(RFM_USE_GTK_ICON_THEME));
2284 settings_p->disable_options = state;
2285 }
2286 }
2287 #else
2288 #define GTK2_SETTING_FILE g_get_home_dir(),".gtkrc-2.0"
2289 static void
save_icon_theme(GtkComboBox * combo_box,gpointer data)2290 save_icon_theme(GtkComboBox *combo_box, gpointer data){
2291 gchar *file = g_build_filename(GTK2_SETTING_FILE, NULL);
2292 GtkSettings *settings = gtk_settings_get_default();
2293 gchar *themename = NULL;
2294 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<24
2295 themename = gtk_combo_box_get_active_text (combo_box);
2296 #else
2297 themename = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(combo_box));
2298 #endif
2299 g_object_set( G_OBJECT(settings),
2300 "gtk-icon-theme-name", themename,
2301 NULL);
2302 settings_t *settings_p=g_object_get_data(G_OBJECT(combo_box), "settings_p");
2303 update_icon_example(g_object_get_data(G_OBJECT(combo_box), "image_box"));
2304
2305 gchar *buffer=g_strdup_printf("gtk-icon-theme-name = \"%s\"\n", themename);
2306 g_free(themename);
2307 gchar line[256];
2308 memset (line, 0, 256);
2309 FILE *settings_file=fopen(file, "r");
2310 if (settings_file){
2311 while (fgets(line, 255, settings_file) && !feof(settings_file)){
2312 if (!strstr(line, "gtk-icon-theme-name")){
2313 gchar *g = g_strconcat(buffer, line, NULL);
2314 g_free(buffer);
2315 buffer = g;
2316 }
2317 }
2318 fclose(settings_file);
2319 } else sit_message(file);
2320
2321 settings_file=fopen(file, "w");
2322 if (settings_file){
2323 fprintf(settings_file, "%s", buffer);
2324 fclose(settings_file);
2325 }
2326 g_free(buffer);
2327 GtkToggleButton *togglebutton = data;
2328 NOOP(stderr, "toggle state is %d\n", gtk_toggle_button_get_active (togglebutton));
2329 //if(gtk_toggle_button_get_active (togglebutton))
2330 {
2331 gboolean state = settings_p->disable_options;
2332 settings_p->disable_options = FALSE;
2333 option_toggled (togglebutton, GINT_TO_POINTER(RFM_USE_GTK_ICON_THEME));
2334 settings_p->disable_options = state;
2335 }
2336 }
2337
2338 #endif
2339 static gboolean
anim_f(void * data)2340 anim_f(void *data){
2341 GdkPixbufAnimation *animation = data;
2342 GdkPixbufAnimationIter *a_iter = g_object_get_data(G_OBJECT(animation), "a_iter");
2343 GtkWidget *abox = g_object_get_data(G_OBJECT(animation), "abox");
2344 if (animation_stop) {
2345 g_object_unref(a_iter);
2346 g_object_unref(animation);
2347 return FALSE;
2348 }
2349 // Gtk bug workaround:
2350 // suspend animations if tooltip mapped.
2351 if (rfm_tooltip_is_mapped()) return TRUE;
2352 gdk_pixbuf_animation_iter_advance(a_iter, NULL);
2353
2354 GdkPixbuf *pixbuf = gdk_pixbuf_animation_iter_get_pixbuf(a_iter);
2355 GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf);
2356 GList *children = gtk_container_get_children (GTK_CONTAINER(abox));
2357 if (children && children->data) {
2358 GtkWidget *child = children->data;
2359 if (GTK_IS_WIDGET(child))
2360 gtk_container_remove (GTK_CONTAINER(abox), child);
2361 }
2362 g_list_free(children);
2363 gtk_container_add (GTK_CONTAINER(abox), image);
2364 gtk_widget_show(image);
2365 return TRUE;
2366 }
2367
2368 static void *
context_run_rfm_settings_dialog(gpointer data)2369 context_run_rfm_settings_dialog (gpointer data) {
2370
2371 /*GtkWidget *test_dialog = gtk_color_chooser_dialog_new ("test title", NULL);
2372 g_object_set(G_OBJECT(test_dialog), "show-editor", TRUE, NULL);
2373 gtk_widget_show(test_dialog);*/
2374
2375
2376
2377 if (!running) return NULL;
2378 settings_t *settings_p=data;
2379 settings_dialog = settings_p->dialog = gtk_dialog_new();
2380 gtk_window_set_type_hint(GTK_WINDOW(settings_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
2381 gtk_window_set_title(GTK_WINDOW(settings_dialog), mp->caption);
2382
2383 environ_t *environ_v = rfm_get_environ();
2384 GtkWidget *button = rfm_dialog_button ("xffm/stock_refresh", _("Rebuild Thumbnails"));
2385 gtk_widget_show (button);
2386 gtk_dialog_add_action_widget (GTK_DIALOG (settings_p->dialog), button, 2);
2387
2388 button = rfm_dialog_button ("xffm/stock_select-color", _("Icons"));
2389 gtk_widget_show (button);
2390 gtk_dialog_add_action_widget (GTK_DIALOG (settings_p->dialog), button, 1);
2391 button = rfm_dialog_button ("xffm/stock_ok", _("Ok"));
2392 gtk_widget_show (button);
2393 gtk_dialog_add_action_widget (GTK_DIALOG (settings_p->dialog), button, 0);
2394 /* gtk_dialog_new_with_buttons (mp->caption,
2395 NULL, 0,
2396 _("Rebuild Thumbnails"), 2,
2397 _("Icons"), 1,
2398 _("Close"), 0,
2399 NULL);*/
2400
2401 //gtk_window_set_modal (GTK_WINDOW(settings_dialog), TRUE);
2402 rfm_global_t *rfm_global_p = rfm_global();
2403 if (!rfm_global_p) g_error("settings-module.i: !rfm_global_p\n");
2404 //gtk_window_set_transient_for(GTK_WINDOW(settings_dialog), GTK_WINDOW(rfm_global_p->window));
2405 g_object_set_data(G_OBJECT(settings_p->dialog), "settings_p", settings_p);
2406 widgets_t *widgets_p = (widgets_t *)malloc(sizeof(widgets_t));
2407 if (!widgets_p) g_error("malloc: %s", strerror(errno));
2408 settings_p->widgets_p = widgets_p;
2409 if (rfm_global_p){
2410 rfm_global_p->settings_widgets_p = widgets_p;
2411 }
2412 memset(widgets_p, 0, sizeof(widgets_t));
2413 g_object_set_data(G_OBJECT(settings_p->dialog), "widgets_p", widgets_p);
2414 gtk_window_stick(GTK_WINDOW (settings_p->dialog));
2415 gtk_window_set_keep_above(GTK_WINDOW (settings_p->dialog), TRUE);
2416
2417 g_signal_connect (settings_p->dialog,
2418 "response", G_CALLBACK (dialog_delete), NULL);
2419 g_signal_connect (settings_p->dialog,
2420 "delete_event", G_CALLBACK (dialog_delete), NULL);
2421 g_signal_connect (settings_p->dialog,
2422 "destroy", G_CALLBACK (dialog_delete), NULL);
2423 //vbox = GTK_DIALOG (settings_p->dialog)->vbox;
2424 #if 10
2425 int i;
2426 GtkTreeIter iter;
2427 GtkCellRenderer *renderer;
2428 GtkWidget *treeview;
2429 GtkWidget *label;
2430 GtkWidget *vbox = rfm_vbox_new (FALSE, 6);
2431 gtk_box_pack_start (
2432 GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (settings_p->dialog))),
2433 vbox, TRUE, TRUE, 0);
2434 gtk_widget_show(vbox);
2435 GtkWidget *hbox = rfm_hbox_new (FALSE, 6);
2436 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2437 gtk_widget_show(hbox);
2438
2439 GtkWidget *header = gtk_label_new ("");
2440 gtk_label_set_markup (GTK_LABEL(header), mp->caption);
2441
2442 GtkWidget *abox = rfm_hbox_new(FALSE,0);
2443 gtk_box_pack_start (GTK_BOX (hbox), abox, FALSE, TRUE, 0);
2444 gchar *iconpath = g_strdup_printf("%s/icons/rfm/animated/rodent-96.gif", PACKAGE_DATA_DIR);
2445 if (!g_file_test(iconpath, G_FILE_TEST_EXISTS)){
2446 GdkPixbuf *pixbuf = rfm_get_pixbuf("xffm/stock_preferences", 96);
2447 if (pixbuf){
2448 GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf);
2449 g_object_unref(pixbuf);
2450 gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, TRUE, 0);
2451 }
2452 } else {
2453 GdkPixbufAnimation *animation = gdk_pixbuf_animation_new_from_file (iconpath, NULL);
2454 g_free(iconpath);
2455 GdkPixbufAnimationIter *a_iter = gdk_pixbuf_animation_get_iter (animation, NULL);
2456 GdkPixbuf *pixbuf = gdk_pixbuf_animation_iter_get_pixbuf(a_iter);
2457 g_object_set_data(G_OBJECT(animation), "a_iter", a_iter);
2458 g_object_set_data(G_OBJECT(animation), "abox", abox);
2459
2460 GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf);
2461 gtk_widget_show(image);
2462 gtk_box_pack_start (GTK_BOX (abox), image, FALSE, TRUE, 0);
2463 animation_stop=FALSE;
2464 g_timeout_add (20, anim_f, animation);
2465 }
2466
2467
2468
2469
2470 gtk_box_pack_start (GTK_BOX (hbox), header, FALSE, TRUE, 0);
2471
2472 GtkWidget *vpane = rfm_vpaned_new ();
2473 g_object_set_data(G_OBJECT(settings_dialog), "vpane", vpane);
2474 // hack:
2475 widgets_p->paper = settings_dialog;
2476
2477 gtk_widget_show (vpane);
2478 gtk_box_pack_start (GTK_BOX (vbox),vpane, TRUE, TRUE, 0);
2479 gtk_paned_set_position (GTK_PANED (vpane), 1000);
2480 vbox = rfm_vbox_new (FALSE, 6);
2481 gtk_paned_pack1 (GTK_PANED (vpane),
2482 GTK_WIDGET (vbox), FALSE, TRUE);
2483 gtk_widget_show(vbox);
2484
2485 widgets_p->diagnostics = gtk_text_view_new ();
2486 GtkWidget *scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
2487 gtk_widget_show (scrolledwindow);
2488 gtk_widget_show ((widgets_p->diagnostics));
2489 gtk_paned_pack2 (GTK_PANED (vpane), scrolledwindow, TRUE, TRUE);
2490 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
2491 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2492
2493 gtk_container_add (GTK_CONTAINER (scrolledwindow), (widgets_p->diagnostics));
2494 gtk_container_set_border_width (GTK_CONTAINER ((widgets_p->diagnostics)), 2);
2495 gtk_widget_set_can_focus((widgets_p->diagnostics), FALSE);
2496 gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW ((widgets_p->diagnostics)), GTK_WRAP_WORD);
2497 gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW ((widgets_p->diagnostics)), FALSE);
2498
2499
2500 GtkNotebook *notebook = GTK_NOTEBOOK(gtk_notebook_new ());
2501 g_object_set_data(G_OBJECT(notebook), "settings_p", settings_p);
2502 gtk_notebook_set_scrollable (notebook, TRUE);
2503 gtk_notebook_popup_enable (notebook);
2504 gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (notebook), TRUE, TRUE, 0);
2505
2506 ////////////////// General
2507 //
2508 vbox = create_tab (notebook, _("General"), _("General Options"));
2509
2510 {
2511 gchar *k_text=g_strdup(_("Configuration of keybindings"));
2512 gpointer k_data=NULL;
2513 GtkWidget *k_box = rfm_hbox_new(FALSE, 0);
2514 GtkWidget *k_button =
2515 rfm_mk_little_button ("xffm/emblem_keyboard",
2516 (gpointer)k_callback, k_data, k_text);
2517 GtkWidget *k_label = gtk_label_new (k_text);
2518 gtk_box_pack_start (GTK_BOX(k_box), k_button, FALSE, FALSE, 0);
2519 gtk_box_pack_start (GTK_BOX(k_box), k_label, FALSE, FALSE, 0);
2520 gtk_box_pack_start (GTK_BOX(vbox), k_box, FALSE, FALSE, 0);
2521 g_free(k_text);
2522 }
2523
2524 {
2525 gchar *t_text=g_strdup(_("Toolbar Settings"));
2526 gpointer t_data=NULL;
2527 GtkWidget *t_box = rfm_hbox_new(FALSE, 0);
2528 GtkWidget *t_button =
2529 rfm_mk_little_button ("xffm/stock_preferences",
2530 (gpointer)t_callback, t_data,
2531 t_text);
2532 GtkWidget *t_label = gtk_label_new (t_text);
2533 gtk_box_pack_start (GTK_BOX(t_box), t_button, FALSE, FALSE, 0);
2534 gtk_box_pack_start (GTK_BOX(t_box), t_label, FALSE, FALSE, 0);
2535 gtk_box_pack_start (GTK_BOX(vbox), t_box, FALSE, FALSE, 0);
2536 g_free(t_text);
2537 #if GTK_MAJOR_VERSION==2 && GTK_MINOR_VERSION<20
2538 gtk_widget_set_sensitive(GTK_WIDGET(t_button), FALSE);
2539 gtk_widget_set_sensitive(GTK_WIDGET(t_label), FALSE);
2540 gtk_widget_set_sensitive(GTK_WIDGET(t_box), FALSE);
2541 #endif
2542 }
2543
2544 for(i = RFM_DOUBLE_CLICK_NAVIGATION; i <= RFM_ENABLE_LABEL_TIPS; i++) {
2545
2546 if (i == RFM_USE_GTK_ICON_THEME) {
2547 GtkSettings *settings = gtk_settings_get_default();
2548 gchar *themename = NULL;
2549 /*g_object_set( G_OBJECT(settings),
2550 "gtk-icon-theme-name", "gnome",
2551 NULL);*/
2552 g_object_get( G_OBJECT(settings),
2553 "gtk-icon-theme-name", &themename,
2554 NULL);
2555 DBG( "icon theme name = %s\n", themename);
2556
2557 gchar **th_options = rfm_get_iconthemes();
2558 GtkWidget *theme_combo = make_string_combo_box(th_options, "settings_p", settings_p);
2559 gint combo_index=0;
2560 gchar **p = th_options;
2561 gint j;
2562 for (j=0; p && *p; p++, j++){
2563 if (strcmp(themename, *p)==0) combo_index=j;
2564 }
2565
2566 gtk_combo_box_set_active (GTK_COMBO_BOX(theme_combo), combo_index);
2567
2568 g_strfreev(th_options);
2569
2570
2571 g_free(themename);
2572
2573 GtkWidget *theme_box = rfm_hbox_new(FALSE,3);
2574 gtk_box_pack_start (GTK_BOX(vbox), theme_box, FALSE, FALSE, 0);
2575 toggle_button[i] = gtk_check_button_new_with_label (_(environ_v[i].env_text));
2576 gtk_box_pack_start (GTK_BOX(theme_box), toggle_button[i], FALSE, FALSE, 0);
2577 gtk_box_pack_start (GTK_BOX(theme_box), theme_combo, FALSE, FALSE, 0);
2578 g_signal_connect (G_OBJECT (theme_combo), "changed", G_CALLBACK (save_icon_theme), toggle_button[i]);
2579
2580 GtkWidget *image_box = rfm_hbox_new(FALSE, 0);
2581 gtk_box_pack_start (GTK_BOX(theme_box), image_box, FALSE, FALSE, 0);
2582 g_object_set_data(G_OBJECT(theme_combo), "image_box", image_box);
2583
2584 GtkWidget *image=get_example_image();
2585 if (image) gtk_box_pack_start (GTK_BOX(image_box), image, FALSE, FALSE, 0);
2586 } else {
2587 gchar *text;
2588 if (i == RFM_CONTENT_FOLDER_ICONS) {
2589 text = g_strdup_printf("%s (%s)",
2590 _(environ_v[i].env_text), _("Content Type"));
2591 } else if (i == RFM_ENABLE_TIPS) {
2592 text = g_strdup_printf("%s (%s)",
2593 _(environ_v[i].env_text), _("Icons"));
2594 } else if (i == RFM_ENABLE_LABEL_TIPS) {
2595 text = g_strdup_printf("%s (%s)",
2596 _(environ_v[i].env_text), _("Labels"));
2597 } else {
2598 text = g_strdup(_(environ_v[i].env_text));
2599 }
2600
2601 toggle_button[i] = gtk_check_button_new_with_label (text);
2602 g_free(text);
2603 gtk_box_pack_start (GTK_BOX(vbox), toggle_button[i], FALSE, FALSE, 0);
2604 }
2605 g_object_set_data(G_OBJECT(toggle_button[i]), "settings_p", settings_p);
2606 g_signal_connect (toggle_button[i],
2607 "toggled", G_CALLBACK (option_toggled), GINT_TO_POINTER(i));
2608 }
2609 // preview size
2610 GtkWidget *preview_size_hbox = rfm_hbox_new (FALSE, 6);
2611 gtk_box_pack_start (GTK_BOX(vbox), preview_size_hbox, FALSE, FALSE, 0);
2612 label = gtk_label_new (_(environ_v[RFM_PREVIEW_IMAGE_SIZE].env_text));
2613 gtk_box_pack_start (GTK_BOX(preview_size_hbox), label, FALSE, FALSE, 0);
2614 settings_p->preview_size_spinbutton =
2615 gtk_spin_button_new_with_range (100.0, 1000.0, 10.0);
2616
2617 gdouble value = rfm_get_preview_image_size();
2618 gtk_spin_button_set_value (
2619 GTK_SPIN_BUTTON(settings_p->preview_size_spinbutton),
2620 value);
2621 gtk_box_pack_start (GTK_BOX(preview_size_hbox), settings_p->preview_size_spinbutton, FALSE, FALSE, 0);
2622 g_object_set_data(
2623 G_OBJECT(settings_p->preview_size_spinbutton),
2624 "settings_p", settings_p);
2625 g_object_set_data(
2626 G_OBJECT(settings_p->preview_size_spinbutton),
2627 "which_margin", GINT_TO_POINTER(i));
2628 g_signal_connect (settings_p->preview_size_spinbutton,
2629 "value-changed", G_CALLBACK (preview_size_changed), NULL);
2630 ////// FONTS
2631 static gchar **fixed_families=NULL;
2632 static gchar **variable_families=NULL;
2633
2634 if (!fixed_families){
2635 PangoFontFamily **pfamilies=NULL;
2636 gint n_families;
2637 PangoContext *context =
2638 gtk_widget_get_pango_context (rfm_global_p->window);
2639 pango_context_list_families (context, &pfamilies, &n_families);
2640 gint k=0;
2641 variable_families = (gchar **)malloc((n_families+1) * sizeof(gchar *));
2642 fixed_families = (gchar **)malloc((n_families+1) * sizeof(gchar *));
2643 if (!fixed_families) g_error("malloc: %s\n", strerror(errno));
2644 if (!variable_families) g_error("malloc: %s\n", strerror(errno));
2645 memset(fixed_families, 0, (n_families+1) * sizeof(gchar *));
2646 memset(variable_families, 0, (n_families+1) * sizeof(gchar *));
2647 gint kk=0;
2648 gint kkk=0;
2649 for (;k<n_families;k++){
2650 if (pango_font_family_is_monospace(pfamilies[k])){
2651 fixed_families[kk++] =
2652 g_strdup(pango_font_family_get_name(pfamilies[k]));
2653
2654 }
2655 variable_families[kkk++] =
2656 g_strdup(pango_font_family_get_name(pfamilies[k]));
2657 }
2658 g_free(pfamilies);
2659 }
2660
2661 {
2662 GtkWidget *font_vbox=rfm_vbox_new(FALSE, 2);
2663 GtkWidget *font_box=rfm_hbox_new(FALSE, 2);
2664 gtk_box_pack_start (GTK_BOX(vbox), font_vbox, FALSE, FALSE, 0);
2665 gtk_box_pack_start (GTK_BOX(font_vbox), font_box, FALSE, FALSE, 0);
2666
2667 GtkWidget *font_label = gtk_label_new("");
2668 gtk_box_pack_start (GTK_BOX(font_box), font_label, FALSE, FALSE, 0);
2669 gchar *label_markup =g_strdup_printf("<b>%s:</b> ", _("Fixed width font"));
2670 gtk_label_set_markup(GTK_LABEL(font_label), label_markup);
2671 g_free(label_markup);
2672 gtk_widget_show(font_label);
2673
2674 font_box=rfm_hbox_new(FALSE, 2);
2675 gtk_box_pack_start (GTK_BOX(font_box), gtk_label_new(" "), FALSE, FALSE, 0);
2676 gtk_box_pack_start (GTK_BOX(font_vbox), font_box, FALSE, FALSE, 0);
2677 settings_p->fontsize_box =
2678 make_gint_combo_box (font_box, RFM_FIXED_FONT_SIZE, rfm_get_font_sizes(), (void *)fontsize_changed);
2679 g_object_set_data(G_OBJECT(settings_p->fontsize_box), "settings_p", settings_p);
2680
2681 font_box=rfm_hbox_new(FALSE, 2);
2682 gtk_box_pack_start (GTK_BOX(font_box), gtk_label_new(" "), FALSE, FALSE, 0);
2683 gtk_box_pack_start (GTK_BOX(font_vbox), font_box, FALSE, FALSE, 0);
2684 settings_p->fontfamily_box =
2685 make_gint_combo_box (font_box, RFM_FIXED_FONT_FAMILY, (const gchar **)fixed_families, (void *)fontfamily_changed);
2686 g_object_set_data(G_OBJECT(settings_p->fontfamily_box), "settings_p", settings_p);
2687 }
2688
2689
2690 {
2691 GtkWidget *font_vbox=rfm_vbox_new(FALSE, 2);
2692 GtkWidget *font_box=rfm_hbox_new(FALSE, 2);
2693 gtk_box_pack_start (GTK_BOX(vbox), font_vbox, FALSE, FALSE, 0);
2694 gtk_box_pack_start (GTK_BOX(font_vbox), font_box, FALSE, FALSE, 0);
2695
2696 GtkWidget *font_label = gtk_label_new("");
2697 gtk_box_pack_start (GTK_BOX(font_box), font_label, FALSE, FALSE, 0);
2698 gchar *label_markup =g_strdup_printf("<b>%s:</b> ", _("Variable width font"));
2699 gtk_label_set_markup(GTK_LABEL(font_label), label_markup);
2700 g_free(label_markup);
2701 gtk_widget_show(font_label);
2702
2703
2704 font_box=rfm_hbox_new(FALSE, 2);
2705 gtk_box_pack_start (GTK_BOX(font_box), gtk_label_new(" "), FALSE, FALSE, 0);
2706 gtk_box_pack_start (GTK_BOX(font_vbox), font_box, FALSE, FALSE, 0);
2707 settings_p->vfontsize_box =
2708 make_gint_combo_box (font_box, RFM_VARIABLE_FONT_SIZE, rfm_get_font_sizes(), (void *)vfontsize_changed);
2709 g_object_set_data(G_OBJECT(settings_p->vfontsize_box), "settings_p", settings_p);
2710
2711 font_box=rfm_hbox_new(FALSE, 2);
2712 gtk_box_pack_start (GTK_BOX(font_box), gtk_label_new(" "), FALSE, FALSE, 0);
2713 gtk_box_pack_start (GTK_BOX(font_vbox), font_box, FALSE, FALSE, 0);
2714 settings_p->vfontfamily_box =
2715 make_gint_combo_box (font_box, RFM_VARIABLE_FONT_FAMILY, (const gchar **)variable_families, (void *)vfontfamily_changed);
2716 g_object_set_data(G_OBJECT(settings_p->vfontfamily_box), "settings_p", settings_p);
2717 }
2718
2719 ///////////////////////////////
2720 settings_p->iconsize_box =
2721 make_gint_combo_box (vbox, RFM_DEFAULT_ICON_SIZE, rfm_get_icon_sizes(), (void *)iconsize_changed);
2722 g_object_set_data(G_OBJECT(settings_p->iconsize_box), "settings_p", settings_p);
2723 settings_p->terminal_box =
2724 make_exec_combo_box (vbox, TERMINAL_CMD, rfm_get_terminals(), (void *)terminal_changed);
2725 g_object_set_data(G_OBJECT(settings_p->terminal_box), "settings_p", settings_p);
2726 settings_p->editor_box =
2727 make_exec_combo_box (vbox, EDITOR, rfm_get_editors(), (void *)editor_changed);
2728 g_object_set_data(G_OBJECT(settings_p->editor_box), "settings_p", settings_p);
2729 ////
2730 hbox = rfm_hbox_new (FALSE, 6);
2731 label = gtk_label_new (_(environ_v[RFM_ICONVIEW_COLOR].env_text));
2732 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2733 settings_p->iconviewcolor_button = gtk_color_button_new ();
2734 if(getenv ("RFM_ICONVIEW_COLOR") && strlen (getenv ("RFM_ICONVIEW_COLOR")))
2735 {
2736 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=4
2737 GdkRGBA color;
2738 if(gdk_rgba_parse (&color, getenv ("RFM_ICONVIEW_COLOR") )) {
2739 gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(settings_p->iconviewcolor_button), &color);
2740 }
2741 /*gtk_color_chooser_add_palette (
2742 GTK_COLOR_CHOOSER(settings_p->iconviewcolor_button),
2743 GTK_ORIENTATION_HORIZONTAL,
2744 7,
2745 49,
2746 X11_colors);*/
2747 #else
2748 GdkColor color;
2749 if(gdk_color_parse (getenv ("RFM_ICONVIEW_COLOR"), &color)) {
2750 gtk_color_button_set_color (
2751 GTK_COLOR_BUTTON(settings_p->desktopcolor_button), &color);
2752 }
2753 #endif
2754 }
2755 gtk_color_button_set_title (GTK_COLOR_BUTTON(settings_p->iconviewcolor_button),
2756 (const gchar *) _(environ_v[RFM_ICONVIEW_COLOR].env_text));
2757 gtk_box_pack_start (GTK_BOX(hbox), settings_p->iconviewcolor_button,
2758 FALSE, FALSE, 0);
2759 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2760 g_object_set_data(G_OBJECT(settings_p->iconviewcolor_button), "settings_p", settings_p);
2761 g_signal_connect (settings_p->iconviewcolor_button,
2762 "color-set", G_CALLBACK (color_changed),
2763 GINT_TO_POINTER(RFM_ICONVIEW_COLOR));
2764 //g_object_set(G_OBJECT(settings_p->iconviewcolor_button),"show-editor", TRUE, NULL);
2765 if(gtk_widget_is_composited (settings_p->dialog)) {
2766 hbox = rfm_hbox_new (FALSE, 6);
2767 label = gtk_label_new (_(environ_v[RFM_TRANSPARENCY].env_text));
2768 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2769 double transparency=0.0;
2770 if(getenv ("RFM_TRANSPARENCY") && strlen (getenv ("RFM_TRANSPARENCY"))) {
2771 errno = 0;
2772 transparency = strtod (getenv ("RFM_TRANSPARENCY"), NULL);
2773 if(errno != 0 || transparency < 0.0)
2774 transparency = 0.0;
2775 else if(transparency > 0.75)
2776 transparency = 0.75;
2777 }
2778 GtkWidget *transparency_slider = rfm_hscale_new_with_range (0.0, 0.75, 0.01);
2779 g_object_set_data(G_OBJECT(transparency_slider), "settings_p", settings_p);
2780 gtk_scale_set_digits (GTK_SCALE(transparency_slider), 2);
2781 gtk_range_set_value (GTK_RANGE(transparency_slider), transparency);
2782 gtk_box_pack_start (GTK_BOX(hbox), transparency_slider, TRUE, TRUE, 0);
2783 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2784 g_signal_connect (transparency_slider, "change-value",
2785 G_CALLBACK (transparency_changed),
2786 GINT_TO_POINTER(RFM_TRANSPARENCY));
2787
2788 }
2789 ////////////////////////////// version control
2790
2791 gtk_widget_show_all (vbox);
2792
2793 ///////////////////////// Desktop options
2794 gchar *tab_text = g_strdup_printf(" %s:", _("Options"));
2795 vbox = create_tab (notebook, _("Desktop"), tab_text);
2796 g_free(tab_text);
2797
2798 for(i = RFM_ENABLE_DESKTOP; i <= RFM_NAVIGATE_DESKTOP; i++) {
2799 gchar *text;
2800 if (i == RFM_NAVIGATE_DESKTOP) {
2801 text = g_strdup_printf("%s (%s)",
2802 _(environ_v[i].env_text), _("Allow"));
2803 } else if (i == RFM_ENABLE_DESKTOP) {
2804 text = g_strdup_printf("%s (%s)",
2805 _(environ_v[i].env_text), _("localhost"));
2806 } else {
2807 text = g_strdup(_(environ_v[i].env_text));
2808 }
2809 toggle_button[i] =
2810 gtk_check_button_new_with_label (text);
2811 g_free(text);
2812
2813 g_object_set_data(G_OBJECT(toggle_button[i]), "settings_p", settings_p);
2814 g_signal_connect (toggle_button[i],
2815 "toggled", G_CALLBACK (option_toggled), GINT_TO_POINTER(i));
2816 gtk_box_pack_start (GTK_BOX(vbox), toggle_button[i], FALSE, FALSE, 0);
2817 if (i==RFM_ENABLE_DESKTOP && !localhost_check()){
2818 gtk_widget_set_sensitive(toggle_button[i], FALSE);
2819 }
2820 }
2821
2822 // desktop image selection
2823 hbox = rfm_hbox_new (FALSE, 6);
2824 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2825 settings_p->desktopimage_button = make_file_chooser_button (RFM_DESKTOP_IMAGE, FALSE, hbox);
2826 g_object_set_data(G_OBJECT(settings_p->desktopimage_button), "settings_p", settings_p);
2827 gchar *g=g_strdup_printf("%s (%s)", _("Clear"), _("Background image"));
2828 GtkWidget *clear_button = rfm_mk_little_button ("xffm/stock_clear",
2829 clear_bgimage, settings_p, g);
2830 gtk_widget_show(clear_button);
2831 g_free(g);
2832 gtk_box_pack_start (GTK_BOX(hbox), clear_button, FALSE, FALSE, 0);
2833 g_signal_connect (clear_button,
2834 "clicked", G_CALLBACK (value_clear),
2835 GINT_TO_POINTER(RFM_DESKTOP_IMAGE));
2836
2837
2838 // desktop directory selection
2839 hbox = rfm_hbox_new (FALSE, 6);
2840 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2841 label=gtk_label_new(_(environ_v[RFM_DESKTOP_DIR].env_text));
2842 settings_p->desktopdir_entry = gtk_entry_new();
2843 g_signal_connect (settings_p->desktopdir_entry,
2844 "activate", G_CALLBACK (deskdir_entry), settings_p);
2845
2846 settings_p->desktopdir_button =
2847 rfm_mk_little_button ("xffm/emblem_desktop",
2848 deskdir_filechooser, settings_p, _("Select Folder"));
2849 g_object_set_data(G_OBJECT(settings_p->desktopdir_button), "settings_p", settings_p);
2850 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2851 gtk_box_pack_start (GTK_BOX(hbox), settings_p->desktopdir_entry, FALSE, FALSE, 0);
2852 gtk_box_pack_start (GTK_BOX(hbox), settings_p->desktopdir_button, FALSE, FALSE, 0);
2853
2854
2855
2856
2857 ////
2858 hbox = rfm_hbox_new (FALSE, 6);
2859 label = gtk_label_new (_(environ_v[RFM_DESKTOP_COLOR].env_text));
2860 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2861 settings_p->desktopcolor_button = gtk_color_button_new ();
2862 if(getenv ("RFM_DESKTOP_COLOR") && strlen (getenv ("RFM_DESKTOP_COLOR"))) {
2863 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=4
2864 GdkRGBA color;
2865 if(gdk_rgba_parse (&color, getenv ("RFM_DESKTOP_COLOR") )) {
2866 gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(settings_p->desktopcolor_button), &color);
2867 }
2868
2869 #else
2870 GdkColor color;
2871 if(gdk_color_parse (getenv ("RFM_DESKTOP_COLOR"), &color)) {
2872 gtk_color_button_set_color (
2873 GTK_COLOR_BUTTON(settings_p->desktopcolor_button), &color);
2874 }
2875 #endif
2876 }
2877 gtk_color_button_set_title ((GtkColorButton *) (settings_p->desktopcolor_button), (const gchar *)
2878 _(environ_v[RFM_DESKTOP_COLOR].env_text));
2879 gtk_box_pack_start (GTK_BOX(hbox), settings_p->desktopcolor_button, FALSE, FALSE, 0);
2880 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2881 g_object_set_data(G_OBJECT(settings_p->desktopcolor_button), "settings_p", settings_p);
2882 g_signal_connect (settings_p->desktopcolor_button,
2883 "color-set", G_CALLBACK (color_changed), GINT_TO_POINTER(RFM_DESKTOP_COLOR));
2884
2885 // spin buttons: margins
2886 for (i = RFM_DESKTOP_TOP_MARGIN; i <= RFM_DESKTOP_LEFT_MARGIN; i++){
2887 hbox = rfm_hbox_new (FALSE, 6);
2888 label = gtk_label_new (_(environ_v[i].env_text));
2889 gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
2890 settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN] =
2891 gtk_spin_button_new_with_range (0.0, 200.0, 1.0);
2892 gdouble value = get_spin_value(i);
2893
2894 gtk_spin_button_set_value (
2895 GTK_SPIN_BUTTON(settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN]),
2896 value);
2897 gtk_box_pack_start (GTK_BOX(hbox), settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN], FALSE, FALSE, 0);
2898 gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2899 g_object_set_data(
2900 G_OBJECT(settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN]),
2901 "settings_p", settings_p);
2902 g_object_set_data(
2903 G_OBJECT(settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN]),
2904 "which_margin", GINT_TO_POINTER(i));
2905 g_signal_connect (settings_p->desktop_margin_spinbutton[i-RFM_DESKTOP_TOP_MARGIN],
2906 "value-changed", G_CALLBACK (margin_changed), GINT_TO_POINTER(i));
2907 }
2908
2909
2910 //////////////////////// Ls options
2911 tab_text = g_strdup_printf(" %s:", _("Options"));
2912 vbox = create_tab (notebook, "ls", tab_text);
2913 g_free(tab_text);
2914 subtitle(vbox, settings_dialog, _("File Information..."), "ls");
2915
2916 mk_bit_toggles(settings_p, vbox, "ls_box", RFM_LS_FLAGS, LS_OPTIONS);
2917 gtk_widget_show_all (vbox);
2918
2919
2920 //////////////////////// Copy options
2921 tab_text = g_strdup_printf(" %s:", _("Options"));
2922 vbox = create_tab (notebook, "cp", tab_text);
2923 g_free(tab_text);
2924 subtitle(vbox, settings_dialog, _("Copy"), "cp");
2925
2926 mk_bit_toggles(settings_p, vbox, "cp_box", RFM_CP_FLAGS, CP_OPTIONS);
2927 gtk_widget_show_all (vbox);
2928
2929
2930 //////////////////////// Move options
2931 tab_text = g_strdup_printf(" %s:", _("Options"));
2932 vbox = create_tab (notebook, "mv", tab_text);
2933 g_object_set_data(G_OBJECT(settings_p->dialog), "mv_box", vbox);
2934 g_free(tab_text);
2935
2936 tab_text = g_strdup_printf("%s", _("Move"));
2937 subtitle(vbox, settings_dialog, tab_text, "mv");
2938 g_free(tab_text);
2939 mk_bit_toggles(settings_p, vbox, "mv_box", RFM_MV_FLAGS, MV_OPTIONS);
2940 gtk_widget_show_all (vbox);
2941
2942 //////////////////////// link options
2943 tab_text = g_strdup_printf(" %s:", _("Options"));
2944 vbox = create_tab (notebook, "ln", tab_text);
2945 g_object_set_data(G_OBJECT(settings_p->dialog), "ln_box", vbox);
2946 g_free(tab_text);
2947
2948 subtitle(vbox, settings_dialog, _("Symbolic Link"), "ln");
2949 mk_bit_toggles(settings_p, vbox, "ln_box", RFM_LN_FLAGS, LN_OPTIONS);
2950
2951 gtk_widget_show_all (vbox);
2952
2953 //////////////////////// remove options
2954 tab_text = g_strdup_printf(" %s:", _("Options"));
2955 vbox = create_tab (notebook, "rm", tab_text);
2956 g_object_set_data(G_OBJECT(settings_p->dialog), "rm_box", vbox);
2957 g_free(tab_text);
2958
2959
2960
2961 subtitle(vbox, settings_dialog, _("Delete"), "rm");
2962 mk_bit_toggles(settings_p, vbox, "rm_box", RFM_RM_FLAGS, RM_OPTIONS);
2963 gtk_widget_show_all (vbox);
2964
2965 //////////////////////// shred options
2966 DBG("testing for shred command...\n");
2967 gchar *shred_bin = g_find_program_in_path("shred");
2968 if (shred_bin) {
2969 DBG("shred bin is at %s\n", shred_bin);
2970 tab_text = g_strdup_printf(" %s:", _("Options"));
2971 vbox = create_tab (notebook, "shred", tab_text);
2972 g_object_set_data(G_OBJECT(settings_p->dialog), "shred_box", vbox);
2973 g_free(tab_text);
2974 subtitle(vbox, settings_dialog, _("Shred"), "shred");
2975 mk_bit_toggles(settings_p, vbox, "shred_box", RFM_SHRED_FLAGS, SHRED_OPTIONS);
2976 gtk_widget_show_all (vbox);
2977 g_free(shred_bin);
2978 }
2979 #if 0
2980 // Plugin restriction is not very useful...
2981 // Just remove the plugin if you don't want it!
2982 //////////////////////// rodent plugins
2983 tab_text = g_strdup_printf(" %s:", _("Plugins"));
2984 vbox = create_tab (notebook, _("Plugins"), tab_text);
2985 g_object_set_data(G_OBJECT(settings_p->dialog), "plugins_box", vbox);
2986 g_free(tab_text);
2987 subtitle(vbox, settings_dialog, _("Rodent"), "rodent");
2988 // find plugins and modules and create toggles, or...
2989 // use a predefined toggle list as with cp.
2990 mk_bit_toggles(settings_p, vbox, "plugins_box", RFM_PLUGIN_FLAGS, rfm_get_lite_plugin_options());
2991
2992 gtk_widget_show_all (vbox);
2993 //////////////////////// rodent modules
2994 tab_text = g_strdup_printf(" %s:", _("Modules"));
2995 vbox = create_tab (notebook, _("Modules"), tab_text);
2996 g_object_set_data(G_OBJECT(settings_p->dialog), "modules_box", vbox);
2997 g_free(tab_text);
2998 subtitle(vbox, settings_dialog, _("Rodent"), "rodent");
2999 // find plugins and modules and create toggles, or...
3000 // use a predefined toggle list as with cp.
3001 mk_bit_toggles(settings_p, vbox, "modules_box", RFM_MODULE_FLAGS, rfm_get_lite_module_options());
3002
3003 gtk_widget_show_all (vbox);
3004 #endif
3005
3006 ///////////////////////////
3007 // advanced options (environment variables)
3008 ///////////////////////////
3009 vbox = create_tab (notebook, _("Environment Variables"),
3010 _("Edit the list of environment variables and associated values"));
3011
3012 GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL);
3013 gtk_widget_set_size_request(sw, -1 , 275);
3014 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
3015 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3016 gtk_widget_show (sw);
3017 gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
3018
3019 settings_p->model = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
3020 for(i = 0; i < RFM_OPTIONS; i++) {
3021 gtk_list_store_append (settings_p->model, &iter);
3022 gtk_list_store_set (settings_p->model, &iter,
3023 COLUMN_VARIABLE,
3024 g_strdup (rfm_options[i].name),
3025 COLUMN_VALUE, g_strdup (rfm_options[i].value),
3026 COLUMN_EDITABLE, TRUE, -1);
3027 }
3028 treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (settings_p->model));
3029 g_object_unref (G_OBJECT (settings_p->model));
3030 // gtk_tree_view_set_rules_hint is deprecated
3031 // and WTF do we need it for anyways?
3032 // gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
3033 gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
3034 GTK_SELECTION_SINGLE);
3035 /* variable column */
3036 renderer = gtk_cell_renderer_text_new ();
3037 g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (environment_changed), settings_p);
3038 g_object_set_data (G_OBJECT (renderer), "column", (gint *) COLUMN_VARIABLE);
3039
3040 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
3041 -1, _("Variable"), renderer, "text",
3042 COLUMN_VARIABLE, NULL);
3043 /* value column */
3044 renderer = gtk_cell_renderer_text_new ();
3045 g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (environment_changed), settings_p);
3046 g_object_set_data (G_OBJECT (renderer), "column", (gint *) COLUMN_VALUE);
3047
3048 gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
3049 -1, _("Value"), renderer, "text",
3050 COLUMN_VALUE, "editable",
3051 COLUMN_EDITABLE, NULL);
3052
3053 gtk_widget_set_size_request (treeview, 300, 200);
3054 gtk_widget_show (treeview);
3055 gtk_container_add (GTK_CONTAINER (sw), treeview);
3056
3057 set_option_buttons (settings_p);
3058 g_signal_connect (notebook, "switch-page", G_CALLBACK (switch_page), NULL);
3059
3060 gtk_widget_set_size_request (settings_p->dialog, 650, 500);
3061 gtk_window_set_decorated (GTK_WINDOW (settings_p->dialog), TRUE);
3062 gtk_window_set_type_hint (GTK_WINDOW (settings_p->dialog), GDK_WINDOW_TYPE_HINT_NORMAL);
3063 gtk_window_set_destroy_with_parent (GTK_WINDOW (settings_p->dialog), TRUE);
3064 gtk_window_stick (GTK_WINDOW (settings_p->dialog));
3065 gchar *title = g_strdup_printf ("%s %s (%s)",
3066 PACKAGE_NAME, TAG, _("Personal settings"));
3067 gtk_window_set_title (GTK_WINDOW (settings_p->dialog), title);
3068 g_free (title);
3069 GdkPixbuf *icon_pixbuf = rfm_get_pixbuf ("xffm/stock_preferences", SIZE_ICON);
3070 if(icon_pixbuf) {
3071 gtk_window_set_icon (GTK_WINDOW (settings_p->dialog), icon_pixbuf);
3072 g_object_unref(icon_pixbuf);
3073 }
3074
3075 #endif
3076 gtk_window_set_type_hint(GTK_WINDOW(settings_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
3077 gtk_widget_show_all (settings_p->dialog);
3078 return NULL;
3079 }
3080
3081
3082 static
3083 void *
options_dialog_f(void * data)3084 options_dialog_f( void *data){
3085 void **arg = data;
3086 widgets_t *widgets_p = arg[0];
3087 const gchar *command = arg[1];
3088 if (!command) return NULL;
3089 settings_t *settings_p=(settings_t *)malloc(sizeof(settings_t));
3090 if (!settings_p) g_error("malloc: %s", strerror(errno));
3091 memset(settings_p, 0, sizeof(settings_t));
3092 RfmProgramOptions *options_p;
3093 const gchar *id = NULL;
3094 gint flags;
3095 if (strcmp(command, "cp")==0){
3096 options_p = CP_OPTIONS;
3097 id = "cp_box";
3098 flags = RFM_CP_FLAGS;
3099 } else if (strcmp(command, "ls")==0){
3100 options_p = LS_OPTIONS;
3101 id = "ls_box";
3102 flags = RFM_LS_FLAGS;
3103 } else if (strcmp(command, "mv")==0){
3104 options_p = MV_OPTIONS;
3105 id = "mv_box";
3106 flags = RFM_MV_FLAGS;
3107 } else if (strcmp(command, "ln")==0){
3108 options_p = LN_OPTIONS;
3109 id = "ln_box";
3110 flags = RFM_LN_FLAGS;
3111 } else if (strcmp(command, "rm")==0){
3112 options_p = RM_OPTIONS;
3113 id = "rm_box";
3114 flags = RFM_RM_FLAGS;
3115 } else if (strcmp(command, "shred")==0){
3116 options_p = SHRED_OPTIONS;
3117 id = "shred_box";
3118 flags = RFM_SHRED_FLAGS;
3119 }
3120 if (!id) {
3121 DBG("options_dialog(): no option_t for %s\n", command);
3122 g_free(settings_p);
3123 return NULL;
3124 }
3125 settings_p->dialog = gtk_dialog_new();
3126 gtk_window_set_type_hint(GTK_WINDOW(settings_p->dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
3127 gchar *title = g_strdup_printf(_("Options: %s"), command);
3128 gtk_window_set_title(GTK_WINDOW(settings_p->dialog), title);
3129 g_free(title);
3130 GtkWidget *box = gtk_dialog_get_content_area (GTK_DIALOG(settings_p->dialog));
3131
3132 GtkLabel *label = GTK_LABEL(gtk_label_new(""));
3133 gchar *slabel = g_strdup_printf("<span foreground=\"blue\" background=\"#cccccc\" weight=\"bold\">%s</span>", _("Ask the user to get additional parameters"));
3134 gtk_label_set_markup(label, slabel);
3135 g_free(slabel);
3136 gtk_widget_show(GTK_WIDGET(label));
3137 gtk_box_pack_start (GTK_BOX(box), GTK_WIDGET(label), FALSE, FALSE, 0);
3138
3139 GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
3140 gtk_box_pack_start (GTK_BOX (box), scrolled_window, TRUE, TRUE, 0);
3141 GtkWidget *vbox = rfm_vbox_new(FALSE,0);
3142
3143
3144 gtk_widget_set_size_request (settings_p->dialog, -1, 300);
3145
3146 #if GTK_MAJOR_VERSION==3 && GTK_MINOR_VERSION>=8
3147 gtk_container_add(GTK_CONTAINER(scrolled_window), vbox);
3148
3149 #else
3150 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), vbox);
3151 #endif
3152
3153 mk_bit_toggles(settings_p, vbox, id, flags, options_p);
3154 set_bit_toggles(settings_p, id, options_p, flags);
3155 update_combo_entry(settings_p);
3156
3157 // XXX create ok and cancel buttons
3158
3159 GtkWidget *button = rfm_dialog_button ("xffm/stock_cancel", _("Cancel"));
3160 gtk_widget_show (button);
3161 gtk_dialog_add_action_widget (GTK_DIALOG (settings_p->dialog), button, GTK_RESPONSE_NO);
3162 g_object_set_data (G_OBJECT (settings_p->dialog), "action_false_button", button);
3163
3164 button = rfm_dialog_button ("xffm/stock_ok", _("Ok"));
3165 gtk_widget_show (button);
3166 g_object_set_data (G_OBJECT (settings_p->dialog), "action_true_button", button);
3167 gtk_dialog_add_action_widget (GTK_DIALOG (settings_p->dialog), button, GTK_RESPONSE_YES);
3168
3169 if(widgets_p) {
3170 view_t *view_p=widgets_p->view_p;
3171 if(view_p && view_p->flags.type == DESKVIEW_TYPE) {
3172 gtk_window_set_keep_above (GTK_WINDOW(settings_p->dialog), TRUE);
3173 gtk_window_stick (GTK_WINDOW(settings_p->dialog));
3174 } else {
3175 rfm_global_t *rfm_global_p = rfm_global();
3176 gtk_window_set_modal (GTK_WINDOW (settings_p->dialog), TRUE);
3177 if(rfm_global_p) gtk_window_set_transient_for (GTK_WINDOW (settings_p->dialog), GTK_WINDOW (rfm_global_p->window));
3178 }
3179 } else {
3180 gtk_window_set_modal (GTK_WINDOW (settings_p->dialog), TRUE);
3181 }
3182
3183 gtk_widget_show_all(settings_p->dialog);
3184
3185 gint response = gtk_dialog_run(GTK_DIALOG(settings_p->dialog));
3186 gtk_widget_hide(settings_p->dialog);
3187 gtk_widget_destroy (settings_p->dialog);
3188 g_free(settings_p);
3189 if(response == GTK_RESPONSE_YES) return GINT_TO_POINTER(TRUE);
3190
3191 return GINT_TO_POINTER(FALSE);
3192 }
3193
3194 #if 0
3195 // gtk 3 only. but not used as of yet...
3196 GdkRGBA X11_colors[]={
3197 {0.3882,0.7216,1.0000,1.0}, // SteelBlue1 (1)
3198 {0.8588,0.8588,0.8588,1.0}, // grey86 (2)
3199 {0.3608,0.6745,0.9333,1.0}, // SteelBlue2 (3)
3200 {0.4627,0.9333,0.0000,1.0}, // chartreuse2 (4)
3201 {0.4980,1.0000,0.8314,1.0}, // aquamarine1 (5)
3202 {0.8902,0.8902,0.8902,1.0}, // grey89 (6)
3203 {0.5451,0.2275,0.2275,1.0}, // IndianRed4 (7)
3204 {1.0000,0.9255,0.5451,1.0}, // LightGoldenrod1 (8)
3205 {0.5451,0.4941,0.4000,1.0}, // wheat4 (9)
3206 {0.5451,0.3882,0.4235,1.0}, // pink4 (10)
3207 {0.5451,0.3961,0.0314,1.0}, // DarkGoldenrod4 (11)
3208 {1.0000,0.6275,0.4784,1.0}, // LightSalmon1 (12)
3209 {0.5137,0.5451,0.5451,1.0}, // azure4 (13)
3210 {0.7294,0.7294,0.7294,1.0}, // grey73 (14)
3211 {0.4784,0.4039,0.9333,1.0}, // SlateBlue2 (15)
3212 {1.0000,0.5137,0.9804,1.0}, // orchid1 (16)
3213 {0.0627,0.3059,0.5451,1.0}, // DodgerBlue4 (17)
3214 {0.5451,0.5333,0.4706,1.0}, // cornsilk4 (18)
3215 {0.3725,0.6196,0.6275,1.0}, // CadetBlue (19)
3216 {0.9412,0.9020,0.5490,1.0}, // khaki (20)
3217 {0.2314,0.2314,0.2314,1.0}, // grey23 (21)
3218 {0.9333,0.6824,0.9333,1.0}, // plum2 (22)
3219 {0.0000,0.6980,0.9333,1.0}, // DeepSkyBlue2 (23)
3220 {1.0000,0.4314,0.7059,1.0}, // HotPink1 (24)
3221 {0.5412,0.1686,0.8863,1.0}, // BlueViolet (25)
3222 {0.7412,0.7176,0.4196,1.0}, // DarkKhaki (26)
3223 {0.8039,0.1961,0.4706,1.0}, // VioletRed3 (27)
3224 {0.7569,0.8039,0.8039,1.0}, // azure3 (28)
3225 {0.9294,0.9294,0.9294,1.0}, // grey93 (29)
3226 {0.1333,0.5451,0.1333,1.0}, // ForestGreen (30)
3227 {0.4902,0.1490,0.8039,1.0}, // purple3 (31)
3228 {0.5608,0.7373,0.5608,1.0}, // DarkSeaGreen (32)
3229 {0.0000,0.5255,0.5451,1.0}, // turquoise4 (33)
3230 {0.9412,0.9725,1.0000,1.0}, // AliceBlue (34)
3231 {0.9882,0.9882,0.9882,1.0}, // grey99 (35)
3232 {0.1608,0.1608,0.1608,1.0}, // grey16 (36)
3233 {1.0000,0.4980,0.3137,1.0}, // coral (37)
3234 {0.9804,0.9412,0.9020,1.0}, // linen (38)
3235 {0.4000,0.8039,0.6667,1.0}, // aquamarine3 (39)
3236 {0.2196,0.2196,0.2196,1.0}, // grey22 (40)
3237 {1.0000,0.8275,0.6078,1.0}, // burlywood1 (41)
3238 {0.8667,0.6275,0.8667,1.0}, // plum (42)
3239 {0.9333,0.9020,0.5216,1.0}, // khaki2 (43)
3240 {0.9333,0.7961,0.6784,1.0}, // PeachPuff2 (44)
3241 {0.6784,1.0000,0.1843,1.0}, // GreenYellow (45)
3242 {0.5490,0.5490,0.5490,1.0}, // grey55 (46)
3243 {0.9333,0.6039,0.2863,1.0}, // tan2 (47)
3244 {0.3765,0.4824,0.5451,1.0}, // LightSkyBlue4 (48)
3245 {0.5451,0.5451,0.4784,1.0}, // LightYellow4 (49)
3246 {0.0000,0.0000,0.5451,1.0}, // DarkBlue (50)
3247 {0.6275,0.3216,0.1765,1.0}, // sienna (51)
3248 {1.0000,1.0000,0.0000,1.0}, // yellow1 (52)
3249 {0.0588,0.0588,0.0588,1.0}, // grey6 (53)
3250 {0.6902,0.6902,0.6902,1.0}, // grey69 (54)
3251 {0.6706,0.5098,1.0000,1.0}, // MediumPurple1 (55)
3252 {0.0000,0.7725,0.8039,1.0}, // turquoise3 (56)
3253 {0.9333,0.4784,0.9137,1.0}, // orchid2 (57)
3254 {0.0000,0.9608,1.0000,1.0}, // turquoise1 (58)
3255 {0.2706,0.2706,0.2706,1.0}, // grey27 (59)
3256 {0.8039,0.4000,0.0000,1.0}, // DarkOrange3 (60)
3257 {0.8039,0.6784,0.0000,1.0}, // gold3 (61)
3258 {0.9333,0.3608,0.2588,1.0}, // tomato2 (62)
3259 {0.7922,0.8824,1.0000,1.0}, // LightSteelBlue1 (63)
3260 {0.6902,0.8784,0.9020,1.0}, // PowderBlue (64)
3261 {0.5451,0.2706,0.0000,1.0}, // DarkOrange4 (65)
3262 {1.0000,0.7137,0.7569,1.0}, // LightPink (66)
3263 {0.9333,0.4627,0.0000,1.0}, // DarkOrange2 (67)
3264 {0.1255,0.6980,0.6667,1.0}, // LightSeaGreen (68)
3265 {0.8392,0.8392,0.8392,1.0}, // grey84 (69)
3266 {0.9333,0.1725,0.1725,1.0}, // firebrick2 (70)
3267 {0.4863,0.8039,0.4863,1.0}, // PaleGreen3 (71)
3268 {0.6235,0.7137,0.8039,1.0}, // SlateGray3 (72)
3269 {0.5294,0.8078,0.9804,1.0}, // LightSkyBlue (73)
3270 {0.5137,0.4353,1.0000,1.0}, // SlateBlue1 (74)
3271 {0.2706,0.5451,0.0000,1.0}, // chartreuse4 (75)
3272 {0.3255,0.5255,0.5451,1.0}, // CadetBlue4 (76)
3273 {0.5451,0.1098,0.3843,1.0}, // maroon4 (77)
3274 {1.0000,0.5098,0.6706,1.0}, // PaleVioletRed1 (78)
3275 {0.8980,0.8980,0.8980,1.0}, // grey90 (79)
3276 {0.6078,0.1882,1.0000,1.0}, // purple1 (80)
3277 {0.7569,1.0000,0.7569,1.0}, // DarkSeaGreen1 (81)
3278 {0.2902,0.4392,0.5451,1.0}, // SkyBlue4 (82)
3279 {0.6980,0.8745,0.9333,1.0}, // LightBlue2 (83)
3280 {0.5882,0.5882,0.5882,1.0}, // grey59 (84)
3281 {0.3294,1.0000,0.6235,1.0}, // SeaGreen1 (85)
3282 {0.4000,0.5451,0.5451,1.0}, // PaleTurquoise4 (86)
3283 {1.0000,1.0000,0.8784,1.0}, // LightYellow1 (87)
3284 {0.5216,0.5216,0.5216,1.0}, // grey52 (88)
3285 {0.8471,0.7490,0.8471,1.0}, // thistle (89)
3286 {0.3647,0.2784,0.5451,1.0}, // MediumPurple4 (90)
3287 {0.9333,0.4157,0.6549,1.0}, // HotPink2 (91)
3288 {0.0000,0.9333,0.9333,1.0}, // cyan2 (92)
3289 {1.0000,0.0000,0.0000,1.0}, // red1 (93)
3290 {0.6980,0.2275,0.9333,1.0}, // DarkOrchid2 (94)
3291 {0.8706,0.8706,0.8706,1.0}, // grey87 (95)
3292 {0.4784,0.7725,0.8039,1.0}, // CadetBlue3 (96)
3293 {0.9608,0.8706,0.7020,1.0}, // wheat (97)
3294 {0.4627,0.9333,0.7765,1.0}, // aquamarine2 (98)
3295 {0.0000,0.0000,0.5020,1.0}, // NavyBlue (99)
3296 {0.0314,0.0314,0.0314,1.0}, // grey3 (100)
3297 {1.0000,0.2706,0.0000,1.0}, // OrangeRed1 (101)
3298 {1.0000,0.9608,0.9333,1.0}, // seashell1 (102)
3299 {0.8039,0.6078,0.1137,1.0}, // goldenrod3 (103)
3300 {1.0000,0.3882,0.2784,1.0}, // tomato1 (104)
3301 {0.5451,0.2784,0.3647,1.0}, // PaleVioletRed4 (105)
3302 {0.9333,0.6353,0.6784,1.0}, // LightPink2 (106)
3303 {0.4980,1.0000,0.0000,1.0}, // chartreuse1 (107)
3304 {0.9333,0.8980,0.8706,1.0}, // seashell2 (108)
3305 {0.4667,0.5333,0.6000,1.0}, // LightSlateGrey (109)
3306 {0.2588,0.2588,0.2588,1.0}, // grey26 (110)
3307 {0.8549,0.6471,0.1255,1.0}, // goldenrod (111)
3308 {0.6275,0.1255,0.9412,1.0}, // purple (112)
3309 {0.6902,0.8863,1.0000,1.0}, // LightSkyBlue1 (113)
3310 {0.3608,0.3608,0.3608,1.0}, // grey36 (114)
3311 {0.8039,0.5216,0.2471,1.0}, // tan3 (115)
3312 {0.8039,0.1490,0.1490,1.0}, // firebrick3 (116)
3313 {0.9333,0.9098,0.8039,1.0}, // cornsilk2 (117)
3314 {0.5451,0.1373,0.1373,1.0}, // brown4 (118)
3315 {0.9333,0.6627,0.7216,1.0}, // pink2 (119)
3316 {0.7490,0.9373,1.0000,1.0}, // LightBlue1 (120)
3317 {0.4392,0.5020,0.5647,1.0}, // SlateGrey (121)
3318 {0.9333,0.8118,0.6314,1.0}, // NavajoWhite2 (122)
3319 {0.8706,0.7216,0.5294,1.0}, // burlywood (123)
3320 {0.6784,0.8471,0.9020,1.0}, // LightBlue (124)
3321 {1.0000,0.9804,0.9804,1.0}, // snow1 (125)
3322 {0.6039,0.7529,0.8039,1.0}, // LightBlue3 (126)
3323 {0.7098,0.7098,0.7098,1.0}, // grey71 (127)
3324 {0.8039,0.2000,0.2000,1.0}, // brown3 (128)
3325 {0.8039,0.6667,0.4902,1.0}, // burlywood3 (129)
3326 {0.8039,0.5686,0.6196,1.0}, // pink3 (130)
3327 {0.5451,0.2118,0.1490,1.0}, // tomato4 (131)
3328 {1.0000,0.7569,0.1451,1.0}, // goldenrod1 (132)
3329 {0.9569,0.6431,0.3765,1.0}, // SandyBrown (133)
3330 {0.7608,0.7608,0.7608,1.0}, // grey76 (134)
3331 {0.0000,1.0000,0.4980,1.0}, // SpringGreen1 (135)
3332 {0.4157,0.3529,0.8039,1.0}, // SlateBlue (136)
3333 {0.7294,0.3333,0.8275,1.0}, // MediumOrchid (137)
3334 {0.5098,0.5098,0.5098,1.0}, // grey51 (138)
3335 {0.2510,0.8784,0.8157,1.0}, // turquoise (139)
3336 {0.4784,0.4784,0.4784,1.0}, // grey48 (140)
3337 {0.9333,0.4745,0.6235,1.0}, // PaleVioletRed2 (141)
3338 {0.9490,0.9490,0.9490,1.0}, // grey95 (142)
3339 {0.1020,0.1020,0.1020,1.0}, // grey10 (143)
3340 {0.0196,0.0196,0.0196,1.0}, // grey2 (144)
3341 {1.0000,0.5490,0.4118,1.0}, // salmon1 (145)
3342 {0.9608,1.0000,0.9804,1.0}, // MintCream (146)
3343 {0.6706,0.6706,0.6706,1.0}, // grey67 (147)
3344 {0.5451,0.0000,0.5451,1.0}, // DarkMagenta (148)
3345 {0.8039,0.5059,0.3843,1.0}, // LightSalmon3 (149)
3346 {0.8039,0.4078,0.5373,1.0}, // PaleVioletRed3 (150)
3347 {0.6078,0.8039,0.6078,1.0}, // DarkSeaGreen3 (151)
3348 {0.3490,0.3490,0.3490,1.0}, // grey35 (152)
3349 {1.0000,0.4157,0.4157,1.0}, // IndianRed1 (153)
3350 {0.9333,0.7059,0.7059,1.0}, // RosyBrown2 (154)
3351 {0.9333,0.9333,0.8196,1.0}, // LightYellow2 (155)
3352 {0.9333,0.3882,0.3882,1.0}, // IndianRed2 (156)
3353 {0.4784,0.5451,0.5451,1.0}, // LightCyan4 (157)
3354 {0.9333,0.1882,0.6549,1.0}, // maroon2 (158)
3355 {0.7020,0.9333,0.2275,1.0}, // OliveDrab2 (159)
3356 {0.0000,0.0000,0.9333,1.0}, // blue2 (160)
3357 {0.8784,0.9333,0.9333,1.0}, // azure2 (161)
3358 {0.4784,0.2157,0.5451,1.0}, // MediumOrchid4 (162)
3359 {0.5765,0.4392,0.8588,1.0}, // MediumPurple (163)
3360 {0.5686,0.1725,0.9333,1.0}, // purple2 (164)
3361 {0.9333,0.2275,0.5490,1.0}, // VioletRed2 (165)
3362 {0.9333,0.8784,0.8980,1.0}, // LavenderBlush2 (166)
3363 {0.3922,0.5843,0.9294,1.0}, // CornflowerBlue (167)
3364 {0.4863,0.9882,0.0000,1.0}, // LawnGreen (168)
3365 {1.0000,0.2431,0.5882,1.0}, // VioletRed1 (169)
3366 {0.1294,0.1294,0.1294,1.0}, // grey13 (170)
3367 {1.0000,0.9647,0.5608,1.0}, // khaki1 (171)
3368 {0.9333,0.9333,0.8784,1.0}, // ivory2 (172)
3369 {0.4588,0.4588,0.4588,1.0}, // grey46 (173)
3370 {0.5686,0.5686,0.5686,1.0}, // grey57 (174)
3371 {0.3333,0.1020,0.5451,1.0}, // purple4 (175)
3372 {0.8039,0.7176,0.7098,1.0}, // MistyRose3 (176)
3373 {0.6588,0.6588,0.6588,1.0}, // grey66 (177)
3374 {0.9922,0.9608,0.9020,1.0}, // OldLace (178)
3375 {0.7569,0.8039,0.7569,1.0}, // honeydew3 (179)
3376 {0.9412,0.9412,0.9412,1.0}, // grey94 (180)
3377 {0.7412,0.7412,0.7412,1.0}, // grey74 (181)
3378 {0.7020,0.7020,0.7020,1.0}, // grey70 (182)
3379 {0.6353,0.8039,0.3529,1.0}, // DarkOliveGreen3 (183)
3380 {0.4941,0.7529,0.9333,1.0}, // SkyBlue2 (184)
3381 {0.0000,1.0000,1.0000,1.0}, // cyan1 (185)
3382 {0.8039,0.7098,0.8039,1.0}, // thistle3 (186)
3383 {0.5451,0.0392,0.3137,1.0}, // DeepPink4 (187)
3384 {0.2275,0.3725,0.8039,1.0}, // RoyalBlue3 (188)
3385 {0.0706,0.0706,0.0706,1.0}, // grey7 (189)
3386 {0.0000,0.9804,0.6039,1.0}, // MediumSpringGreen (190)
3387 {0.7216,0.5255,0.0431,1.0}, // DarkGoldenrod (191)
3388 {0.8039,0.4078,0.2235,1.0}, // sienna3 (192)
3389 {0.8196,0.3725,0.9333,1.0}, // MediumOrchid2 (193)
3390 {0.5451,0.1333,0.3216,1.0}, // VioletRed4 (194)
3391 {0.8039,0.3608,0.3608,1.0}, // IndianRed (195)
3392 {0.6392,0.6392,0.6392,1.0}, // grey64 (196)
3393 {0.0000,0.5451,0.2706,1.0}, // SpringGreen4 (197)
3394 {0.9333,0.8745,0.8000,1.0}, // AntiqueWhite2 (198)
3395 {0.8039,0.3765,0.5647,1.0}, // HotPink3 (199)
3396 {0.4392,0.4392,0.4392,1.0}, // grey44 (200)
3397 {0.3294,0.3294,0.3294,1.0}, // grey33 (201)
3398 {0.1882,0.1882,0.1882,1.0}, // grey19 (202)
3399 {0.7059,0.8039,0.8039,1.0}, // LightCyan3 (203)
3400 {0.2824,0.2392,0.5451,1.0}, // DarkSlateBlue (204)
3401 {0.0000,0.6039,0.8039,1.0}, // DeepSkyBlue3 (205)
3402 {0.9333,0.7882,0.0000,1.0}, // gold2 (206)
3403 {0.5451,0.3412,0.2588,1.0}, // LightSalmon4 (207)
3404 {0.5451,0.3529,0.1686,1.0}, // tan4 (208)
3405 {1.0000,0.8941,0.7686,1.0}, // bisque1 (209)
3406 {0.4314,0.5451,0.2392,1.0}, // DarkOliveGreen4 (210)
3407 {0.5529,0.9333,0.9333,1.0}, // DarkSlateGray2 (211)
3408 {1.0000,0.1882,0.1882,1.0}, // firebrick1 (212)
3409 {0.6235,0.4745,0.9333,1.0}, // MediumPurple2 (213)
3410 {0.5451,0.1020,0.1020,1.0}, // firebrick4 (214)
3411 {0.4314,0.4314,0.4314,1.0}, // grey43 (215)
3412 {0.5451,0.0000,0.0000,1.0}, // DarkRed (216)
3413 {0.6902,0.7686,0.8706,1.0}, // LightSteelBlue (217)
3414 {0.3882,0.3882,0.3882,1.0}, // grey39 (218)
3415 {0.8039,0.4392,0.3294,1.0}, // salmon3 (219)
3416 {0.6784,0.6784,0.6784,1.0}, // grey68 (220)
3417 {0.9333,0.7059,0.1333,1.0}, // goldenrod2 (221)
3418 {0.8627,0.8627,0.8627,1.0}, // gainsboro (222)
3419 {0.5569,0.8980,0.9333,1.0}, // CadetBlue2 (223)
3420 {1.0000,0.0784,0.5765,1.0}, // DeepPink1 (224)
3421 {0.3333,0.4196,0.1843,1.0}, // DarkOliveGreen (225)
3422 {0.2784,0.2353,0.5451,1.0}, // SlateBlue4 (226)
3423 {0.8039,0.5216,0.0000,1.0}, // orange3 (227)
3424 {1.0000,0.8941,0.7098,1.0}, // moccasin (228)
3425 {0.5294,0.8078,0.9216,1.0}, // SkyBlue (229)
3426 {0.7373,0.5608,0.5608,1.0}, // RosyBrown (230)
3427 {0.6431,0.8275,0.9333,1.0}, // LightSkyBlue2 (231)
3428 {0.9804,0.9804,0.8235,1.0}, // LightGoldenrodYellow (232)
3429 {0.9333,0.6039,0.0000,1.0}, // orange2 (233)
3430 {0.7490,0.2431,1.0000,1.0}, // DarkOrchid1 (234)
3431 {0.7529,1.0000,0.2431,1.0}, // OliveDrab1 (235)
3432 {1.0000,0.6824,0.7255,1.0}, // LightPink1 (236)
3433 {0.9333,0.4745,0.2588,1.0}, // sienna2 (237)
3434 {0.8118,0.8118,0.8118,1.0}, // grey81 (238)
3435 {1.0000,0.7529,0.7961,1.0}, // pink (239)
3436 {1.0000,0.4980,0.0000,1.0}, // DarkOrange1 (240)
3437 {1.0000,0.7569,0.7569,1.0}, // RosyBrown1 (241)
3438 {0.8039,0.4000,0.1137,1.0}, // chocolate3 (242)
3439 {1.0000,0.7098,0.7725,1.0}, // pink1 (243)
3440 {0.9333,0.8353,0.8235,1.0}, // MistyRose2 (244)
3441 {1.0000,0.6471,0.3098,1.0}, // tan1 (245)
3442 {1.0000,0.8549,0.7255,1.0}, // PeachPuff1 (246)
3443 {0.0000,0.7490,1.0000,1.0}, // DeepSkyBlue1 (247)
3444 {0.9412,1.0000,0.9412,1.0}, // honeydew1 (248)
3445 {0.7686,0.7686,0.7686,1.0}, // grey77 (249)
3446 {0.5451,0.2784,0.1490,1.0}, // sienna4 (250)
3447 {0.5451,0.5059,0.2980,1.0}, // LightGoldenrod4 (251)
3448 {0.2000,0.2000,0.2000,1.0}, // grey20 (252)
3449 {0.9804,0.9216,0.8431,1.0}, // AntiqueWhite (253)
3450 {0.0118,0.0118,0.0118,1.0}, // grey1 (254)
3451 {1.0000,1.0000,1.0000,1.0}, // grey100 (255)
3452 {0.8275,0.8275,0.8275,1.0}, // LightGray (256)
3453 {0.2745,0.5098,0.7059,1.0}, // SteelBlue (257)
3454 {0.9412,0.5020,0.5020,1.0}, // LightCoral (258)
3455 {0.9333,0.8667,0.5098,1.0}, // LightGoldenrod (259)
3456 {0.9333,0.0706,0.5373,1.0}, // DeepPink2 (260)
3457 {0.8510,0.8510,0.8510,1.0}, // grey85 (261)
3458 {0.8588,0.4392,0.5765,1.0}, // PaleVioletRed (262)
3459 {0.8039,0.4118,0.7882,1.0}, // orchid3 (263)
3460 {0.2784,0.2784,0.2784,1.0}, // grey28 (264)
3461 {0.0510,0.0510,0.0510,1.0}, // grey5 (265)
3462 {0.8039,0.8039,0.0000,1.0}, // yellow3 (266)
3463 {0.4980,0.4980,0.4980,1.0}, // grey50 (267)
3464 {0.5451,0.5451,0.5137,1.0}, // ivory4 (268)
3465 {0.5451,0.2431,0.1843,1.0}, // coral4 (269)
3466 {0.2706,0.5451,0.4549,1.0}, // aquamarine4 (270)
3467 {0.9333,0.8471,0.6824,1.0}, // wheat2 (271)
3468 {0.7333,1.0000,1.0000,1.0}, // PaleTurquoise1 (272)
3469 {0.0902,0.0902,0.0902,1.0}, // grey9 (273)
3470 {0.1098,0.1098,0.1098,1.0}, // grey11 (274)
3471 {0.9608,0.9608,0.8627,1.0}, // beige (275)
3472 {0.6980,0.1333,0.1333,1.0}, // firebrick (276)
3473 {0.8039,0.7176,0.6196,1.0}, // bisque3 (277)
3474 {0.9333,0.0000,0.9333,1.0}, // magenta2 (278)
3475 {1.0000,0.4471,0.3373,1.0}, // coral1 (279)
3476 {0.0000,0.0000,1.0000,1.0}, // blue1 (280)
3477 {0.3098,0.5804,0.8039,1.0}, // SteelBlue3 (281)
3478 {0.1961,0.8039,0.1961,1.0}, // LimeGreen (282)
3479 {0.0000,0.9333,0.4627,1.0}, // SpringGreen2 (283)
3480 {0.9333,0.4157,0.3137,1.0}, // coral2 (284)
3481 {1.0000,0.4118,0.7059,1.0}, // HotPink (285)
3482 {0.9333,0.5098,0.3843,1.0}, // salmon2 (286)
3483 {1.0000,1.0000,0.9412,1.0}, // ivory1 (287)
3484 {0.8784,1.0000,1.0000,1.0}, // LightCyan1 (288)
3485 {0.6039,1.0000,0.6039,1.0}, // PaleGreen1 (289)
3486 {0.9333,0.4627,0.1294,1.0}, // chocolate2 (290)
3487 {0.8235,0.7059,0.5490,1.0}, // tan (291)
3488 {0.8235,0.4118,0.1176,1.0}, // chocolate (292)
3489 {0.6471,0.1647,0.1647,1.0}, // brown (293)
3490 {0.8039,0.8039,0.7569,1.0}, // ivory3 (294)
3491 {0.6510,0.6510,0.6510,1.0}, // grey65 (295)
3492 {0.4118,0.5451,0.4118,1.0}, // DarkSeaGreen4 (296)
3493 {0.7922,1.0000,0.4392,1.0}, // DarkOliveGreen1 (297)
3494 {0.4118,0.4118,0.4118,1.0}, // grey41 (298)
3495 {1.0000,0.9373,0.8588,1.0}, // AntiqueWhite1 (299)
3496 {0.6039,0.8039,0.1961,1.0}, // OliveDrab3 (300)
3497 {0.8039,0.5490,0.5843,1.0}, // LightPink3 (301)
3498 {0.5451,0.4902,0.4196,1.0}, // bisque4 (302)
3499 {0.2627,0.8039,0.5020,1.0}, // SeaGreen3 (303)
3500 {0.0000,0.5451,0.0000,1.0}, // green4 (304)
3501 {0.8039,0.7765,0.4510,1.0}, // khaki3 (305)
3502 {0.1843,0.3098,0.3098,1.0}, // DarkSlateGrey (306)
3503 {0.6353,0.7098,0.8039,1.0}, // LightSteelBlue3 (307)
3504 {0.5451,0.4824,0.5451,1.0}, // thistle4 (308)
3505 {0.9333,0.2510,0.0000,1.0}, // OrangeRed2 (309)
3506 {1.0000,0.2510,0.2510,1.0}, // brown1 (310)
3507 {0.1176,0.5647,1.0000,1.0}, // DodgerBlue1 (311)
3508 {0.0000,1.0000,0.0000,1.0}, // green1 (312)
3509 {0.4078,0.1333,0.5451,1.0}, // DarkOrchid4 (313)
3510 {0.3216,0.3216,0.3216,1.0}, // grey32 (314)
3511 {0.4196,0.5569,0.1373,1.0}, // OliveDrab (315)
3512 {0.0941,0.4549,0.8039,1.0}, // DodgerBlue3 (316)
3513 {0.8039,0.5882,0.8039,1.0}, // plum3 (317)
3514 {0.8039,0.3569,0.2706,1.0}, // coral3 (318)
3515 {0.0000,0.0000,0.0000,1.0}, // grey0 (319)
3516 {0.5922,1.0000,1.0000,1.0}, // DarkSlateGray1 (320)
3517 {0.9333,0.5098,0.9333,1.0}, // violet (321)
3518 {0.4235,0.4824,0.5451,1.0}, // SlateGray4 (322)
3519 {0.9333,0.2314,0.2314,1.0}, // brown2 (323)
3520 {0.5451,0.2980,0.2235,1.0}, // salmon4 (324)
3521 {0.0000,0.0000,0.8039,1.0}, // blue3 (325)
3522 {1.0000,0.9804,0.8039,1.0}, // LemonChiffon1 (326)
3523 {0.8039,0.7725,0.7490,1.0}, // seashell3 (327)
3524 {1.0000,0.6471,0.0000,1.0}, // orange1 (328)
3525 {0.8039,0.1608,0.5647,1.0}, // maroon3 (329)
3526 {0.9333,0.6784,0.0549,1.0}, // DarkGoldenrod2 (330)
3527 {0.9608,0.9608,0.9608,1.0}, // grey96 (331)
3528 {0.2118,0.2118,0.2118,1.0}, // grey21 (332)
3529 {0.3294,0.5451,0.3294,1.0}, // PaleGreen4 (333)
3530 {0.9333,0.8235,0.9333,1.0}, // thistle2 (334)
3531 {0.4196,0.4196,0.4196,1.0}, // grey42 (335)
3532 {1.0000,0.9412,0.9608,1.0}, // LavenderBlush1 (336)
3533 {0.5294,0.8078,1.0000,1.0}, // SkyBlue1 (337)
3534 {0.8039,0.7294,0.5882,1.0}, // wheat3 (338)
3535 {0.5451,0.4667,0.3961,1.0}, // PeachPuff4 (339)
3536 {0.2824,0.4627,1.0000,1.0}, // RoyalBlue1 (340)
3537 {0.5451,0.2784,0.5373,1.0}, // orchid4 (341)
3538 {0.8784,0.9333,0.8784,1.0}, // honeydew2 (342)
3539 {0.5804,0.0000,0.8275,1.0}, // DarkViolet (343)
3540 {0.0000,0.3922,0.0000,1.0}, // DarkGreen (344)
3541 {1.0000,0.5490,0.0000,1.0}, // DarkOrange (345)
3542 {0.5647,0.9333,0.5647,1.0}, // LightGreen (346)
3543 {1.0000,0.9059,0.7294,1.0}, // wheat1 (347)
3544 {0.2392,0.2392,0.2392,1.0}, // grey24 (348)
3545 {0.6196,0.6196,0.6196,1.0}, // grey62 (349)
3546 {0.8039,0.0000,0.0000,1.0}, // red3 (350)
3547 {0.5451,0.5255,0.3059,1.0}, // khaki4 (351)
3548 {0.8039,0.7843,0.6941,1.0}, // cornsilk3 (352)
3549 {0.8000,0.8000,0.8000,1.0}, // grey80 (353)
3550 {0.1490,0.1490,0.1490,1.0}, // grey15 (354)
3551 {0.5451,0.3725,0.3961,1.0}, // LightPink4 (355)
3552 {0.8039,0.7529,0.6902,1.0}, // AntiqueWhite3 (356)
3553 {0.8196,0.8196,0.8196,1.0}, // grey82 (357)
3554 {0.9412,1.0000,1.0000,1.0}, // azure1 (358)
3555 {0.5451,0.4000,0.5451,1.0}, // plum4 (359)
3556 {0.6118,0.6118,0.6118,1.0}, // grey61 (360)
3557 {0.9020,0.9020,0.9804,1.0}, // lavender (361)
3558 {0.5608,0.5608,0.5608,1.0}, // grey56 (362)
3559 {0.4510,0.4510,0.4510,1.0}, // grey45 (363)
3560 {0.3804,0.3804,0.3804,1.0}, // grey38 (364)
3561 {0.8039,0.7569,0.7725,1.0}, // LavenderBlush3 (365)
3562 {0.5882,0.8039,0.8039,1.0}, // PaleTurquoise3 (366)
3563 {0.8157,0.1255,0.5647,1.0}, // VioletRed (367)
3564 {0.6863,0.9333,0.9333,1.0}, // PaleTurquoise (368)
3565 {0.9098,0.9098,0.9098,1.0}, // grey91 (369)
3566 {0.8039,0.6863,0.5843,1.0}, // PeachPuff3 (370)
3567 {0.5451,0.5137,0.5255,1.0}, // LavenderBlush4 (371)
3568 {0.7490,0.7490,0.7490,1.0}, // grey75 (372)
3569 {0.4902,0.4902,0.4902,1.0}, // grey49 (373)
3570 {0.3098,0.3098,0.3098,1.0}, // grey31 (374)
3571 {0.0784,0.0784,0.0784,1.0}, // grey8 (375)
3572 {0.2824,0.8196,0.8000,1.0}, // MediumTurquoise (376)
3573 {0.9333,0.9137,0.7490,1.0}, // LemonChiffon2 (377)
3574 {0.1216,0.1216,0.1216,1.0}, // grey12 (378)
3575 {0.5294,0.5294,0.5294,1.0}, // grey53 (379)
3576 {0.5961,0.9843,0.5961,1.0}, // PaleGreen (380)
3577 {0.4745,0.8039,0.8039,1.0}, // DarkSlateGray3 (381)
3578 {0.0000,0.8039,0.4000,1.0}, // SpringGreen3 (382)
3579 {0.1686,0.1686,0.1686,1.0}, // grey17 (383)
3580 {0.5451,0.4510,0.3333,1.0}, // burlywood4 (384)
3581 {0.2353,0.7020,0.4431,1.0}, // MediumSeaGreen (385)
3582 {0.8196,0.9333,0.9333,1.0}, // LightCyan2 (386)
3583 {0.4000,0.8039,0.0000,1.0}, // chartreuse3 (387)
3584 {0.5451,0.4118,0.4118,1.0}, // RosyBrown4 (388)
3585 {0.5451,0.4588,0.0000,1.0}, // gold4 (389)
3586 {0.5451,0.5255,0.5098,1.0}, // seashell4 (390)
3587 {0.5451,0.3529,0.0000,1.0}, // orange4 (391)
3588 {0.4118,0.5451,0.1333,1.0}, // OliveDrab4 (392)
3589 {0.0000,0.9333,0.0000,1.0}, // green2 (393)
3590 {0.7451,0.7451,0.7451,1.0}, // grey (394)
3591 {0.9725,0.9725,1.0000,1.0}, // GhostWhite (395)
3592 {0.0000,0.4078,0.5451,1.0}, // DeepSkyBlue4 (396)
3593 {0.5451,0.4118,0.0784,1.0}, // goldenrod4 (397)
3594 {1.0000,0.4980,0.1412,1.0}, // chocolate1 (398)
3595 {1.0000,0.5098,0.2784,1.0}, // sienna1 (399)
3596 {0.5451,0.4745,0.3686,1.0}, // NavajoWhite4 (400)
3597 {0.1098,0.5255,0.9333,1.0}, // DodgerBlue2 (401)
3598 {0.5412,0.5412,0.5412,1.0}, // grey54 (402)
3599 {0.4706,0.4706,0.4706,1.0}, // grey47 (403)
3600 {0.9804,0.5020,0.4471,1.0}, // salmon (404)
3601 {0.5451,0.4902,0.4824,1.0}, // MistyRose4 (405)
3602 {0.9804,0.9804,0.9804,1.0}, // grey98 (406)
3603 {0.3686,0.3686,0.3686,1.0}, // grey37 (407)
3604 {0.5137,0.5451,0.5137,1.0}, // honeydew4 (408)
3605 {0.5451,0.2275,0.3843,1.0}, // HotPink4 (409)
3606 {0.5451,0.2706,0.0745,1.0}, // chocolate4 (410)
3607 {0.8039,0.7882,0.7882,1.0}, // snow3 (411)
3608 {0.5451,0.5451,0.0000,1.0}, // yellow4 (412)
3609 {0.1804,0.5451,0.3412,1.0}, // SeaGreen4 (413)
3610 {1.0000,0.2039,0.7020,1.0}, // maroon1 (414)
3611 {0.5804,0.5804,0.5804,1.0}, // grey58 (415)
3612 {1.0000,0.9216,0.8039,1.0}, // BlanchedAlmond (416)
3613 {0.9333,0.9137,0.9137,1.0}, // snow2 (417)
3614 {0.9686,0.9686,0.9686,1.0}, // grey97 (418)
3615 {0.0000,0.8980,0.9333,1.0}, // turquoise2 (419)
3616 {1.0000,0.0000,1.0000,1.0}, // magenta1 (420)
3617 {1.0000,0.8706,0.6784,1.0}, // NavajoWhite1 (421)
3618 {0.1529,0.2510,0.5451,1.0}, // RoyalBlue4 (422)
3619 {0.2118,0.3922,0.5451,1.0}, // SteelBlue4 (423)
3620 {0.4314,0.4824,0.5451,1.0}, // LightSteelBlue4 (424)
3621 {0.9333,0.7725,0.5686,1.0}, // burlywood2 (425)
3622 {0.7255,0.8275,0.9333,1.0}, // SlateGray2 (426)
3623 {0.0000,0.8039,0.8039,1.0}, // cyan3 (427)
3624 {0.6824,0.9333,0.9333,1.0}, // PaleTurquoise2 (428)
3625 {0.9333,0.8627,0.5098,1.0}, // LightGoldenrod2 (429)
3626 {0.6314,0.6314,0.6314,1.0}, // grey63 (430)
3627 {0.8039,0.3333,0.3333,1.0}, // IndianRed3 (431)
3628 {0.9333,0.8353,0.7176,1.0}, // bisque2 (432)
3629 {0.4235,0.6510,0.8039,1.0}, // SkyBlue3 (433)
3630 {0.8784,0.4000,1.0000,1.0}, // MediumOrchid1 (434)
3631 {1.0000,0.7255,0.0588,1.0}, // DarkGoldenrod1 (435)
3632 {0.4118,0.3490,0.8039,1.0}, // SlateBlue3 (436)
3633 {0.0000,0.8078,0.8196,1.0}, // DarkTurquoise (437)
3634 {0.7804,0.7804,0.7804,1.0}, // grey78 (438)
3635 {0.5451,0.5137,0.4706,1.0}, // AntiqueWhite4 (439)
3636 {1.0000,0.8824,1.0000,1.0}, // thistle1 (440)
3637 {0.5451,0.1451,0.0000,1.0}, // OrangeRed4 (441)
3638 {0.9333,0.9333,0.0000,1.0}, // yellow2 (442)
3639 {0.4824,0.4078,0.9333,1.0}, // MediumSlateBlue (443)
3640 {0.8784,0.8784,0.8784,1.0}, // grey88 (444)
3641 {1.0000,0.8941,0.8824,1.0}, // MistyRose1 (445)
3642 {0.9333,0.9098,0.6667,1.0}, // PaleGoldenrod (446)
3643 {0.8039,0.7451,0.4392,1.0}, // LightGoldenrod3 (447)
3644 {0.8314,0.8314,0.8314,1.0}, // grey83 (448)
3645 {0.7765,0.8863,1.0000,1.0}, // SlateGray1 (449)
3646 {0.0980,0.0980,0.4392,1.0}, // MidnightBlue (450)
3647 {0.8039,0.6078,0.6078,1.0}, // RosyBrown3 (451)
3648 {1.0000,0.8431,0.0000,1.0}, // gold1 (452)
3649 {1.0000,0.7333,1.0000,1.0}, // plum1 (453)
3650 {0.2902,0.2902,0.2902,1.0}, // grey29 (454)
3651 {0.7059,0.9333,0.7059,1.0}, // DarkSeaGreen2 (455)
3652 {0.1412,0.1412,0.1412,1.0}, // grey14 (456)
3653 {0.8039,0.2157,0.0000,1.0}, // OrangeRed3 (457)
3654 {0.8039,0.3098,0.2235,1.0}, // tomato3 (458)
3655 {0.0000,0.8039,0.0000,1.0}, // green3 (459)
3656 {0.8039,0.5843,0.0471,1.0}, // DarkGoldenrod3 (460)
3657 {0.7373,0.9333,0.4078,1.0}, // DarkOliveGreen2 (461)
3658 {0.8549,0.4392,0.8392,1.0}, // orchid (462)
3659 {0.6902,0.1882,0.3765,1.0}, // maroon (463)
3660 {0.5451,0.5373,0.4392,1.0}, // LemonChiffon4 (464)
3661 {0.7059,0.3216,0.8039,1.0}, // MediumOrchid3 (465)
3662 {1.0000,0.9804,0.9412,1.0}, // FloralWhite (466)
3663 {0.5373,0.4078,0.8039,1.0}, // MediumPurple3 (467)
3664 {0.6039,0.1961,0.8039,1.0}, // DarkOrchid3 (468)
3665 {0.9216,0.9216,0.9216,1.0}, // grey92 (469)
3666 {0.7373,0.8235,0.9333,1.0}, // LightSteelBlue2 (470)
3667 {0.6000,0.1961,0.8000,1.0}, // DarkOrchid (471)
3668 {0.9137,0.5882,0.4784,1.0}, // DarkSalmon (472)
3669 {0.0000,0.5451,0.5451,1.0}, // DarkCyan (473)
3670 {0.2549,0.4118,0.8824,1.0}, // RoyalBlue (474)
3671 {0.8039,0.0627,0.4627,1.0}, // DeepPink3 (475)
3672 {0.5529,0.7137,0.8039,1.0}, // LightSkyBlue3 (476)
3673 {0.9333,0.5843,0.4471,1.0}, // LightSalmon2 (477)
3674 {0.7216,0.7216,0.7216,1.0}, // grey72 (478)
3675 {0.3020,0.3020,0.3020,1.0}, // grey30 (479)
3676 {1.0000,0.9725,0.8627,1.0}, // cornsilk1 (480)
3677 {0.8039,0.7882,0.6471,1.0}, // LemonChiffon3 (481)
3678 {0.3216,0.5451,0.5451,1.0}, // DarkSlateGray4 (482)
3679 {0.6627,0.6627,0.6627,1.0}, // DarkGray (483)
3680 {0.7804,0.0824,0.5216,1.0}, // MediumVioletRed (484)
3681 {0.7882,0.7882,0.7882,1.0}, // grey79 (485)
3682 {0.1804,0.1804,0.1804,1.0}, // grey18 (486)
3683 {0.3059,0.9333,0.5804,1.0}, // SeaGreen2 (487)
3684 {0.5451,0.5373,0.5373,1.0}, // snow4 (488)
3685 {0.4078,0.5137,0.5451,1.0}, // LightBlue4 (489)
3686 {0.8039,0.0000,0.8039,1.0}, // magenta3 (490)
3687 {1.0000,0.9373,0.8353,1.0}, // PapayaWhip (491)
3688 {0.4000,0.4000,0.4000,1.0}, // grey40 (492)
3689 {0.2627,0.4314,0.9333,1.0}, // RoyalBlue2 (493)
3690 {0.2510,0.2510,0.2510,1.0}, // grey25 (494)
3691 {0.0392,0.0392,0.0392,1.0}, // grey4 (495)
3692 {0.9333,0.0000,0.0000,1.0}, // red2 (496)
3693 {0.8039,0.7020,0.5451,1.0}, // NavajoWhite3 (497)
3694 {0.5961,0.9608,1.0000,1.0}, // CadetBlue1 (498)
3695 {0.3412,0.3412,0.3412,1.0}, // grey34 (499)
3696 {0.6000,0.6000,0.6000,1.0}, // grey60 (500)
3697 {0.8039,0.8039,0.7059,1.0}, // LightYellow3 (501)
3698 {0.5176,0.4392,1.0000,1.0} // LightSlateBlue (502)
3699 };
3700 #endif
3701
3702
