applications/gnome-control-center
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
gnome-control-center/capplets/screensaver/screensaver-prefs-dialog.c
Bradford Hovinen (Gdict maintainer) 2830dc67b3 Added new screensaver properties capplet
2000-07-31 20:06:12 +00:00

953 lines
26 KiB
C
Raw Blame History

/* -*- mode: c; style: linux -*- */
/* screensaver-prefs-dialog.c
* Copyright (C) 2000 Helix Code, Inc.
*
* Written by Bradford Hovinen <hovinen@helixcode.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <gnome.h>
#include <parser.h>
#include <sys/stat.h>
#include <glade/glade.h>
#include "screensaver-prefs-dialog.h"
#include "preferences.h"
#include "expr.h"
#include "preview.h"
struct _cli_argument_t
{
char *argument;
char *value;
};
typedef struct _cli_argument_t cli_argument_t;
enum {
OK_CLICKED_SIGNAL,
DEMO_SIGNAL,
LAST_SIGNAL
};
static gint screensaver_prefs_dialog_signals[LAST_SIGNAL] = { 0 };
static void screensaver_prefs_dialog_init (ScreensaverPrefsDialog *dialog);
static void screensaver_prefs_dialog_class_init (ScreensaverPrefsDialogClass *dialog);
static void set_widgets_sensitive (GladeXML *prop_data,
gchar *widgets_str,
gboolean s);
static void activate_option_cb (GtkWidget *widget);
static void toggle_check_cb (GtkWidget *widget,
xmlNodePtr node);
static gchar *write_boolean (xmlNodePtr arg_def,
GladeXML *prop_data);
static gchar *write_number (xmlNodePtr arg_def,
GladeXML *prop_data);
static gchar *write_select (xmlNodePtr arg_def,
GladeXML *prop_data);
static gchar *write_command_line (gchar *name,
xmlNodePtr arg_def,
GladeXML *prop_data);
static GScanner *read_command_line (char *command_line);
static xmlNodePtr get_argument_data (Screensaver *saver);
static GladeXML *get_screensaver_widget (Screensaver *saver,
xmlNodePtr argument_data);
static gint arg_is_set (xmlNodePtr argument_data,
GScanner *cli_db);
static void read_boolean (GladeXML *widget_data,
xmlNodePtr argument_data,
GScanner *cli_db);
static void read_number (GladeXML *widget_data,
xmlNodePtr argument_data,
GScanner *cli_db);
static void read_select (GladeXML *widget_data,
xmlNodePtr argument_data,
GScanner *cli_db);
static void place_screensaver_properties (ScreensaverPrefsDialog *dialog);
static gboolean arg_mapping_exists (Screensaver *saver);
static void store_cli (ScreensaverPrefsDialog *dialog);
static GtkWidget *get_basic_screensaver_widget (ScreensaverPrefsDialog *dialog,
Screensaver *saver);
static void demo_cb (GtkWidget *widget,
ScreensaverPrefsDialog *dialog);
static void help_cb (GtkWidget *widget,
ScreensaverPrefsDialog *dialog);
static void screensaver_prop_ok_cb (GtkWidget *widget,
ScreensaverPrefsDialog *dialog);
static void screensaver_prop_cancel_cb (GtkWidget *widget,
ScreensaverPrefsDialog *dialog);
guint
screensaver_prefs_dialog_get_type (void)
{
static guint screensaver_prefs_dialog_type = 0;
if (!screensaver_prefs_dialog_type) {
GtkTypeInfo screensaver_prefs_dialog_info = {
"ScreensaverPrefsDialog",
sizeof (ScreensaverPrefsDialog),
sizeof (ScreensaverPrefsDialogClass),
(GtkClassInitFunc) screensaver_prefs_dialog_class_init,
(GtkObjectInitFunc) screensaver_prefs_dialog_init,
(GtkArgSetFunc) NULL,
(GtkArgGetFunc) NULL
};
screensaver_prefs_dialog_type =
gtk_type_unique (gnome_dialog_get_type (),
&screensaver_prefs_dialog_info);
}
return screensaver_prefs_dialog_type;
}
static void
screensaver_prefs_dialog_init (ScreensaverPrefsDialog *dialog)
{
GtkWidget *global_vbox, *vbox, *hbox, *frame, *label;
gtk_window_set_policy (GTK_WINDOW (dialog), FALSE, FALSE, FALSE);
global_vbox = GNOME_DIALOG (dialog)->vbox;
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (global_vbox), hbox, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
label = gtk_label_new (_("Name:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
dialog->name_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), dialog->name_entry, TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (global_vbox), hbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
dialog->settings_dialog_frame = gtk_frame_new (_("Settings"));
gtk_box_pack_start (GTK_BOX (hbox), dialog->settings_dialog_frame,
TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
frame = gtk_frame_new (_("Description"));
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
dialog->description = gtk_label_new (_("label1"));
gtk_container_add (GTK_CONTAINER (frame), dialog->description);
gtk_label_set_justify (GTK_LABEL (dialog->description),
GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (dialog->description), TRUE);
gtk_misc_set_alignment (GTK_MISC (dialog->description), 0, 0);
gtk_misc_set_padding (GTK_MISC (dialog->description), 5, 5);
gnome_dialog_append_button (GNOME_DIALOG (dialog),
_("Demo"));
gnome_dialog_append_button (GNOME_DIALOG (dialog),
GNOME_STOCK_BUTTON_HELP);
gnome_dialog_append_button (GNOME_DIALOG (dialog),
GNOME_STOCK_BUTTON_OK);
gnome_dialog_append_button (GNOME_DIALOG (dialog),
GNOME_STOCK_BUTTON_CANCEL);
gtk_widget_show_all (global_vbox);
}
static void
screensaver_prefs_dialog_class_init (ScreensaverPrefsDialogClass *class)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) class;
screensaver_prefs_dialog_signals[OK_CLICKED_SIGNAL] =
gtk_signal_new ("ok-clicked", GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET
(ScreensaverPrefsDialogClass, ok_clicked),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
screensaver_prefs_dialog_signals[DEMO_SIGNAL] =
gtk_signal_new ("demo", GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET
(ScreensaverPrefsDialogClass, demo),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class,
screensaver_prefs_dialog_signals,
LAST_SIGNAL);
class->ok_clicked = NULL;
}
GtkWidget *
screensaver_prefs_dialog_new (Screensaver *saver)
{
GtkWidget *widget;
ScreensaverPrefsDialog *dialog;
char *title;
widget = gtk_type_new (screensaver_prefs_dialog_get_type ());
dialog = SCREENSAVER_PREFS_DIALOG (widget);
dialog->saver = saver;
title = g_strconcat (saver->label, " properties", NULL);
gtk_entry_set_text (GTK_ENTRY (dialog->name_entry),
saver->label);
if (arg_mapping_exists (saver)) {
dialog->cli_args_db =
read_command_line (saver->command_line);
dialog->argument_data = get_argument_data (saver);
dialog->prefs_widget_data =
get_screensaver_widget (saver,
dialog->argument_data);
} else {
dialog->basic_widget =
get_basic_screensaver_widget (dialog, saver);
}
gtk_window_set_title (GTK_WINDOW (dialog), title);
gnome_dialog_button_connect (GNOME_DIALOG (dialog), 0,
demo_cb, dialog);
gnome_dialog_button_connect (GNOME_DIALOG (dialog), 1,
help_cb, dialog);
gnome_dialog_button_connect (GNOME_DIALOG (dialog), 2,
screensaver_prop_ok_cb, dialog);
gnome_dialog_button_connect (GNOME_DIALOG (dialog), 3,
screensaver_prop_cancel_cb, dialog);
if (dialog->basic_widget)
gtk_container_add (GTK_CONTAINER
(dialog->settings_dialog_frame),
dialog->basic_widget);
else if (dialog->prefs_widget_data)
gtk_container_add (GTK_CONTAINER
(dialog->settings_dialog_frame),
glade_xml_get_widget
(dialog->prefs_widget_data,
"widget"));
gtk_label_set_text (GTK_LABEL (dialog->description),
screensaver_get_desc (saver));
if (dialog->argument_data)
place_screensaver_properties (dialog);
return widget;
}
/*****************************************************************************/
/* Enabling/disabling widgets based on options selected */
/*****************************************************************************/
/* set_widgets_sensitive
*
* Given a string of comma-separated widget names, finds the widgets
* in the given Glade XML definition and enables or disables them,
* based on the value of s
*/
static void
set_widgets_sensitive (GladeXML *prop_data, gchar *widgets_str, gboolean s)
{
char **widgets;
int i;
GtkWidget *widget;
if (!widgets_str) return;
widgets = g_strsplit (widgets_str, ",", -1);
for (i = 0; widgets[i]; i++) {
widget = glade_xml_get_widget (prop_data, widgets[i]);
if (widget) gtk_widget_set_sensitive (widget, s);
}
g_strfreev (widgets);
}
/* activate_option_cb
*
* Callback invoked when an option on an option menu is selected. The
* callback scans the xml node corresponding with that option to see
* what widgets are enabled by selecting that option and uses
* set_widgets_sensitive to enable them. Iterates through all other
* XML nodes and disables those widgets enabled by other nodes.
*/
static void
activate_option_cb (GtkWidget *widget)
{
GladeXML *prop_data;
xmlNodePtr argument_data, option_def, node;
prop_data = gtk_object_get_data (GTK_OBJECT (widget),
"prop_data");
argument_data = gtk_object_get_data (GTK_OBJECT (widget),
"argument_data");
option_def = gtk_object_get_data (GTK_OBJECT (widget),
"option_def");
node = argument_data->childs;
while (node) {
if (node != option_def)
set_widgets_sensitive (prop_data,
xmlGetProp (node, "enable"),
FALSE);
node = node->next;
}
set_widgets_sensitive (prop_data,
xmlGetProp (option_def, "enable"), TRUE);
}
/* toggle_check_cb
*
* Callback invoked when a check button is toggled. Works in a manner
* analagous to select_option_cb and deselect_option_cb above.
*/
static void
toggle_check_cb (GtkWidget *widget, xmlNodePtr node)
{
GladeXML *prop_data;
gboolean set;
prop_data = gtk_object_get_data (GTK_OBJECT (widget),
"prop_data");
set = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
set_widgets_sensitive (prop_data,
xmlGetProp (node, "enable"),
set);
}
/*****************************************************************************/
/* Writing out command lines */
/*****************************************************************************/
static gchar *
write_boolean (xmlNodePtr argument_data, GladeXML *prop_data)
{
char *widget_name;
GtkWidget *widget;
widget_name = g_strconcat (xmlGetProp (argument_data, "id"),
"_widget", NULL);
widget = glade_xml_get_widget (prop_data, widget_name);
g_free (widget_name);
if (!widget || !GTK_WIDGET_IS_SENSITIVE (widget)) return NULL;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
return xmlGetProp (argument_data, "arg-set");
else
return NULL;
}
static gchar *
write_number (xmlNodePtr argument_data, GladeXML *prop_data)
{
char *widget_name;
GtkWidget *widget;
GtkAdjustment *adjustment = NULL;
gfloat value = 0.0;
gchar *to_cli_expr;
widget_name = g_strconcat (xmlGetProp (argument_data, "id"),
"_widget", NULL);
widget = glade_xml_get_widget (prop_data, widget_name);
g_free (widget_name);
if (!widget || !GTK_WIDGET_IS_SENSITIVE (widget)) return NULL;
if (GTK_IS_RANGE (widget))
adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
else if (GTK_IS_SPIN_BUTTON (widget))
adjustment = gtk_spin_button_get_adjustment
(GTK_SPIN_BUTTON (widget));
if (adjustment)
value = adjustment->value;
to_cli_expr = xmlGetProp (argument_data, "to-cli-conv");
if (to_cli_expr)
value = parse_expr (to_cli_expr, value);
return g_strdup_printf (xmlGetProp (argument_data, "arg"), (int) value);
}
/* Note to readers: *please* ignore the following function, for the
* sake of your own mental health and my reputation as a sane
* coder. Just accept that it returns a string containing the CLI
* arguments corresponding with the selected option of an option
* menu. *sigh* I really must ask someone if there's a better way to
* do this...
*/
static gchar *
write_select (xmlNodePtr argument_data, GladeXML *prop_data)
{
xmlNodePtr node;
int i = 0;
GtkWidget *widget, *menu, *active;
char *widget_name;
GList *menu_item;
node = argument_data->childs;
widget_name = g_strconcat (xmlGetProp (argument_data, "id"),
"_widget", NULL);
widget = glade_xml_get_widget (prop_data, widget_name);
if (!widget || !GTK_WIDGET_IS_SENSITIVE (widget)) return NULL;
menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (widget));
menu_item = GTK_MENU_SHELL (menu)->children;
active = gtk_menu_get_active (GTK_MENU (menu));
while (node && menu_item) {
if (active == menu_item->data &&
!xmlGetProp (node, "no-output"))
return xmlGetProp (node, "arg-set");
node = node->next; menu_item = menu_item->next; i++;
}
return NULL;
}
/* write_command_line
*
* Scan through XML nodes in the argument definition file and write
* out the parameter corresponding to each node in turn.
*/
static gchar *
write_command_line (gchar *name, xmlNodePtr argument_data, GladeXML *prop_data)
{
GString *line;
xmlNodePtr node;
gchar *arg, *ret;
line = g_string_new (name);
node = argument_data->childs;
for (node = argument_data->childs; node; node = node->next) {
if (xmlGetProp (node, "no-output"))
continue;
if (!strcmp (node->name, "boolean"))
arg = write_boolean (node, prop_data);
else if (!strcmp (node->name, "number"))
arg = write_number (node, prop_data);
else if (!strcmp (node->name, "select"))
arg = write_select (node, prop_data);
else if (!strcmp (node->name, "command"))
arg = xmlGetProp (node, "arg");
else
arg = NULL;
if (arg) {
g_string_append (line, " ");
g_string_append (line, arg);
}
}
ret = line->str;
g_string_free (line, FALSE);
return ret;
}
/*****************************************************************************/
/* Reading the command line */
/*****************************************************************************/
static GScanner *
read_command_line (char *command_line)
{
char **args;
int i;
GScanner *cli_db;
static GScannerConfig config;
char *arg, *value;
config.cset_skip_characters = " \t\n";
config.cset_identifier_first = "abcdefghijklmnopqrstuvwxyz";
config.cset_identifier_nth = "abcdefghijklmnopqrstuvwxyz_";
config.scan_symbols = TRUE;
config.scan_identifier = TRUE;
cli_db = g_scanner_new (&config);
g_scanner_set_scope (cli_db, 0);
args = g_strsplit (command_line, " ", -1);
g_scanner_scope_add_symbol (cli_db, 0, "and", SYMBOL_AND);
g_scanner_scope_add_symbol (cli_db, 0, "or", SYMBOL_OR);
g_scanner_scope_add_symbol (cli_db, 0, "not", SYMBOL_NOT);
for (i = 0; args[i]; i++) {
if (args[i][0] == '-') {
arg = g_strdup (args[i] + 1);
if (args[i + 1] && args[i + 1][0] != '-') {
value = g_strdup (args[i + 1]);
i++;
} else {
value = (char *) 1;
}
g_scanner_scope_add_symbol (cli_db, 0, arg, value);
}
}
g_strfreev (args);
return cli_db;
}
/*****************************************************************************/
/* Getting the argument definition data */
/*****************************************************************************/
static xmlNodePtr
get_argument_data (Screensaver *saver)
{
xmlDocPtr doc;
xmlNodePtr root_node, node;
gchar *name;
doc = xmlParseFile (SSPROP_DATADIR "/hacks.xml");
root_node = xmlDocGetRootElement (doc);
g_assert (root_node != NULL);
node = root_node->childs;
while (node) {
name = xmlGetProp (node, "name");
if (!strcmp (name, saver->name)) break;
node = node->next;
}
return node;
}
/*****************************************************************************/
/* Creating the dialog proper */
/*****************************************************************************/
static GladeXML *
get_screensaver_widget (Screensaver *saver,
xmlNodePtr argument_data)
{
GladeXML *screensaver_prop_data;
gchar *file_name;
file_name = g_strconcat (SSPROP_DATADIR "/",
saver->name, "-settings.glade", NULL);
screensaver_prop_data = glade_xml_new (file_name, "widget");
g_free (file_name);
return screensaver_prop_data;
}
/*****************************************************************************/
/* Setting dialog properties from the CLI */
/*****************************************************************************/
/* arg_is_set
*
* Determines if an argument or set of arguments specified by the
* argument definition entry is set on a command line. Returns -1 if
* the argument is definitely not set, 0 if it may be, and 1 if it
* definitely is.
*/
static gint
arg_is_set (xmlNodePtr argument_data, GScanner *cli_db)
{
char *test;
test = xmlGetProp (argument_data, "test");
if (test) {
return parse_sentence (test, cli_db) ? 1 : -1;
} else {
return 0;
}
}
static void
read_boolean (GladeXML *widget_data, xmlNodePtr argument_data,
GScanner *cli_db)
{
char *widget_name;
GtkWidget *widget;
gint found;
found = arg_is_set (argument_data, cli_db);
widget_name = g_strconcat (xmlGetProp (argument_data, "id"),
"_widget", NULL);
widget = glade_xml_get_widget (widget_data, widget_name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
found >= 0);
gtk_object_set_data (GTK_OBJECT (widget), "prop_data",
widget_data);
gtk_signal_connect (GTK_OBJECT (widget), "toggled",
GTK_SIGNAL_FUNC (toggle_check_cb),
argument_data);
if (found >= 0) {
set_widgets_sensitive (widget_data,
xmlGetProp (argument_data, "enable"),
TRUE);
} else {
set_widgets_sensitive (widget_data,
xmlGetProp (argument_data, "enable"),
FALSE);
}
}
static void
read_number (GladeXML *widget_data, xmlNodePtr argument_data,
GScanner *cli_db)
{
char *arg;
char *arg_line;
char **args;
char *widget_name;
char *from_cli_conv;
GtkWidget *widget;
GtkAdjustment *adjustment;
gfloat value;
arg_line = xmlGetProp (argument_data, "arg");
args = g_strsplit (arg_line, " ", -1);
arg = g_scanner_scope_lookup_symbol (cli_db, 0, args[0] + 1);
if (!arg) return;
widget_name = g_strconcat (xmlGetProp (argument_data, "id"),
"_widget", NULL);
widget = glade_xml_get_widget (widget_data, widget_name);
from_cli_conv = xmlGetProp (argument_data, "from-cli-conv");
if (from_cli_conv)
value = parse_expr (from_cli_conv, atof (arg));
else
value = atof (arg);
if (GTK_IS_RANGE (widget)) {
adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
gtk_adjustment_set_value (adjustment, value);
}
else if (GTK_IS_SPIN_BUTTON (widget)) {
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
}
g_strfreev (args);
}
static void
read_select (GladeXML *widget_data, xmlNodePtr argument_data,
GScanner *cli_db)
{
xmlNodePtr node;
gchar *widget_name;
GtkWidget *widget, *menu;
GList *menu_item_node;
gint found, max_found = -1;
int set_idx = 0, i = 0;
widget_name = g_strconcat (xmlGetProp (argument_data, "id"),
"_widget", NULL);
widget = glade_xml_get_widget (widget_data, widget_name);
menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (widget));
node = argument_data->childs;
/* Get the index of the selected option */
while (node) {
found = arg_is_set (node, cli_db);
if (found > max_found) {
set_idx = i;
max_found = found;
}
node = node->next; i++;
}
/* Enable widgets enabled by selected option and disable
* widgets enabled by other options; connect select and
* deselect signals to do the same when an option is selected
*/
menu_item_node = GTK_MENU_SHELL (menu)->children;
node = argument_data->childs; i = 0;
while (node) {
if (i == set_idx) {
gtk_option_menu_set_history
(GTK_OPTION_MENU (widget), i);
set_widgets_sensitive (widget_data,
xmlGetProp (node, "enable"),
TRUE);
} else {
set_widgets_sensitive (widget_data,
xmlGetProp (node, "enable"),
FALSE);
}
gtk_object_set_data (GTK_OBJECT (menu_item_node->data),
"prop_data", widget_data);
gtk_object_set_data (GTK_OBJECT (menu_item_node->data),
"option_def", node);
gtk_object_set_data (GTK_OBJECT (menu_item_node->data),
"argument_data", argument_data);
gtk_signal_connect (GTK_OBJECT (menu_item_node->data),
"activate",
GTK_SIGNAL_FUNC (activate_option_cb),
NULL);
node = node->next; menu_item_node = menu_item_node->next; i++;
}
}
static void
place_screensaver_properties (ScreensaverPrefsDialog *dialog)
{
xmlNodePtr node;
node = dialog->argument_data->childs;
while (node) {
if (!strcmp (node->name, "boolean"))
read_boolean (dialog->prefs_widget_data, node,
dialog->cli_args_db);
else if (!strcmp (node->name, "number"))
read_number (dialog->prefs_widget_data, node,
dialog->cli_args_db);
else if (!strcmp (node->name, "select"))
read_select (dialog->prefs_widget_data, node,
dialog->cli_args_db);
node = node->next;
}
}
static gboolean
arg_mapping_exists (Screensaver *saver)
{
struct stat buf;
char *filename;
gboolean ret;
if (!saver->name) return FALSE;
filename = g_strconcat (SSPROP_DATADIR "/",
saver->name, "-settings.glade", NULL);
if (stat (filename, &buf))
ret = FALSE;
else
ret = TRUE;
g_free (filename);
return ret;
}
static void
store_cli (ScreensaverPrefsDialog *dialog)
{
char *str;
g_free (dialog->saver->command_line);
if (dialog->prefs_widget_data) {
dialog->saver->command_line =
write_command_line (dialog->saver->name,
dialog->argument_data,
dialog->prefs_widget_data);
} else {
dialog->saver->command_line =
g_strdup (gtk_entry_get_text
(GTK_ENTRY (dialog->cli_entry)));
str = gtk_entry_get_text
(GTK_ENTRY (GTK_COMBO
(dialog->visual_combo)->entry));
if (!strcmp (str, "Any")) {
dialog->saver->visual = NULL;
} else {
dialog->saver->visual = g_strdup (str);
g_strdown (dialog->saver->visual);
}
}
}
/*****************************************************************************/
/* Fallback when Glade definition not found */
/*****************************************************************************/
static GtkWidget *
get_basic_screensaver_widget (ScreensaverPrefsDialog *dialog,
Screensaver *saver)
{
GtkWidget *vbox, *label;
GList *node;
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
if (saver->name) {
label = gtk_label_new (_("Cannot find the data to configure this screensaver. Please edit the command line below."));
} else {
label = gtk_label_new (_("Please enter a command line below."));
}
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 5);
dialog->cli_entry = gtk_entry_new ();
if (saver->command_line) {
gtk_entry_set_text (GTK_ENTRY (dialog->cli_entry),
saver->command_line);
}
gtk_box_pack_start (GTK_BOX (vbox), dialog->cli_entry,
TRUE, FALSE, 5);
label = gtk_label_new (_("Visual:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 5);
dialog->visual_combo = gtk_combo_new ();
node = g_list_alloc ();
node->data = "Any";
g_list_append (node, "Best");
g_list_append (node, "Default");
g_list_append (node, "Default-N");
g_list_append (node, "GL");
g_list_append (node, "TrueColor");
g_list_append (node, "PseudoColor");
g_list_append (node, "StaticGray");
g_list_append (node, "GrayScale");
g_list_append (node, "DirectColor");
g_list_append (node, "Color");
g_list_append (node, "Gray");
g_list_append (node, "Mono");
gtk_combo_set_popdown_strings (GTK_COMBO (dialog->visual_combo), node);
if (saver->visual)
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO
(dialog->visual_combo)->entry),
saver->visual);
else
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO
(dialog->visual_combo)->entry),
"Any");
gtk_box_pack_start (GTK_BOX (vbox), dialog->visual_combo,
TRUE, FALSE, 5);
return vbox;
}
/*****************************************************************************/
/* Global dialog callbacks */
/*****************************************************************************/
static void
demo_cb (GtkWidget *widget, ScreensaverPrefsDialog *dialog)
{
store_cli (dialog);
gtk_signal_emit (GTK_OBJECT (dialog),
screensaver_prefs_dialog_signals[DEMO_SIGNAL]);
show_demo (dialog->saver);
}
static void
help_cb (GtkWidget *widget, ScreensaverPrefsDialog *dialog)
{
GnomeHelpMenuEntry entry;
gchar *url;
if (!dialog->saver->name) return;
if (dialog->prefs_widget_data) {
entry.name = "screensaver-properties-capplet";
entry.path = g_strconcat (dialog->saver->name, ".html", NULL);
if (entry.path) {
gnome_help_display (NULL, &entry);
g_free (entry.path);
}
} else {
url = g_strconcat ("man:", dialog->saver->name, NULL);
gnome_url_show (url);
g_free (url);
}
}
static void
screensaver_prop_ok_cb (GtkWidget *widget, ScreensaverPrefsDialog *dialog)
{
store_cli (dialog);
g_free (dialog->saver->label);
dialog->saver->label =
g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->name_entry)));
gtk_signal_emit (GTK_OBJECT (dialog),
screensaver_prefs_dialog_signals[OK_CLICKED_SIGNAL]);
gnome_dialog_close (GNOME_DIALOG (dialog));
}
static void
screensaver_prop_cancel_cb (GtkWidget *widget, ScreensaverPrefsDialog *dialog)
{
gnome_dialog_close (GNOME_DIALOG (dialog));
}
Reference in a new issue View git blame Copy permalink