static struct gopt *gopt_new_int_range(struct gopt_job_view *gjv,
struct fio_option *o, unsigned int **ip,
unsigned int idx)
{
struct gopt_range *r;
GtkWidget *label;
guint interval;
unsigned int defvals[GOPT_RANGE_SPIN];
gint maxval;
int i;
r = calloc(1, sizeof(*r));
r->gopt.box = gtk_hbox_new(FALSE, 3);
gopt_mark_index(gjv, &r->gopt, idx, GOPT_RANGE);
if (!o->lname)
label = gtk_label_new(o->name);
else
label = gtk_label_new(o->lname);
maxval = o->maxval;
if (!maxval)
maxval = INT_MAX;
memset(defvals, 0, sizeof(defvals));
if (o->def) {
long long val;
check_str_bytes(o->def, &val, o);
for (i = 0; i < GOPT_RANGE_SPIN; i++)
defvals[i] = val;
}
interval = 1.0;
if (o->interval)
interval = o->interval;
for (i = 0; i < GOPT_RANGE_SPIN; i++) {
r->spins[i] = gtk_spin_button_new_with_range(o->minval, maxval, interval);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(r->spins[i]), GTK_UPDATE_IF_VALID);
gtk_box_pack_start(GTK_BOX(r->gopt.box), r->spins[i], FALSE, FALSE, 0);
}
if (ip)
gopt_int_range_set_val(r, *ip);
else
gopt_int_range_set_val(r, defvals);
for (i = 0; i < GOPT_RANGE_SPIN; i++)
g_signal_connect(G_OBJECT(r->spins[i]), "value-changed", G_CALLBACK(range_value_changed), r);
gtk_box_pack_start(GTK_BOX(r->gopt.box), label, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(r->gopt.box), "destroy", G_CALLBACK(gopt_range_destroy), r);
return &r->gopt;
}
/* Changes the way a spin button refreshes and updates itself. */
int
clip_GTK_SPINBUTTONSETUPDATEPOLICY(ClipMachine * ClipMachineMemory)
{
C_widget *cspb = _fetch_cw_arg(ClipMachineMemory);
GtkSpinButtonUpdatePolicy policy = _clip_parni(ClipMachineMemory, 2);
CHECKCWID(cspb, GTK_IS_SPIN_BUTTON);
CHECKOPT(2, NUMERIC_type_of_ClipVarType);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(cspb->widget), policy);
return 0;
err:
return 1;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_spin_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gfloat climb_rate;
gint digits, policy_value = GTK_UPDATE_ALWAYS, i;
gchar *policy;
gboolean numeric, snap, wrap;
GtkAdjustment *adj;
climb_rate = gb_widget_input_float (data, ClimbRate);
/* No set function for this */
if (data->apply)
GTK_SPIN_BUTTON (widget)->climb_rate = climb_rate;
digits = gb_widget_input_int (data, Digits);
if (data->apply)
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (widget), digits);
numeric = gb_widget_input_bool (data, Numeric);
if (data->apply)
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (widget), numeric);
snap = gb_widget_input_bool (data, Snap);
if (data->apply)
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (widget), snap);
policy = gb_widget_input_choice (data, Policy);
for (i = 0; i < sizeof (GbPolicyValues) / sizeof (GbPolicyValues[0]); i++)
{
if (!strcmp (policy, GbPolicyChoices[i])
|| !strcmp (policy, GbPolicySymbols[i]))
{
policy_value = GbPolicyValues[i];
break;
}
}
if (data->apply)
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (widget), policy_value);
wrap = gb_widget_input_bool (data, Wrap);
if (data->apply)
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), wrap);
adj = GTK_SPIN_BUTTON (widget)->adjustment;
if (gb_widget_input_adjustment (data, Values, adj, "adjustment"))
{
gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed");
}
}
static struct gopt_int *__gopt_new_int(struct gopt_job_view *gjv,
struct fio_option *o,
unsigned long long *p, unsigned int idx)
{
unsigned long long defval;
struct gopt_int *i;
guint maxval, interval;
GtkWidget *label;
i = calloc(1, sizeof(*i));
i->gopt.box = gtk_hbox_new(FALSE, 3);
if (!o->lname)
label = gtk_label_new(o->name);
else
label = gtk_label_new(o->lname);
maxval = o->maxval;
if (!maxval)
maxval = UINT_MAX;
defval = 0;
if (p)
defval = *p;
else if (o->def) {
long long val;
check_str_bytes(o->def, &val, o);
defval = val;
}
interval = 1.0;
if (o->interval)
interval = o->interval;
i->spin = gtk_spin_button_new_with_range(o->minval, maxval, interval);
gopt_mark_index(gjv, &i->gopt, idx, GOPT_INT);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(i->spin), GTK_UPDATE_IF_VALID);
if (p)
gopt_int_set_val(i, *p);
else
gopt_int_set_val(i, defval);
i->gopt.sig_handler = g_signal_connect(G_OBJECT(i->spin), "value-changed", G_CALLBACK(gopt_int_changed), i);
g_signal_connect(G_OBJECT(i->spin), "destroy", G_CALLBACK(gopt_int_destroy), i);
gtk_box_pack_start(GTK_BOX(i->gopt.box), i->spin, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(i->gopt.box), label, FALSE, FALSE, 0);
return i;
}
static GtkWidget *create_spinbutton(GtkWidget *vbox, const char *name, double min, double max, double incr)
{
GtkWidget *frame, *hbox, *button;
frame = gtk_frame_new(name);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 3);
gtk_container_add(GTK_CONTAINER(frame), hbox);
button = gtk_spin_button_new_with_range(min, max, incr);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, FALSE, 0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
return button;
}
static struct gopt *gopt_new_str_val(struct gopt_job_view *gjv,
struct fio_option *o,
unsigned long long *p, unsigned int idx)
{
struct gopt_str_val *g;
const gchar *postfix[] = { "B", "KB", "MB", "GB", "PB", "TB", "" };
GtkWidget *label;
int i;
g = calloc(1, sizeof(*g));
g->gopt.box = gtk_hbox_new(FALSE, 3);
if (!o->lname)
label = gtk_label_new(o->name);
else
label = gtk_label_new(o->lname);
gopt_mark_index(gjv, &g->gopt, idx, GOPT_STR_VAL);
g->spin = gtk_spin_button_new_with_range(0.0, 1023.0, 1.0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(g->spin), GTK_UPDATE_IF_VALID);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->spin), 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(g->spin), 1);
gtk_box_pack_start(GTK_BOX(g->gopt.box), g->spin, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(g->spin), "wrapped", G_CALLBACK(gopt_str_val_spin_wrapped), g);
g_signal_connect(G_OBJECT(g->spin), "changed", G_CALLBACK(gopt_str_val_changed), g);
g->combo = gtk_combo_box_text_new();
i = 0;
while (strlen(postfix[i])) {
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(g->combo), postfix[i]);
i++;
}
g->maxindex = i - 1;
gtk_combo_box_set_active(GTK_COMBO_BOX(g->combo), 0);
gtk_box_pack_start(GTK_BOX(g->gopt.box), g->combo, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(g->gopt.box), label, FALSE, FALSE, 3);
if (p)
gopt_str_val_set_val(g, *p);
g_signal_connect(G_OBJECT(g->combo), "changed", G_CALLBACK(gopt_str_val_changed), g);
g_signal_connect(G_OBJECT(g->gopt.box), "destroy", G_CALLBACK(gopt_str_val_destroy), g);
return &g->gopt;
}
/**
* To understand how to setup this function you must understand:
*
* gimp_table_attach_aligned
*
* To understand that you will find information in only one spot:
*
* c:\gimp-2.6.11\libgimpwidgets\gimpwidgets.c on or about line number 1118
* which states:
*
**
* gimp_table_attach_aligned:
* @table: The #GtkTable the widgets will be attached to.
* @column: The column to start with.
* @row: The row to attach the widgets.
* @label_text: The text for the #GtkLabel which will be attached left of
* the widget.
* @xalign: The horizontal alignment of the #GtkLabel.
* @yalign: The vertival alignment of the #GtkLabel.
* @widget: The #GtkWidget to attach right of the label.
* @colspan: The number of columns the widget will use.
* @left_align: %TRUE if the widget should be left-aligned.
*
* Note that the @label_text can be %NULL and that the widget will be
* attached starting at (@column + 1) in this case, too.
*
* Returns: The created #GtkLabel.
**
* GtkWidget *
* gimp_table_attach_aligned (GtkTable *table,
* gint column,
* gint row,
* const gchar *label_text,
* gfloat xalign,
* gfloat yalign,
* GtkWidget *widget,
* gint colspan,
* gboolean left_align);
*
*/
static GtkWidget *CreateInteger255SpinButton(GtkWidget *table, gint row, GCallback *function, const gchar *szName, gint32 nVal, gint32 allow_neg)
{
GtkObject *adj = NULL;
GtkWidget *spin = NULL;
if (allow_neg)
{
adj = gtk_adjustment_new((gdouble)nVal, -1000, 1000, 1, 10, 0);
}
else
{
adj = gtk_adjustment_new((gdouble)nVal, 0, 1000, 1, 10, 0);
}
spin = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1, 0);
gtk_widget_show(spin);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_IF_VALID);
gtk_signal_connect(GTK_OBJECT(spin), "value_changed",
GTK_SIGNAL_FUNC(function), 0);
gimp_table_attach_aligned(GTK_TABLE(table), 0, row, szName, 0, 0.5,
spin, 1, 0);
return spin;
}
void ui_common_study_preferences_widgets(GtkWidget * packing_table,
gint table_row,
GtkWidget ** proi_width_spin,
GnomeCanvasItem ** proi_item,
#ifdef AMIDE_LIBGNOMECANVAS_AA
GtkWidget ** proi_transparency_spin,
#else
GtkWidget ** pline_style_menu,
GtkWidget ** pfill_roi_button,
#endif
GtkWidget ** playout_button1,
GtkWidget ** playout_button2,
GtkWidget ** ppanel_layout_button1,
GtkWidget ** ppanel_layout_button2,
GtkWidget ** ppanel_layout_button3,
GtkWidget ** pmaintain_size_button,
GtkWidget ** ptarget_size_spin) {
GtkWidget * label;
GtkObject * adjustment;
GtkWidget * roi_canvas;
GnomeCanvasPoints * roi_line_points;
GtkWidget * image;
GtkWidget * hseparator;
#ifndef AMIDE_LIBGNOMECANVAS_AA
GdkLineStyle i_line_style;
#endif
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Width (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MAX_ROI_WIDTH,1.0, 1.0, 0.0);
*proi_width_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*proi_width_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*proi_width_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *proi_width_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_width_spin);
/* a little canvas indicator thingie to show the user who the new preferences will look */
#ifdef AMIDE_LIBGNOMECANVAS_AA
roi_canvas = gnome_canvas_new_aa();
#else
roi_canvas = gnome_canvas_new();
#endif
gtk_widget_set_size_request(roi_canvas, 100, 100);
gnome_canvas_set_scroll_region(GNOME_CANVAS(roi_canvas), 0.0, 0.0, 100.0, 100.0);
gtk_table_attach(GTK_TABLE(packing_table), roi_canvas, 2,3,table_row,table_row+2,
GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(roi_canvas);
/* the box */
roi_line_points = gnome_canvas_points_new(5);
roi_line_points->coords[0] = 25.0; /* x1 */
roi_line_points->coords[1] = 25.0; /* y1 */
roi_line_points->coords[2] = 75.0; /* x2 */
roi_line_points->coords[3] = 25.0; /* y2 */
roi_line_points->coords[4] = 75.0; /* x3 */
roi_line_points->coords[5] = 75.0; /* y3 */
roi_line_points->coords[6] = 25.0; /* x4 */
roi_line_points->coords[7] = 75.0; /* y4 */
roi_line_points->coords[8] = 25.0; /* x4 */
roi_line_points->coords[9] = 25.0; /* y4 */
*proi_item = gnome_canvas_item_new(gnome_canvas_root(GNOME_CANVAS(roi_canvas)),
#ifdef AMIDE_LIBGNOMECANVAS_AA
gnome_canvas_polygon_get_type(),
#else
gnome_canvas_line_get_type(),
#endif
"points", roi_line_points,
NULL);
gnome_canvas_points_unref(roi_line_points);
table_row++;
#ifdef AMIDE_LIBGNOMECANVAS_AA
/* widget to change the transparency level */
/* only works for anti-aliased canvases */
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Transparency"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0, 1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*proi_transparency_spin = gtk_spin_button_new_with_range(0.0,1.0,AMITK_PREFERENCES_DEFAULT_CANVAS_ROI_TRANSPARENCY);
gtk_spin_button_set_increments(GTK_SPIN_BUTTON(*proi_transparency_spin),0.1,0.1);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_transparency_spin),FALSE);
gtk_table_attach(GTK_TABLE(packing_table), *proi_transparency_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_transparency_spin);
table_row++;
#else
/* widgets to change the roi's line style */
/* Anti-aliased canvas doesn't yet support this */
/* also need to remove #ifndef for relevant lines in amitk_canvas_object.c and other locations */
label = gtk_label_new(_("ROI Line Style:"));
gtk_table_attach(GTK_TABLE(packing_table), label, 0,1,
table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pline_style_menu = gtk_combo_box_new_text();
for (i_line_style=0; i_line_style<=GDK_LINE_DOUBLE_DASH; i_line_style++)
gtk_combo_box_append_text(GTK_COMBO_BOX(*pline_style_menu),
line_style_names[i_line_style]);
gtk_widget_set_size_request (*pline_style_menu, 125, -1);
gtk_table_attach(GTK_TABLE(packing_table), *pline_style_menu, 1,2,
table_row,table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pline_style_menu);
table_row++;
/* do we want to fill in isocontour roi's */
label = gtk_label_new(_("Draw Isocontours/Freehands Filled:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pfill_roi_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pfill_roi_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pfill_roi_button);
table_row++;
#endif
hseparator = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(packing_table), hseparator,
0, 3, table_row, table_row+1,
GTK_FILL, 0, X_PADDING, Y_PADDING);
table_row++;
gtk_widget_show(hseparator);
label = gtk_label_new(_("Canvas Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*playout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_layout_linear",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button1), "layout", GINT_TO_POINTER(AMITK_LAYOUT_LINEAR));
gtk_widget_show(*playout_button1);
*playout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*playout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*playout_button1)));
image = gtk_image_new_from_stock("amide_icon_layout_orthogonal",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button2, 2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button2), "layout", GINT_TO_POINTER(AMITK_LAYOUT_ORTHOGONAL));
gtk_widget_show(*playout_button2);
table_row++;
label = gtk_label_new(_("Multiple Canvases Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*ppanel_layout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_panels_mixed", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button1), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_MIXED));
gtk_widget_show(*ppanel_layout_button1);
*ppanel_layout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_x", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button2,
2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button2), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_X));
gtk_widget_show(*ppanel_layout_button2);
*ppanel_layout_button3 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button3),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_y", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button3), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button3,
3,4, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button3), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_Y));
gtk_widget_show(*ppanel_layout_button3);
table_row++;
/* do we want the size of the canvas to not resize */
label = gtk_label_new(_("Maintain view size constant:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pmaintain_size_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pmaintain_size_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pmaintain_size_button);
table_row++;
/* widgets to change the amount of empty space in the center of the target */
label = gtk_label_new(_("Target Empty Area (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MAX_TARGET_EMPTY_AREA, 1.0, 1.0, 0.0);
*ptarget_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*ptarget_size_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*ptarget_size_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *ptarget_size_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*ptarget_size_spin);
return;
}
/** \brief Create and initialise widgets for the refresh rates tab.
*
* The widgets must be preloaded with values from config. If a config value
* is NULL, sensible default values, eg. those from defaults.h should
* be laoded.
*/
GtkWidget *sat_pref_refresh_create (GKeyFile *cfg)
{
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *label;
gint val;
dirty = FALSE;
reset = FALSE;
/* create table */
table = gtk_table_new (6, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
/* data refresh */
label = gtk_label_new (_("Refresh data every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
dataspin = gtk_spin_button_new_with_range (100, 10000, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (dataspin), 1, 100);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (dataspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (dataspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_GLOBAL_SECTION,
MOD_CFG_TIMEOUT_KEY,
SAT_CFG_INT_MODULE_TIMEOUT);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_MODULE_TIMEOUT);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dataspin), val);
g_signal_connect (G_OBJECT (dataspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), dataspin, 1, 2, 0, 1,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[msec]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* separator */
gtk_table_attach (GTK_TABLE (table),
gtk_hseparator_new (),
0, 3, 1, 2,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* List View */
label = gtk_label_new (_("Refresh list view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL,
GTK_SHRINK,
0, 0);
listspin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (listspin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (listspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (listspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_LIST_SECTION,
MOD_CFG_LIST_REFRESH,
SAT_CFG_INT_LIST_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_LIST_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (listspin), val);
g_signal_connect (G_OBJECT (listspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), listspin, 1, 2, 2, 3,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* Map View */
label = gtk_label_new (_("Refresh map view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
GTK_FILL,
GTK_SHRINK,
0, 0);
mapspin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (mapspin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mapspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mapspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_MAP_SECTION,
MOD_CFG_MAP_REFRESH,
SAT_CFG_INT_MAP_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_MAP_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (mapspin), val);
g_signal_connect (G_OBJECT (mapspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), mapspin, 1, 2, 3, 4,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 3, 4,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* Polar View */
label = gtk_label_new (_("Refresh polar view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
GTK_FILL,
GTK_SHRINK,
0, 0);
polarspin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (polarspin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (polarspin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (polarspin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_POLAR_SECTION,
MOD_CFG_POLAR_REFRESH,
SAT_CFG_INT_POLAR_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_POLAR_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (polarspin), val);
g_signal_connect (G_OBJECT (polarspin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), polarspin, 1, 2, 4, 5,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 4, 5,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* Single-Sat View */
label = gtk_label_new (_("Refresh single-sat view every"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6,
GTK_FILL,
GTK_SHRINK,
0, 0);
singlespin = gtk_spin_button_new_with_range (1, 50, 1);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (singlespin), 1, 5);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (singlespin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (singlespin),
GTK_UPDATE_IF_VALID);
if (cfg != NULL) {
val = mod_cfg_get_int (cfg,
MOD_CFG_SINGLE_SAT_SECTION,
MOD_CFG_SINGLE_SAT_REFRESH,
SAT_CFG_INT_SINGLE_SAT_REFRESH);
}
else {
val = sat_cfg_get_int (SAT_CFG_INT_SINGLE_SAT_REFRESH);
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (singlespin), val);
g_signal_connect (G_OBJECT (singlespin), "value-changed",
G_CALLBACK (spin_changed_cb), NULL);
gtk_table_attach (GTK_TABLE (table), singlespin, 1, 2, 5, 6,
GTK_FILL,
GTK_SHRINK,
0, 0);
label = gtk_label_new (_("[cycle]"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 5, 6,
GTK_FILL | GTK_EXPAND,
GTK_SHRINK,
0, 0);
/* create vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 20);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
/* create RESET button */
create_reset_button (cfg, GTK_BOX (vbox));
return vbox;
}
int
Tetris::gameProperties(GtkAction *action, void *d)
{
GtkWidget *notebook;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *fvbox;
GtkObject *adj;
GtkWidget *controls_list;
Tetris *t = (Tetris*) d;
if (t->setupdialog) {
gtk_window_present (GTK_WINDOW(t->setupdialog));
return FALSE;
}
/* create the dialog */
t->setupdialog =
gtk_dialog_new_with_buttons(_("Gnometris Preferences"),
GTK_WINDOW (t->w),
(GtkDialogFlags)0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (t->setupdialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (t->setupdialog), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (t->setupdialog)->vbox), 2);
g_signal_connect (t->setupdialog, "close",
G_CALLBACK (setupdialogDestroy), d);
g_signal_connect (t->setupdialog, "response",
G_CALLBACK (setupdialogResponse), d);
notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(t->setupdialog)->vbox), notebook,
TRUE, TRUE, 0);
/* game page */
vbox = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
label = gtk_label_new (_("Game"));
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label);
frame = games_frame_new (_("Setup"));
table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
/* pre-filled rows */
label = gtk_label_new_with_mnemonic (_("_Number of pre-filled rows:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) GTK_FILL,
(GtkAttachOptions) 0,
0, 0);
adj = gtk_adjustment_new (t->line_fill_height, 0, LINES-1, 1, 5, 0);
t->fill_height_spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 10, 0);
gtk_spin_button_set_update_policy
(GTK_SPIN_BUTTON (t->fill_height_spinner), GTK_UPDATE_ALWAYS);
gtk_spin_button_set_snap_to_ticks
(GTK_SPIN_BUTTON (t->fill_height_spinner), TRUE);
g_signal_connect (t->fill_height_spinner, "value_changed",
G_CALLBACK (lineFillHeightChanged), t);
gtk_table_attach_defaults (GTK_TABLE (table), t->fill_height_spinner, 1, 2, 0, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), t->fill_height_spinner);
/* pre-filled rows density */
label = gtk_label_new_with_mnemonic (_("_Density of blocks in a pre-filled row:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) GTK_FILL,
(GtkAttachOptions) 0,
0, 0);
adj = gtk_adjustment_new (t->line_fill_prob, 0, 10, 1, 5, 0);
t->fill_prob_spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 10, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (t->fill_prob_spinner),
GTK_UPDATE_ALWAYS);
gtk_spin_button_set_snap_to_ticks
(GTK_SPIN_BUTTON (t->fill_prob_spinner), TRUE);
g_signal_connect (t->fill_prob_spinner, "value_changed",
G_CALLBACK (lineFillProbChanged), t);
gtk_table_attach_defaults (GTK_TABLE (table), t->fill_prob_spinner, 1, 2, 1, 2);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), t->fill_prob_spinner);
/* starting level */
label = gtk_label_new_with_mnemonic (_("_Starting level:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
(GtkAttachOptions) GTK_FILL,
(GtkAttachOptions) 0,
0, 0);
adj = gtk_adjustment_new (t->startingLevel, 1, 20, 1, 5, 0);
t->sentry = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 10.0, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (t->sentry),
GTK_UPDATE_ALWAYS);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (t->sentry), TRUE);
g_signal_connect (t->sentry, "value_changed",
G_CALLBACK (startingLevelChanged), t);
gtk_table_attach_defaults (GTK_TABLE (table), t->sentry, 1, 2, 2, 3);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), t->sentry);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_box_pack_start (GTK_BOX (vbox), frame,
FALSE, FALSE, 0);
frame = games_frame_new (_("Operation"));
fvbox = gtk_vbox_new (FALSE, 6);
/* sound */
t->sound_toggle =
gtk_check_button_new_with_mnemonic (_("_Enable sounds"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (t->sound_toggle),
games_sound_is_enabled ());
g_signal_connect (t->sound_toggle, "clicked",
G_CALLBACK (setSound), d);
gtk_box_pack_start (GTK_BOX (fvbox), t->sound_toggle, 0, 0, 0);
/* preview next block */
t->do_preview_toggle =
gtk_check_button_new_with_mnemonic (_("_Preview next block"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (t->do_preview_toggle),
do_preview);
g_signal_connect (t->do_preview_toggle, "clicked",
G_CALLBACK (setSelectionPreview), d);
gtk_box_pack_start (GTK_BOX (fvbox), t->do_preview_toggle, 0, 0, 0);
/* random blocks */
t->random_block_colors_toggle =
gtk_check_button_new_with_mnemonic (_("_Use random block colors"));
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (t->random_block_colors_toggle),
random_block_colors);
g_signal_connect (t->random_block_colors_toggle, "clicked",
G_CALLBACK (setSelectionBlocks), d);
gtk_box_pack_start (GTK_BOX (fvbox), t->random_block_colors_toggle,
0, 0, 0);
/* rotate counter clock wise */
t->rotate_counter_clock_wise_toggle =
gtk_check_button_new_with_mnemonic (_("_Rotate blocks counterclockwise"));
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (t->rotate_counter_clock_wise_toggle),
rotateCounterClockWise);
g_signal_connect (t->rotate_counter_clock_wise_toggle, "clicked",
G_CALLBACK (setRotateCounterClockWise), d);
gtk_box_pack_start (GTK_BOX (fvbox), t->rotate_counter_clock_wise_toggle,
0, 0, 0);
t->useTargetToggle = gtk_check_button_new_with_mnemonic (_("Show _where the block will land"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (t->useTargetToggle),
t->useTarget);
g_signal_connect (t->useTargetToggle, "clicked",
G_CALLBACK (setTarget), d);
gtk_box_pack_start (GTK_BOX (fvbox), t->useTargetToggle,
0, 0, 0);
gtk_container_add (GTK_CONTAINER (frame), fvbox);
gtk_box_pack_start (GTK_BOX (vbox), frame,
FALSE, FALSE, 0);
frame = games_frame_new (_("Theme"));
table = gtk_table_new (2, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
/* controls page */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
label = gtk_label_new (_("Controls"));
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label);
frame = games_frame_new (_("Keyboard Controls"));
gtk_container_add (GTK_CONTAINER (vbox), frame);
fvbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), fvbox);
controls_list = games_controls_list_new (KEY_CONTROLS_GROUP);
games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls_list),
KEY_MOVE_LEFT, _("Move left"), GDK_Left,
KEY_MOVE_RIGHT, _("Move right"), GDK_Right,
KEY_MOVE_DOWN, _("Move down"), GDK_Down,
KEY_MOVE_DROP, _("Drop"), GDK_Pause,
KEY_MOVE_ROTATE, _("Rotate"), GDK_Up,
KEY_MOVE_PAUSE, _("Pause"), GDK_space,
NULL);
gtk_box_pack_start (GTK_BOX (fvbox), controls_list, TRUE, TRUE, 0);
/* theme page */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
label = gtk_label_new (_("Theme"));
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label);
frame = games_frame_new (_("Block Style"));
gtk_container_add (GTK_CONTAINER (vbox), frame);
fvbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), fvbox);
GtkWidget *omenu = gtk_combo_box_new_text ();
const ThemeTableEntry *entry = ThemeTable;
while (entry->id) {
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), entry->name);
entry++;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), t->themeno);
g_signal_connect (omenu, "changed", G_CALLBACK (setSelection), t);
gtk_box_pack_start (GTK_BOX (fvbox), omenu, FALSE, FALSE, 0);
t->theme_preview = new Preview();
t->theme_preview->setTheme (t->themeno);
gtk_box_pack_start(GTK_BOX(fvbox), t->theme_preview->getWidget(), TRUE, TRUE, 0);
t->theme_preview->previewBlock(4, 0, 0);
gtk_widget_show_all (t->setupdialog);
gtk_action_set_sensitive(t->new_game_action, FALSE);
return TRUE;
}
/* Shows the preferences dialog on the given tab */
void show_preferences(gint tab) {
if(gtk_grab_get_current()) {
/* A window is already open, so we present it to the user */
GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
gtk_window_present((GtkWindow*)toplevel);
return;
}
/* Declare some variables */
GtkWidget *frame, *label,
*alignment, *hbox,
*vbox;
GtkObject *adjustment, *adjustment_small, *adjustment_statics;
GtkTreeViewColumn *tree_column;
/* Create the dialog */
GtkWidget* dialog = gtk_dialog_new_with_buttons(_("Preferences"), NULL,
(GTK_DIALOG_MODAL + GTK_DIALOG_NO_SEPARATOR),
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_icon((GtkWindow*)dialog, gtk_widget_render_icon(dialog, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, NULL));
gtk_window_set_resizable((GtkWindow*)dialog, FALSE);
/* Create notebook */
GtkWidget* notebook = gtk_notebook_new();
#if GTK_CHECK_VERSION (2,14,0)
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 2);
#else
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 2);
#endif
/* Build the settings page */
GtkWidget* page_settings = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_settings, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_settings, gtk_label_new(_("Settings")));
GtkWidget* vbox_settings = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_settings, vbox_settings);
/* Build the clipboards frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Clipboards</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
copy_check = gtk_check_button_new_with_mnemonic(_("Use _Copy (Ctrl-C)"));
g_signal_connect((GObject*)copy_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, copy_check, FALSE, FALSE, 0);
primary_check = gtk_check_button_new_with_mnemonic(_("Use _Primary (Selection)"));
g_signal_connect((GObject*)primary_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, primary_check, FALSE, FALSE, 0);
synchronize_check = gtk_check_button_new_with_mnemonic(_("S_ynchronize clipboards"));
gtk_box_pack_start((GtkBox*)vbox, synchronize_check, FALSE, FALSE, 0);
paste_check = gtk_check_button_new_with_mnemonic(_("_Automatically paste selected item"));
g_signal_connect((GObject*)paste_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, paste_check, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0);
/* Build the miscellaneous frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Miscellaneous</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
show_indexes_check = gtk_check_button_new_with_mnemonic(_("Show _indexes in history menu"));
gtk_box_pack_start((GtkBox*)vbox, show_indexes_check, FALSE, FALSE, 0);
save_uris_check = gtk_check_button_new_with_mnemonic(_("S_ave URIs"));
gtk_box_pack_start((GtkBox*)vbox, save_uris_check, FALSE, FALSE, 0);
hyperlinks_check = gtk_check_button_new_with_mnemonic(_("Capture _hyperlinks only"));
gtk_box_pack_start((GtkBox*)vbox, hyperlinks_check, FALSE, FALSE, 0);
confirm_check = gtk_check_button_new_with_mnemonic(_("C_onfirm before clearing history"));
gtk_box_pack_start((GtkBox*)vbox, confirm_check, FALSE, FALSE, 0);
use_rmb_menu_check = gtk_check_button_new_with_mnemonic(_("_Use right-click menu"));
gtk_box_pack_start((GtkBox*)vbox, use_rmb_menu_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0);
/* Build the history page */
GtkWidget* page_history = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_history, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_history, gtk_label_new(_("History")));
GtkWidget* vbox_history = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_history, vbox_history);
/* Build the history frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>History</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
save_check = gtk_check_button_new_with_mnemonic(_("Save _history"));
gtk_widget_set_tooltip_text(save_check, _("Save and restore history between sessions"));
gtk_box_pack_start((GtkBox*)vbox, save_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Items in history:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment = gtk_adjustment_new(25, 5, 1000, 1, 10, 0);
history_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)history_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, history_spin, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Items in menu:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment_small = gtk_adjustment_new(25, 5, 100, 1, 10, 0);
items_menu = gtk_spin_button_new((GtkAdjustment*)adjustment_small, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)items_menu, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, items_menu, FALSE, FALSE, 0);
statics_show_check = gtk_check_button_new_with_mnemonic(_("Show _static items in menu"));
g_signal_connect((GObject*)statics_show_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, statics_show_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Static items in menu:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment_statics = gtk_adjustment_new(10, 1, 100, 1, 10, 0);
statics_items_spin = gtk_spin_button_new((GtkAdjustment*)adjustment_statics, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)statics_items_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, statics_items_spin, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0);
/* Build the items frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Items</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
linemode_check = gtk_check_button_new_with_mnemonic(_("Show in a single _line"));
gtk_box_pack_start((GtkBox*)vbox, linemode_check, FALSE, FALSE, 0);
reverse_check = gtk_check_button_new_with_mnemonic(_("Show in _reverse order"));
gtk_box_pack_start((GtkBox*)vbox, reverse_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Character length of items:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment = gtk_adjustment_new(50, 25, 75, 1, 5, 0);
charlength_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)charlength_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, charlength_spin, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Omit items in the:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
ellipsize_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End"));
gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0);
/* Build the omitting frame
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Omitting</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Omit items in the:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
ellipsize_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End"));
gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); */
/* Build the actions page */
GtkWidget* page_actions = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_actions, 6, 6, 6, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_actions, gtk_label_new(_("Actions")));
GtkWidget* vbox_actions = gtk_vbox_new(FALSE, 6);
gtk_container_add((GtkContainer*)page_actions, vbox_actions);
/* Build the actions label */
label = gtk_label_new(_("Control-click ClipIt\'s tray icon to use actions"));
gtk_label_set_line_wrap((GtkLabel*)label, TRUE);
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)vbox_actions, label, FALSE, FALSE, 0);
/* Build the actions treeview */
GtkWidget* scrolled_window = gtk_scrolled_window_new(
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0),
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0));
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window, GTK_SHADOW_ETCHED_OUT);
GtkWidget* treeview = gtk_tree_view_new();
gtk_tree_view_set_reorderable((GtkTreeView*)treeview, TRUE);
gtk_tree_view_set_rules_hint((GtkTreeView*)treeview, TRUE);
actions_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1);
gtk_tree_view_set_model((GtkTreeView*)treeview, (GtkTreeModel*)actions_list);
GtkCellRenderer* name_renderer = gtk_cell_renderer_text_new();
g_object_set(name_renderer, "editable", TRUE, NULL);
g_signal_connect((GObject*)name_renderer, "edited", (GCallback)edit_action, (gpointer)0);
tree_column = gtk_tree_view_column_new_with_attributes(_("Action"), name_renderer, "text", 0, NULL);
gtk_tree_view_column_set_resizable(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column);
GtkCellRenderer* command_renderer = gtk_cell_renderer_text_new();
g_object_set(command_renderer, "editable", TRUE, NULL);
g_object_set(command_renderer, "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect((GObject*)command_renderer, "edited", (GCallback)edit_action, (gpointer)1);
tree_column = gtk_tree_view_column_new_with_attributes(_("Command"), command_renderer, "text", 1, NULL);
gtk_tree_view_column_set_expand(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column);
gtk_container_add((GtkContainer*)scrolled_window, treeview);
gtk_box_pack_start((GtkBox*)vbox_actions, scrolled_window, TRUE, TRUE, 0);
/* Edit selection and connect treeview related signals */
actions_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview);
gtk_tree_selection_set_mode(actions_selection, GTK_SELECTION_BROWSE);
g_signal_connect((GObject*)treeview, "key-press-event", (GCallback)delete_key_pressed, NULL);
/* Build the buttons */
GtkWidget* hbbox = gtk_hbutton_box_new();
gtk_box_set_spacing((GtkBox*)hbbox, 6);
gtk_button_box_set_layout((GtkButtonBox*)hbbox, GTK_BUTTONBOX_START);
GtkWidget* add_button = gtk_button_new_with_label(_("Add..."));
gtk_button_set_image((GtkButton*)add_button, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)add_button, "clicked", (GCallback)add_action, NULL);
gtk_box_pack_start((GtkBox*)hbbox, add_button, FALSE, TRUE, 0);
GtkWidget* remove_button = gtk_button_new_with_label(_("Remove"));
gtk_button_set_image((GtkButton*)remove_button, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)remove_button, "clicked", (GCallback)remove_action, NULL);
gtk_box_pack_start((GtkBox*)hbbox, remove_button, FALSE, TRUE, 0);
GtkWidget* up_button = gtk_button_new();
gtk_button_set_image((GtkButton*)up_button, gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)up_button, "clicked", (GCallback)move_action_up, NULL);
gtk_box_pack_start((GtkBox*)hbbox, up_button, FALSE, TRUE, 0);
GtkWidget* down_button = gtk_button_new();
gtk_button_set_image((GtkButton*)down_button, gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)down_button, "clicked", (GCallback)move_action_down, NULL);
gtk_box_pack_start((GtkBox*)hbbox, down_button, FALSE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_actions, hbbox, FALSE, FALSE, 0);
/* Build the exclude page */
GtkWidget* page_exclude = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_exclude, 6, 6, 6, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_exclude, gtk_label_new(_("Exclude")));
GtkWidget* vbox_exclude = gtk_vbox_new(FALSE, 6);
gtk_container_add((GtkContainer*)page_exclude, vbox_exclude);
/* Build the exclude label */
label = gtk_label_new(_("Regex list of items that should not be inserted into the history (passwords/sites that you don't need in history, etc)."));
gtk_label_set_line_wrap((GtkLabel*)label, TRUE);
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)vbox_exclude, label, FALSE, FALSE, 0);
/* Build the exclude treeview */
GtkWidget* scrolled_window_exclude = gtk_scrolled_window_new(
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0),
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0));
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window_exclude, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window_exclude, GTK_SHADOW_ETCHED_OUT);
GtkWidget* treeview_exclude = gtk_tree_view_new();
gtk_tree_view_set_reorderable((GtkTreeView*)treeview_exclude, TRUE);
gtk_tree_view_set_rules_hint((GtkTreeView*)treeview_exclude, TRUE);
exclude_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1);
gtk_tree_view_set_model((GtkTreeView*)treeview_exclude, (GtkTreeModel*)exclude_list);
GtkCellRenderer* name_renderer_exclude = gtk_cell_renderer_text_new();
g_object_set(name_renderer_exclude, "editable", TRUE, NULL);
g_signal_connect((GObject*)name_renderer_exclude, "edited", (GCallback)edit_exclude, (gpointer)0);
tree_column = gtk_tree_view_column_new_with_attributes(_("Regex"), name_renderer_exclude, "text", 0, NULL);
gtk_tree_view_column_set_resizable(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview_exclude, tree_column);
gtk_container_add((GtkContainer*)scrolled_window_exclude, treeview_exclude);
gtk_box_pack_start((GtkBox*)vbox_exclude, scrolled_window_exclude, TRUE, TRUE, 0);
/* Edit selection and connect treeview related signals */
exclude_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview_exclude);
gtk_tree_selection_set_mode(exclude_selection, GTK_SELECTION_BROWSE);
g_signal_connect((GObject*)treeview_exclude, "key-press-event", (GCallback)delete_key_pressed, NULL);
/* Build the buttons */
GtkWidget* hbbox_exclude = gtk_hbutton_box_new();
gtk_box_set_spacing((GtkBox*)hbbox_exclude, 6);
gtk_button_box_set_layout((GtkButtonBox*)hbbox_exclude, GTK_BUTTONBOX_START);
GtkWidget* add_button_exclude = gtk_button_new_with_label(_("Add..."));
gtk_button_set_image((GtkButton*)add_button_exclude, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)add_button_exclude, "clicked", (GCallback)add_exclude, NULL);
gtk_box_pack_start((GtkBox*)hbbox_exclude, add_button_exclude, FALSE, TRUE, 0);
GtkWidget* remove_button_exclude = gtk_button_new_with_label(_("Remove"));
gtk_button_set_image((GtkButton*)remove_button_exclude, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)remove_button_exclude, "clicked", (GCallback)remove_exclude, NULL);
gtk_box_pack_start((GtkBox*)hbbox_exclude, remove_button_exclude, FALSE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_exclude, hbbox_exclude, FALSE, FALSE, 0);
/* Build the hotkeys page */
GtkWidget* page_extras = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_extras, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_extras, gtk_label_new(_("Hotkeys")));
GtkWidget* vbox_extras = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_extras, vbox_extras);
/* Build the hotkeys frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Hotkeys</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
/* History key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("History hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
history_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)history_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, history_key_entry, TRUE, TRUE, 0);
/* Actions key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Actions hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
actions_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)actions_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, actions_key_entry, TRUE, TRUE, 0);
/* Menu key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Menu hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
menu_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)menu_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, menu_key_entry, TRUE, TRUE, 0);
/* Search key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Manage hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
search_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)search_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, search_key_entry, TRUE, TRUE, 0);
/* Offline mode key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Offline mode hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
offline_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)offline_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, offline_key_entry, TRUE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_extras, frame, FALSE, FALSE, 0);
/* Make widgets reflect current preferences */
gtk_toggle_button_set_active((GtkToggleButton*)copy_check, prefs.use_copy);
gtk_toggle_button_set_active((GtkToggleButton*)primary_check, prefs.use_primary);
gtk_toggle_button_set_active((GtkToggleButton*)synchronize_check, prefs.synchronize);
gtk_toggle_button_set_active((GtkToggleButton*)paste_check, prefs.automatic_paste);
gtk_toggle_button_set_active((GtkToggleButton*)show_indexes_check, prefs.show_indexes);
gtk_toggle_button_set_active((GtkToggleButton*)save_uris_check, prefs.save_uris);
gtk_toggle_button_set_active((GtkToggleButton*)use_rmb_menu_check, prefs.use_rmb_menu);
gtk_toggle_button_set_active((GtkToggleButton*)save_check, prefs.save_history);
gtk_spin_button_set_value((GtkSpinButton*)history_spin, (gdouble)prefs.history_limit);
gtk_spin_button_set_value((GtkSpinButton*)items_menu, (gdouble)prefs.items_menu);
gtk_toggle_button_set_active((GtkToggleButton*)statics_show_check, prefs.statics_show);
gtk_spin_button_set_value((GtkSpinButton*)statics_items_spin, (gdouble)prefs.statics_items);
gtk_toggle_button_set_active((GtkToggleButton*)hyperlinks_check, prefs.hyperlinks_only);
gtk_toggle_button_set_active((GtkToggleButton*)confirm_check, prefs.confirm_clear);
gtk_toggle_button_set_active((GtkToggleButton*)linemode_check, prefs.single_line);
gtk_toggle_button_set_active((GtkToggleButton*)reverse_check, prefs.reverse_history);
gtk_spin_button_set_value((GtkSpinButton*)charlength_spin, (gdouble)prefs.item_length);
gtk_combo_box_set_active((GtkComboBox*)ellipsize_combo, prefs.ellipsize - 1);
gtk_entry_set_text((GtkEntry*)history_key_entry, prefs.history_key);
gtk_entry_set_text((GtkEntry*)actions_key_entry, prefs.actions_key);
gtk_entry_set_text((GtkEntry*)menu_key_entry, prefs.menu_key);
gtk_entry_set_text((GtkEntry*)search_key_entry, prefs.search_key);
gtk_entry_set_text((GtkEntry*)offline_key_entry, prefs.offline_key);
/* Read actions */
read_actions();
read_excludes();
/* Run the dialog */
gtk_widget_show_all(dialog);
#ifdef HAVE_APPINDICATOR
gtk_widget_hide(use_rmb_menu_check);
#endif
gtk_notebook_set_current_page((GtkNotebook*)notebook, tab);
if (gtk_dialog_run((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT)
{
/* If the user disabled history saving, we ask him if he wants to delete the history file */
if(prefs.save_history && !gtk_toggle_button_get_active((GtkToggleButton*)save_check))
check_saved_hist_file();
/* Apply and save preferences */
apply_preferences();
save_preferences();
save_actions();
save_excludes();
}
gtk_widget_destroy(dialog);
}
ConfigDialog *config_dialog_new(void)
{
ConfigDialog *config_win;
GtkTooltips *tooltips;
GtkWidget *window_main;
GtkWidget *vbox_main;
GtkWidget *label_scale_factor;
GtkWidget *hscale_scale_factor;
GtkWidget *frame_general;
GtkWidget *table_general;
GtkWidget *label_effect;
GtkWidget *label_palette;
GtkWidget *label_fps;
GtkWidget *checkbutton_show_title;
GtkWidget *hscale_effect;
GtkWidget *hscale_palette;
GtkObject *spinbutton_fps_adj;
GtkWidget *spinbutton_fps;
GtkWidget *hbuttonbox_main;
GtkWidget *button_ok;
GtkWidget *button_cancel;
GtkWidget *button_apply;
#if ENABLE_NLS
setlocale(LC_MESSAGES, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
#endif
window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(window_main), "window_main", window_main);
gtk_window_set_title(GTK_WINDOW(window_main), _("Infinity Configuration"));
gtk_window_set_type_hint(GTK_WINDOW(window_main), GDK_WINDOW_TYPE_HINT_DIALOG);
vbox_main = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(vbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "vbox_main", vbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(vbox_main);
gtk_container_add(GTK_CONTAINER(window_main), vbox_main);
gtk_container_set_border_width(GTK_CONTAINER(vbox_main), 2);
frame_general = gtk_frame_new(_("Parameters"));
gtk_widget_ref(frame_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "frame_general", frame_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(frame_general);
gtk_box_pack_start(GTK_BOX(vbox_main), frame_general, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_general), 2);
table_general = gtk_table_new(5, 3, FALSE);
gtk_widget_ref(table_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "table_general", table_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(table_general);
gtk_container_add(GTK_CONTAINER(frame_general), table_general);
gtk_container_set_border_width(GTK_CONTAINER(table_general), 2);
gtk_table_set_row_spacings(GTK_TABLE(table_general), 2);
gtk_table_set_col_spacings(GTK_TABLE(table_general), 2);
label_effect = gtk_label_new(_("Effect period:"));
gtk_widget_ref(label_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_effect", label_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_effect);
gtk_table_attach(GTK_TABLE(table_general), label_effect, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_effect), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_effect), 1, 0);
label_palette = gtk_label_new(_("Palette period:"));
gtk_widget_ref(label_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_palette", label_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_palette);
gtk_table_attach(GTK_TABLE(table_general), label_palette, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_palette), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_palette), 1, 0);
label_scale_factor = gtk_label_new(_("Scale Factor"));
gtk_widget_ref(label_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_scale_factor", label_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), label_scale_factor, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_scale_factor), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_scale_factor), 1, 0);
label_fps = gtk_label_new(_("Maximum Frames per Second:"));
gtk_widget_ref(label_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_fps", label_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_fps);
gtk_table_attach(GTK_TABLE(table_general), label_fps, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_fps), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_fps), 1, 0);
checkbutton_show_title = gtk_check_button_new_with_label(_("Show current play title"));
gtk_widget_ref(checkbutton_show_title);
gtk_object_set_data_full(GTK_OBJECT(window_main), "checkbutton_show_title", checkbutton_show_title,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(checkbutton_show_title);
gtk_table_attach(GTK_TABLE(table_general), checkbutton_show_title, 0, 1, 4, 5,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips, checkbutton_show_title,
_("Check it if you want to see the current play "
"title on the Infinity's title bar"), NULL);
//spinbutton_fps_adj = gtk_adjustment_new (30, 5, 150, 1, 10, 0);
spinbutton_fps_adj = gtk_adjustment_new(config_get_fps(), 5, 150, 1, 10, 0);
spinbutton_fps = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_fps_adj), 1, 0);
gtk_widget_ref(spinbutton_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "spinbutton_fps", spinbutton_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(spinbutton_fps);
gtk_table_attach(GTK_TABLE(table_general), spinbutton_fps, 2, 3, 3, 4,
(GtkAttachOptions)(0),
(GtkAttachOptions)(0), 0, 0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spinbutton_fps), GTK_UPDATE_IF_VALID);
hscale_effect = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_effect", hscale_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_effect);
gtk_table_attach(GTK_TABLE(table_general), hscale_effect, 1, 3, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_effect), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_effect), 0);
gtk_tooltips_set_tip(tooltips, hscale_effect,
_("Time to change between an effect and the "
"next one, in milliseconds."), NULL);
hscale_palette = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_palette", hscale_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_palette);
gtk_table_attach(GTK_TABLE(table_general), hscale_palette, 1, 3, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_palette), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_palette), 0);
gtk_tooltips_set_tip(tooltips, hscale_palette,
_("Time to change between a color and the "
"next one, in milliseconds."), NULL);
hscale_scale_factor = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(1, 1, 2, 0, 0, 0)));
gtk_widget_ref(hscale_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_scale_factor", hscale_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), hscale_scale_factor, 1, 3, 2, 3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_scale_factor), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_scale_factor), 0);
gtk_tooltips_set_tip(tooltips, hscale_scale_factor,
_("Change only if the system doesn't have "
"enough power to show the screen at "
"a reasonably speed/size relation."), NULL);
hbuttonbox_main = gtk_hbutton_box_new();
gtk_widget_ref(hbuttonbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hbuttonbox_main", hbuttonbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hbuttonbox_main);
gtk_box_pack_start(GTK_BOX(vbox_main), hbuttonbox_main, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbuttonbox_main), 2);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox_main), GTK_BUTTONBOX_END);
button_ok = gtk_button_new_with_label(_("Ok"));
gtk_widget_ref(button_ok);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_ok", button_ok,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_ok);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_ok);
GTK_WIDGET_SET_FLAGS(button_ok, GTK_CAN_DEFAULT);
gtk_tooltips_set_tip(tooltips, button_ok,
_("For to toggle to fullscreen mode, select "
"the Infinity plugin window, and press "
"the Tab key. Pressing Tab again will return "
"to window mode."), NULL);
button_cancel = gtk_button_new_with_label(_("Cancel"));
gtk_widget_ref(button_cancel);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_cancel", button_cancel,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_cancel);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_cancel);
GTK_WIDGET_SET_FLAGS(button_cancel, GTK_CAN_DEFAULT);
button_apply = gtk_button_new_with_label(_("Apply"));
gtk_widget_ref(button_apply);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_apply", button_apply,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_apply);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_apply);
GTK_WIDGET_SET_FLAGS(button_apply, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button_cancel);
config_win = g_new0(ConfigDialog, 1);
config_win->window_main = window_main;
config_win->hscale_effect = hscale_effect;
config_win->hscale_palette = hscale_palette;
config_win->hscale_scale_factor = hscale_scale_factor;
config_win->spinbutton_fps = spinbutton_fps;
config_win->checkbutton_show_title = checkbutton_show_title;
config_win->button_ok = button_ok;
config_win->button_cancel = button_cancel;
config_win->button_apply = button_apply;
gtk_tooltips_enable(tooltips);
return config_win;
}
void ir_configure(void)
{
GtkWidget *vbox, *notebook, *box, *frame, *table, *vbox2, *label,
*button, *label_codelen;
GtkAdjustment *adj;
gint i;
irapp_read_config();
if (!irconf_mainwin)
{
irconf_mainwin = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(irconf_mainwin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &irconf_mainwin);
gtk_window_set_title(GTK_WINDOW(irconf_mainwin), _("XMMS IRman Configuration"));
gtk_window_set_policy(GTK_WINDOW(irconf_mainwin), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(irconf_mainwin), GTK_WIN_POS_MOUSE);
gtk_container_border_width(GTK_CONTAINER(irconf_mainwin), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(irconf_mainwin), vbox);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
box = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(box), 5);
frame = gtk_frame_new(_("Device:"));
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
table = gtk_table_new(2, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
label = gtk_label_new(_("Device: "));
gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show(label);
dev_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(dev_entry), ircfg.device);
gtk_table_attach_defaults(GTK_TABLE(table), dev_entry, 1, 2, 0, 1);
gtk_widget_show(dev_entry);
label_codelen = gtk_label_new(_("IR code length: "));
gtk_misc_set_alignment(GTK_MISC(label_codelen), 1.0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(table), label_codelen, 0, 1, 1, 2);
gtk_widget_show(label_codelen);
codelen_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(codelen_entry), g_strdup_printf("%d", ircfg.codelen));
gtk_table_attach_defaults(GTK_TABLE(table), codelen_entry, 1, 2, 1, 2);
gtk_widget_show(codelen_entry);
gtk_widget_show(table);
gtk_widget_show(frame);
frame = gtk_frame_new(_("Controls:"));
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox2);
table = gtk_table_new(5, 3, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
gtk_box_pack_start(GTK_BOX(vbox2), table, FALSE, FALSE, 0);
for (i = 0; i < 13; i++)
{
button = gtk_button_new_with_label(_(ir_control[i]));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_control_cb), ir_control[i]);
gtk_table_attach_defaults(GTK_TABLE(table), button, i % 3, (i % 3) + 1, i / 3, (i / 3) + 1);
gtk_widget_show(button);
}
gtk_widget_show(table);
gtk_widget_show(frame);
table = gtk_table_new(2, 5, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_table_set_row_spacings(GTK_TABLE(table), 0);
gtk_table_set_col_spacings(GTK_TABLE(table), 0);
gtk_box_pack_start(GTK_BOX(vbox2), table, FALSE, FALSE, 0);
for (i = 0; i < 10; i++)
{
button = gtk_button_new_with_label(_(ir_playlist[i]));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_control_cb), ir_playlist[i]);
gtk_table_attach_defaults(GTK_TABLE(table), button, i % 5, (i % 5) + 1, i / 5, (i / 5) + 1);
gtk_widget_show(button);
}
gtk_widget_show(table);
gtk_widget_show(frame);
frame = gtk_frame_new(_("Playlists:"));
gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 0);
table = gtk_table_new(2, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
adj = (GtkAdjustment *) gtk_adjustment_new(0, 0, 99, 1, 5, 0);
playlist_spin = gtk_spin_button_new(adj, 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(playlist_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(playlist_spin), GTK_UPDATE_IF_VALID);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(playlist_spin), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), playlist_spin, 0, 1, 0, 1);
gtk_signal_connect(GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(spin_change_cb), (gpointer) playlist_spin);
gtk_widget_show(playlist_spin);
playlist_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(playlist_entry), ircfg.playlist[0]);
gtk_signal_connect(GTK_OBJECT(playlist_entry), "changed", GTK_SIGNAL_FUNC(pl_entry_change_cb), (gpointer) playlist_spin);
gtk_table_attach_defaults(GTK_TABLE(table), playlist_entry, 1, 2, 0, 1);
gtk_widget_show(playlist_entry);
gtk_widget_show(table);
gtk_widget_show(frame);
gtk_widget_show(vbox2);
gtk_widget_show(box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), box, gtk_label_new(_("General")));
gtk_widget_show(notebook);
box = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(box), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(box), 5);
gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 0);
button = gtk_button_new_with_label(_("OK"));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_ok_cb), NULL);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(irconf_cancel_cb), NULL);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_widget_show(button);
gtk_widget_show(box);
gtk_widget_show(vbox);
gtk_widget_show(irconf_mainwin);
}
}
static void config_window_create(void)
{
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *notebook;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *group;
GtkWidget *subgroup;
GtkWidget *button;
GtkWidget *tabcomp;
GtkWidget *ct_button;
GtkWidget *table;
GtkWidget *spin;
GtkWidget *scrolled;
GtkWidget *viewport;
GtkWidget *filter_view;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint i;
configwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT (configwindow), "delete_event",
G_CALLBACK(config_window_delete), NULL);
gtk_window_set_resizable(GTK_WINDOW(configwindow), FALSE);
gtk_window_set_title(GTK_WINDOW(configwindow), _("GQview Preferences"));
gtk_window_set_wmclass(GTK_WINDOW(configwindow), "config", "GQview");
gtk_container_set_border_width(GTK_CONTAINER(configwindow), PREF_PAD_BORDER);
window_set_icon(configwindow, PIXBUF_INLINE_ICON_CONFIG, NULL);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(configwindow), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, GTK_STOCK_OK, NULL, FALSE,
G_CALLBACK(config_window_ok_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_show(button);
ct_button = button;
button = pref_button_new(NULL, GTK_STOCK_APPLY, NULL, FALSE,
G_CALLBACK(config_window_apply_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CANCEL, NULL, FALSE,
G_CALLBACK(config_window_close_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
if (!generic_dialog_get_alternative_button_order(configwindow))
{
gtk_box_reorder_child(GTK_BOX(hbox), ct_button, -1);
}
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(win_vbox), notebook, TRUE, TRUE, 0);
/* general options tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("General"));
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("Startup"), GTK_ORIENTATION_VERTICAL);
button = pref_checkbox_new_int(group, _("Change to folder:"),
startup_path_enable, &startup_path_enable_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(button, hbox);
tabcomp = tab_completion_new(&startup_path_entry, startup_path, NULL, NULL);
tab_completion_add_select_button(startup_path_entry, NULL, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
button = pref_button_new(hbox, NULL, _("Use current"), FALSE,
G_CALLBACK(startup_path_set_current), NULL);
group = pref_group_new(vbox, FALSE, _("Thumbnails"), GTK_ORIENTATION_VERTICAL);
table = pref_table_new(group, 2, 2, FALSE, FALSE);
add_thumb_size_menu(table, 0, 0, _("Size:"));
add_quality_menu(table, 0, 1, _("Quality:"), thumbnail_quality, &thumbnail_quality_c);
ct_button = pref_checkbox_new_int(group, _("Cache thumbnails"),
enable_thumb_caching, &enable_thumb_caching_c);
subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_link_sensitivity(ct_button, subgroup);
button = pref_checkbox_new_int(subgroup, _("Use shared thumbnail cache"),
thumbnail_spec_standard, &thumbnail_spec_standard_c);
subgroup = pref_box_new(subgroup, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_link_sensitivity_swap(button, subgroup);
pref_checkbox_new_int(subgroup, _("Cache thumbnails into .thumbnails"),
enable_thumb_dirs, &enable_thumb_dirs_c);
#if 0
pref_checkbox_new_int(subgroup, _("Use xvpics thumbnails when found (read only)"),
use_xvpics_thumbnails, &use_xvpics_thumbnails_c);
#endif
pref_checkbox_new_int(group, _("Faster jpeg thumbnailing (may reduce quality)"),
thumbnail_fast, &thumbnail_fast_c);
group = pref_group_new(vbox, FALSE, _("Slide show"), GTK_ORIENTATION_VERTICAL);
slideshow_delay_c = slideshow_delay;
spin = pref_spin_new(group, _("Delay between image change:"), _("seconds"),
SLIDESHOW_MIN_SECONDS, SLIDESHOW_MAX_SECONDS, 1.0, 1,
slideshow_delay ? (double)slideshow_delay / SLIDESHOW_SUBSECOND_PRECISION : 10.0,
G_CALLBACK(slideshow_delay_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
pref_checkbox_new_int(group, _("Random"), slideshow_random, &slideshow_random_c);
pref_checkbox_new_int(group, _("Repeat"), slideshow_repeat, &slideshow_repeat_c);
/* image tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Image"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("Zoom"), GTK_ORIENTATION_VERTICAL);
#if 0
add_dither_menu(dither_quality, &dither_quality_c, _("Dithering method:"), group);
#endif
table = pref_table_new(group, 2, 1, FALSE, FALSE);
add_quality_menu(table, 0, 0, _("Quality:"), zoom_quality, &zoom_quality_c);
pref_checkbox_new_int(group, _("Two pass zooming"),
two_pass_zoom, &two_pass_zoom_c);
pref_checkbox_new_int(group, _("Allow enlargement of image for zoom to fit"),
zoom_to_fit_expands, &zoom_to_fit_expands_c);
zoom_increment_c = zoom_increment;
spin = pref_spin_new(group, _("Zoom increment:"), NULL,
0.1, 4.0, 1.0, 1, (double)zoom_increment / 10.0,
G_CALLBACK(zoom_increment_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
group = pref_group_new(vbox, FALSE, _("When new image is selected:"), GTK_ORIENTATION_VERTICAL);
zoom_mode_c = zoom_mode;
button = pref_radiobutton_new(group, NULL, _("Zoom to original size"),
(zoom_mode == ZOOM_RESET_ORIGINAL),
G_CALLBACK(zoom_mode_original_cb), NULL);
button = pref_radiobutton_new(group, button, _("Fit image to window"),
(zoom_mode == ZOOM_RESET_FIT_WINDOW),
G_CALLBACK(zoom_mode_fit_cb), NULL);
button = pref_radiobutton_new(group, button, _("Leave Zoom at previous setting"),
(zoom_mode == ZOOM_RESET_NONE),
G_CALLBACK(zoom_mode_none_cb), NULL);
group = pref_group_new(vbox, FALSE, _("Appearance"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Black background"),
black_window_background, &black_window_background_c);
group = pref_group_new(vbox, FALSE, _("Convenience"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Refresh on file change"),
update_on_time_change, &update_on_time_change_c);
pref_checkbox_new_int(group, _("Preload next image"),
enable_read_ahead, &enable_read_ahead_c);
pref_checkbox_new_int(group, _("Auto rotate image using Exif information"),
exif_rotate_enable, &exif_rotate_enable_c);
/* window tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Windows"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("State"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Remember window positions"),
save_window_positions, &save_window_positions_c);
pref_checkbox_new_int(group, _("Remember tool state (float/hidden)"),
restore_tool, &restore_tool_c);
group = pref_group_new(vbox, FALSE, _("Size"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Fit window to image when tools are hidden/floating"),
fit_window, &fit_window_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
ct_button = pref_checkbox_new_int(hbox, _("Limit size when auto-sizing window (%):"),
limit_window_size, &limit_window_size_c);
spin = pref_spin_new_int(hbox, NULL, NULL,
10, 150, 1,
max_window_size, &max_window_size_c);
pref_checkbox_link_sensitivity(ct_button, spin);
group = pref_group_new(vbox, FALSE, _("Layout"), GTK_ORIENTATION_VERTICAL);
layout_widget = layout_config_new();
layout_config_set(layout_widget, layout_style, layout_order);
gtk_box_pack_start(GTK_BOX(group), layout_widget, FALSE, FALSE, 0);
gtk_widget_show(layout_widget);
/* filtering tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER (vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Filtering"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
group = pref_box_new(vbox, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_new_int(group, _("Show entries that begin with a dot"),
show_dot_files, &show_dot_files_c);
pref_checkbox_new_int(group, _("Case sensitive sort"),
file_sort_case_sensitive, &file_sort_case_sensitive_c);
ct_button = pref_checkbox_new_int(group, _("Disable File Filtering"),
file_filter_disable, &file_filter_disable_c);
group = pref_group_new(vbox, TRUE, _("File types"), GTK_ORIENTATION_VERTICAL);
frame = pref_group_parent(group);
g_signal_connect(G_OBJECT(ct_button), "toggled",
G_CALLBACK(filter_disable_cb), frame);
gtk_widget_set_sensitive(frame, !file_filter_disable);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
filter_store = gtk_list_store_new(1, G_TYPE_POINTER);
filter_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_store));
g_object_unref(filter_store);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(filter_view), FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Filter"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(filter_store_enable_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_ENABLE), NULL);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_ext_edit_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_EXTENSION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Description"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_desc_edit_cb), filter_store);
g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_DESCRIPTION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
filter_store_populate();
gtk_container_add(GTK_CONTAINER(scrolled), filter_view);
gtk_widget_show(filter_view);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
G_CALLBACK(filter_default_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_REMOVE, NULL, FALSE,
G_CALLBACK(filter_remove_cb), filter_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_ADD, NULL, FALSE,
G_CALLBACK(filter_add_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* editor entry tab */
vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Editors"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
table = pref_table_new(vbox, 3, 9, FALSE, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
label = pref_table_label(table, 0, 0, _("#"), 1.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 2, 0, _("Command Line"), 0.0);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < GQVIEW_EDITOR_SLOTS; i++)
{
gchar *buf;
buf = g_strdup_printf("%d", i+1);
pref_table_label(table, 0, i+1, buf, 1.0);
g_free(buf);
editor_name_entry[i] = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(editor_name_entry[i]), EDITOR_NAME_MAX_LENGTH);
gtk_widget_set_size_request(editor_name_entry[i],80,-1);
if (editor_name[i]) gtk_entry_set_text(GTK_ENTRY(editor_name_entry[i]),editor_name[i]);
gtk_table_attach(GTK_TABLE (table),editor_name_entry[i],1,2,i+1,i+2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(editor_name_entry[i]);
editor_command_entry[i] = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(editor_command_entry[i]), EDITOR_COMMAND_MAX_LENGTH);
gtk_widget_set_size_request(editor_command_entry[i],160,-1);
tab_completion_add_to_entry(editor_command_entry[i], NULL, NULL);
if (editor_command[i]) gtk_entry_set_text(GTK_ENTRY(editor_command_entry[i]), editor_command[i]);
gtk_table_attach(GTK_TABLE (table),editor_command_entry[i],2,3,i+1,i+2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(editor_command_entry[i]);
}
hbox = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
G_CALLBACK(editor_default_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
G_CALLBACK(editor_help_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* advanced entry tab */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
label = gtk_label_new(_("Advanced"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled, label);
gtk_widget_show(scrolled);
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scrolled), viewport);
gtk_widget_show(viewport);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(viewport), vbox);
gtk_widget_show(vbox);
group = pref_group_new(vbox, FALSE, _("Full screen"), GTK_ORIENTATION_VERTICAL);
fullscreen_screen_c = fullscreen_screen;
fullscreen_above_c = fullscreen_above;
hbox = fullscreen_prefs_selection_new(_("Location:"), &fullscreen_screen_c, &fullscreen_above_c);
gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
pref_checkbox_new_int(group, _("Smooth image flip"),
fullscreen_clean_flip, &fullscreen_clean_flip_c);
pref_checkbox_new_int(group, _("Disable screen saver"),
fullscreen_disable_saver, &fullscreen_disable_saver_c);
group = pref_group_new(vbox, FALSE, _("Delete"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Confirm file delete"),
confirm_delete, &confirm_delete_c);
pref_checkbox_new_int(group, _("Enable Delete key"),
enable_delete_key, &enable_delete_key_c);
ct_button = pref_checkbox_new_int(group, _("Safe delete"),
safe_delete_enable, &safe_delete_enable_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
tabcomp = tab_completion_new(&safe_delete_path_entry, safe_delete_path, NULL, NULL);
tab_completion_add_select_button(safe_delete_path_entry, NULL, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_GAP);
pref_spin_new_int(hbox, _("Maximum size:"), _("MB"),
1, 500, 1, safe_delete_size, &safe_delete_size_c);
button = pref_button_new(NULL, NULL, _("View"), FALSE,
G_CALLBACK(safe_delete_view_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CLEAR, NULL, FALSE,
G_CALLBACK(safe_delete_clear_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
group = pref_group_new(vbox, FALSE, _("Behavior"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Rectangular selection in icon view"),
collection_rectangular_selection, &collection_rectangular_selection_c);
pref_checkbox_new_int(group, _("Descend folders in tree view"),
tree_descend_subdirs, &tree_descend_subdirs_c);
pref_checkbox_new_int(group, _("In place renaming"),
enable_in_place_rename, &enable_in_place_rename_c);
group = pref_group_new(vbox, FALSE, _("Navigation"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Progressive keyboard scrolling"),
progressive_key_scrolling, &progressive_key_scrolling_c);
pref_checkbox_new_int(group, _("Mouse wheel scrolls image"),
mousewheel_scrolls, &mousewheel_scrolls_c);
group = pref_group_new(vbox, FALSE, _("Miscellaneous"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Store keywords and comments local to source images"),
enable_metadata_dirs, &enable_metadata_dirs_c);
pref_spin_new_int(group, _("Custom similarity threshold:"), NULL,
0, 100, 1, dupe_custom_threshold, &dupe_custom_threshold_c);
pref_spin_new_int(group, _("Offscreen cache size (Mb per image):"), NULL,
0, 128, 1, tile_cache_max, &tile_cache_max_c);
group = pref_group_new(vbox, FALSE, _("Color profiles"), GTK_ORIENTATION_VERTICAL);
#ifndef HAVE_LCMS
gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
#endif
table = pref_table_new(group, 3, COLOR_PROFILE_INPUTS + 2, FALSE, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
label = pref_table_label(table, 0, 0, _("Type"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 2, 0, _("File"), 0.0);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
{
GtkWidget *entry;
gchar *buf;
buf = g_strdup_printf("Input %d:", i + 1);
pref_table_label(table, 0, i + 1, buf, 1.0);
g_free(buf);
entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), EDITOR_NAME_MAX_LENGTH);
gtk_widget_set_size_request(editor_name_entry[i], 30, -1);
if (color_profile_input_name[i]) gtk_entry_set_text(GTK_ENTRY(entry), color_profile_input_name[i]);
gtk_table_attach(GTK_TABLE(table), entry, 1, 2, i + 1, i + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(entry);
color_profile_input_name_entry[i] = entry;
tabcomp = tab_completion_new(&entry, color_profile_input_file[i], NULL, NULL);
tab_completion_add_select_button(entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3, i + 1, i + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(tabcomp);
color_profile_input_file_entry[i] = entry;
}
pref_table_label(table, 0, COLOR_PROFILE_INPUTS + 1, _("Screen:"), 1.0);
tabcomp = tab_completion_new(&color_profile_screen_file_entry,
color_profile_screen_file, NULL, NULL);
tab_completion_add_select_button(color_profile_screen_file_entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(color_profile_screen_file_entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3,
COLOR_PROFILE_INPUTS + 1, COLOR_PROFILE_INPUTS + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(tabcomp);
gtk_widget_show(notebook);
gtk_widget_show(configwindow);
}
GtkWidget* create_SurfaceInspector( void ){
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *table1;
GtkWidget *table2;
GtkWidget *frame1;
GtkWidget *frame2;
GtkWidget *vbox1;
GtkWidget *hbox1;
SurfaceInspector = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_container_set_border_width( GTK_CONTAINER( SurfaceInspector ), 4 );
gtk_window_set_title( GTK_WINDOW( SurfaceInspector ), "Surface Inspector" );
SetWinPos_from_Prefs( SurfaceInspector );
vbox1 = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox1 );
gtk_container_add( GTK_CONTAINER( SurfaceInspector ), vbox1 );
hbox1 = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox1 );
gtk_container_add( GTK_CONTAINER( vbox1 ), hbox1 );
gtk_container_set_border_width( GTK_CONTAINER( hbox1 ), 4 );
label = gtk_label_new( "Texture: " );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox1 ), label, FALSE, FALSE, 0 );
gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 );
texture_combo = gtk_combo_new();
g_object_set_data( G_OBJECT( GTK_COMBO( texture_combo )->popwin ),
"KeepMeAround", texture_combo );
gtk_combo_disable_activate( (GtkCombo*) texture_combo );
gtk_widget_show( texture_combo );
gtk_box_pack_start( GTK_BOX( hbox1 ), texture_combo, TRUE, TRUE, 0 );
texture_combo_entry = GTK_COMBO( texture_combo )->entry;
gtk_widget_show( texture_combo_entry );
gtk_entry_set_max_length( GTK_ENTRY( texture_combo_entry ), 1024 );
frame1 = gtk_frame_new( "Surface" );
gtk_widget_show( frame1 );
gtk_container_add( GTK_CONTAINER( vbox1 ), frame1 );
table1 = gtk_table_new( 7, 3, FALSE );
gtk_widget_show( table1 );
gtk_table_set_col_spacings( GTK_TABLE( table1 ), 5 );
gtk_table_set_row_spacings( GTK_TABLE( table1 ), 5 );
gtk_container_set_border_width( GTK_CONTAINER( table1 ), 5 );
gtk_container_add( GTK_CONTAINER( frame1 ), table1 );
label = gtk_label_new( "Step" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 2, 3, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Value" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 1, 2, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 );
label = gtk_label_new( "Horizontal shift: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Vertical shift: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Horizontal scale: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 3, 4,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Vertical scale: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 4, 5,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
label = gtk_label_new( "Rotate: " );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table1 ), label, 0, 1, 5, 6,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( GTK_FILL ), 0, 0 );
// Value Spins
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
hshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( hshift_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hshift_value_spinbutton, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hshift_value_spinbutton ), TRUE );
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
vshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( vshift_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vshift_value_spinbutton, 1, 2, 2, 3,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vshift_value_spinbutton ), TRUE );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
hscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( hscale_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hscale_value_spinbutton, 1, 2, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hscale_value_spinbutton ), TRUE );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
vscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( vscale_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vscale_value_spinbutton, 1, 2, 4, 5,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_value_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 0.0 );
rotate_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 0 );
gtk_widget_show( rotate_value_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), rotate_value_spinbutton, 1, 2, 5, 6,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_value_spinbutton ), GTK_UPDATE_IF_VALID );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( rotate_value_spinbutton ), TRUE );
// Step Spins
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
hshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( hshift_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hshift_step_spinbutton, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 0.0 );
vshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( vshift_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vshift_step_spinbutton, 2, 3, 2, 3,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
hscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( hscale_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), hscale_step_spinbutton, 2, 3, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 0.0 );
vscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 4 );
gtk_widget_show( vscale_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), vscale_step_spinbutton, 2, 3, 4, 5,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_step_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 0.0 );
rotate_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 2 );
gtk_widget_show( rotate_step_spinbutton );
gtk_table_attach( GTK_TABLE( table1 ), rotate_step_spinbutton, 2, 3, 5, 6,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_step_spinbutton ), GTK_UPDATE_IF_VALID );
match_grid_button = gtk_button_new_with_mnemonic( "Match Grid" );
gtk_widget_show( match_grid_button );
gtk_table_attach( GTK_TABLE( table1 ), match_grid_button, 2, 3, 6, 7,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
frame2 = gtk_frame_new( "Tools" );
gtk_widget_show( frame2 );
gtk_container_add( GTK_CONTAINER( vbox1 ), frame2 );
table2 = gtk_table_new( 2, 4, TRUE );
gtk_widget_show( table2 );
gtk_table_set_col_spacings( GTK_TABLE( table2), 5 );
gtk_table_set_row_spacings( GTK_TABLE( table2 ), 0 );
gtk_container_set_border_width( GTK_CONTAINER( table2 ), 5 );
gtk_container_add( GTK_CONTAINER( frame2 ), table2 );
label = gtk_label_new( "Height" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table2 ), label, 3, 4, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Width" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table2 ), label, 2, 3, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Brush" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table2 ), label, 0, 2, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
adjustment = gtk_adjustment_new( 1, 1, 32, 1, 10, 0 );
fit_height_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 0 );
gtk_widget_show( fit_height_spinbutton );
gtk_table_attach( GTK_TABLE( table2 ), fit_height_spinbutton, 3, 4, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_height_spinbutton ), TRUE );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_height_spinbutton ), GTK_UPDATE_IF_VALID );
adjustment = gtk_adjustment_new( 1, 1, 32, 1, 10, 0 );
fit_width_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( adjustment ), 1, 0 );
gtk_widget_show( fit_width_spinbutton );
gtk_table_attach( GTK_TABLE( table2 ), fit_width_spinbutton, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_width_spinbutton ), TRUE );
gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_width_spinbutton ), GTK_UPDATE_IF_VALID );
fit_button = gtk_button_new_with_mnemonic( "Fit" );
gtk_widget_show( fit_button );
gtk_table_attach( GTK_TABLE( table2 ), fit_button, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
axial_button = gtk_button_new_with_mnemonic( "Axial" );
gtk_widget_show( axial_button );
gtk_table_attach( GTK_TABLE( table2 ), axial_button, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
// Add the SURF_ and CONTENTS_ flags frame
create_SurfaceFlagsFrame( vbox1 );
g_signal_connect( (gpointer) SurfaceInspector,
"delete_event",
G_CALLBACK( delete_event_callback ),
NULL );
g_signal_connect( (gpointer) SurfaceInspector, "destroy",
G_CALLBACK( gtk_widget_destroy ),
NULL );
g_signal_connect( (gpointer) SurfaceInspector, "key_press_event",
G_CALLBACK( surface_inspector_key_press_event ),
NULL );
g_signal_connect( (gpointer) texture_combo_entry, "key_press_event",
G_CALLBACK( on_texture_combo_entry_key_press_event ),
NULL );
g_signal_connect( (gpointer) texture_combo_entry, "activate",
G_CALLBACK( on_texture_combo_entry_activate ),
NULL );
g_signal_connect( (gpointer) hshift_value_spinbutton, "value_changed",
G_CALLBACK( on_hshift_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vshift_value_spinbutton, "value_changed",
G_CALLBACK( on_vshift_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) hscale_value_spinbutton, "value_changed",
G_CALLBACK( on_hscale_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vscale_value_spinbutton, "value_changed",
G_CALLBACK( on_vscale_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) rotate_value_spinbutton, "value_changed",
G_CALLBACK( on_rotate_value_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) hshift_step_spinbutton, "value_changed",
G_CALLBACK( on_hshift_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vshift_step_spinbutton, "value_changed",
G_CALLBACK( on_vshift_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) hscale_step_spinbutton, "value_changed",
G_CALLBACK( on_hscale_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) vscale_step_spinbutton, "value_changed",
G_CALLBACK( on_vscale_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) rotate_step_spinbutton, "value_changed",
G_CALLBACK( on_rotate_step_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) match_grid_button, "clicked",
G_CALLBACK( on_match_grid_button_clicked ),
NULL );
g_signal_connect( (gpointer) fit_width_spinbutton, "value_changed",
G_CALLBACK( on_fit_width_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) fit_height_spinbutton, "value_changed",
G_CALLBACK( on_fit_height_spinbutton_value_changed ),
NULL );
g_signal_connect( (gpointer) fit_button, "clicked",
G_CALLBACK( on_fit_button_clicked ),
NULL );
g_signal_connect( (gpointer) axial_button, "clicked",
G_CALLBACK( on_axial_button_clicked ),
NULL );
return SurfaceInspector;
}
void
calendar_create_fullyear_window (GUI *appGUI)
{
GtkWidget *vbox1, *vbox2;
GtkWidget *hseparator;
GtkWidget *hbuttonbox;
GtkWidget *close_button;
GtkWidget *hbox1;
GtkWidget *prev_button;
GtkWidget *info_button;
GtkObject *fy_spinbutton_adj;
GtkWidget *next_button;
GtkWidget *fycal_scrolledwindow;
GtkWidget *fycal_viewport;
GtkWidget *fycal_alternative_view_checkbutton;
GtkWidget *vseparator;
GtkWidget *label;
GtkWidget *fycal_label, *fycal_vbox;
#ifdef HAVE_LIBICAL
GtkWidget *button;
#endif /* HAVE_LIBICAL */
gchar tmpbuf[BUFFER_SIZE], buffer[BUFFER_SIZE];
gint i, j, x, y, idx;
GDate *cdate;
guint month, year;
cdate = g_date_new ();
g_return_if_fail (cdate != NULL);
g_date_set_time_t (cdate, time (NULL));
appGUI->cal->fullyear_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appGUI->cal->fullyear_window), _("Full-year calendar"));
gtk_window_set_position (GTK_WINDOW (appGUI->cal->fullyear_window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_default_size (GTK_WINDOW (appGUI->cal->fullyear_window), config.fy_window_size_x, config.fy_window_size_y);
gtk_window_set_modal (GTK_WINDOW (appGUI->cal->fullyear_window), TRUE);
g_signal_connect (G_OBJECT (appGUI->cal->fullyear_window), "delete_event",
G_CALLBACK (fullyear_window_close_cb), appGUI);
gtk_window_set_transient_for (GTK_WINDOW (appGUI->cal->fullyear_window), GTK_WINDOW (appGUI->main_window));
gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->fullyear_window), 8);
g_signal_connect (G_OBJECT (appGUI->cal->fullyear_window), "key_press_event",
G_CALLBACK (fullyear_key_press_cb), appGUI);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (appGUI->cal->fullyear_window), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 4);
g_snprintf (tmpbuf, BUFFER_SIZE, "<b>%s:</b>", _("Year"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, TRUE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
fy_spinbutton_adj = gtk_adjustment_new (get_gdate_current_year (), JULIAN_GREGORIAN_YEAR, 9999, 1, 10, 10);
appGUI->cal->fy_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (fy_spinbutton_adj), 1, 0);
gtk_widget_show (appGUI->cal->fy_spinbutton);
g_signal_connect(appGUI->cal->fy_spinbutton, "value-changed", G_CALLBACK(change_year_spin_button_cb), appGUI);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->fy_spinbutton, FALSE, FALSE, 8);
gtk_widget_set_size_request (appGUI->cal->fy_spinbutton, 80, -1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton), GTK_UPDATE_IF_VALID);
if (config.default_stock_icons) {
info_button = gui_stock_button (GTK_STOCK_INFO, FALSE);
} else {
info_button = gui_stock_button (OSMO_STOCK_BUTTON_INFO, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(info_button, GTK_CAN_FOCUS);
gtk_widget_show (info_button);
g_signal_connect (info_button, "clicked", G_CALLBACK (year_info_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, info_button, _("Year info"), NULL);
gtk_button_set_relief (GTK_BUTTON (info_button), GTK_RELIEF_NONE);
gtk_box_pack_start (GTK_BOX (hbox1), info_button, FALSE, FALSE, 2);
vseparator = gtk_vseparator_new ();
gtk_widget_show (vseparator);
gtk_box_pack_start (GTK_BOX (hbox1), vseparator, FALSE, FALSE, 8);
if (config.default_stock_icons) {
prev_button = gui_stock_button (GTK_STOCK_GO_BACK, FALSE);
} else {
prev_button = gui_stock_button (OSMO_STOCK_BUTTON_PREV_YEAR, FALSE);
}
GTK_WIDGET_UNSET_FLAGS (prev_button, GTK_CAN_FOCUS);
gtk_widget_show (prev_button);
g_signal_connect (prev_button, "clicked", G_CALLBACK (change_to_previous_year_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, prev_button, _("Previous year"), NULL);
gtk_button_set_relief (GTK_BUTTON (prev_button), GTK_RELIEF_NONE);
gtk_box_pack_start (GTK_BOX (hbox1), prev_button, FALSE, FALSE, 2);
if (config.default_stock_icons) {
appGUI->cal->cyear_button = gui_stock_button (GTK_STOCK_HOME, FALSE);
} else {
appGUI->cal->cyear_button = gui_stock_button (OSMO_STOCK_BUTTON_TODAY, FALSE);
}
GTK_WIDGET_UNSET_FLAGS (appGUI->cal->cyear_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->cal->cyear_button);
g_signal_connect (appGUI->cal->cyear_button, "clicked", G_CALLBACK (change_to_current_year_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->cal->cyear_button, _("Current year"), NULL);
gtk_button_set_relief (GTK_BUTTON (appGUI->cal->cyear_button), GTK_RELIEF_NONE);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->cyear_button, FALSE, FALSE, 2);
if (config.default_stock_icons) {
next_button = gui_stock_button (GTK_STOCK_GO_FORWARD, FALSE);
} else {
next_button = gui_stock_button (OSMO_STOCK_BUTTON_NEXT_YEAR, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(next_button, GTK_CAN_FOCUS);
gtk_widget_show (next_button);
g_signal_connect (next_button, "clicked", G_CALLBACK (change_to_next_year_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, next_button, _("Next year"), NULL);
gtk_button_set_relief (GTK_BUTTON (next_button), GTK_RELIEF_NONE);
gtk_box_pack_start (GTK_BOX (hbox1), next_button, FALSE, FALSE, 2);
vseparator = gtk_vseparator_new ();
gtk_widget_show (vseparator);
gtk_box_pack_start (GTK_BOX (hbox1), vseparator, FALSE, FALSE, 8);
fycal_alternative_view_checkbutton = gtk_check_button_new_with_mnemonic (_("Alternative view"));
GTK_WIDGET_UNSET_FLAGS (fycal_alternative_view_checkbutton, GTK_CAN_FOCUS);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fycal_alternative_view_checkbutton), config.fy_alternative_view);
g_signal_connect (G_OBJECT (fycal_alternative_view_checkbutton), "toggled",
G_CALLBACK (alternative_view_cb), appGUI);
gtk_box_pack_start (GTK_BOX (hbox1), fycal_alternative_view_checkbutton, FALSE, FALSE, 2);
gtk_widget_show (fycal_alternative_view_checkbutton);
#ifdef HAVE_LIBICAL
if (appGUI->calendar_only == FALSE) {
button = gtk_button_new_with_label (_("Browse iCal events"));
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_widget_show (button);
gtk_box_pack_end (GTK_BOX (hbox1), button, FALSE, FALSE, 2);
g_signal_connect (button, "clicked", G_CALLBACK (browse_ical_events_cb), appGUI);
}
#endif /* HAVE_LIBICAL */
fycal_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (fycal_scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox1), fycal_scrolledwindow, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (fycal_scrolledwindow), 4);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (fycal_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
fycal_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (fycal_viewport);
gtk_container_add (GTK_CONTAINER (fycal_scrolledwindow), fycal_viewport);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (fycal_viewport), vbox2);
/*-------------------------------------------------------------------------------------*/
/* First view */
if (config.fy_simple_view == TRUE) {
appGUI->cal->fycal_table_1 = gtk_table_new (MAX_MONTHS + 2, FULL_YEAR_COLS + 1, FALSE);
} else {
appGUI->cal->fycal_table_1 = gtk_table_new (MAX_MONTHS + 4, FULL_YEAR_COLS + 3, FALSE);
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fycal_alternative_view_checkbutton)) == FALSE) {
gtk_widget_show (appGUI->cal->fycal_table_1);
}
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->fycal_table_1, TRUE, TRUE, 0);
vseparator = gtk_vseparator_new ();
gtk_widget_show (vseparator);
if (config.fy_simple_view == TRUE) {
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), vseparator, 1, 2, 0, 14,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
} else {
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), vseparator, 1, 2, 0, 16,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
}
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 2, 39, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
if (config.fy_simple_view == FALSE) {
vseparator = gtk_vseparator_new ();
gtk_widget_show (vseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), vseparator, FULL_YEAR_COLS + 2, FULL_YEAR_COLS + 3, 0, 16,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 2, 39, MAX_MONTHS + 2, MAX_MONTHS + 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, 0, 1, MAX_MONTHS + 2, MAX_MONTHS + 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, FULL_YEAR_COLS + 3, FULL_YEAR_COLS + 4, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), hseparator, FULL_YEAR_COLS + 3, FULL_YEAR_COLS + 4,
MAX_MONTHS + 2, MAX_MONTHS + 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
}
g_date_set_day (cdate, 1);
for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) {
g_date_set_month (cdate, month);
g_date_strftime (buffer, BUFFER_SIZE, config.fy_simple_view ? "%b" : "%B", cdate);
g_snprintf (tmpbuf, BUFFER_SIZE, (month % 2) ? "%s" : "<span foreground='medium blue'>%s</span>", buffer);
label = gtk_label_new (NULL);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, 0, 1, month + 1, month + 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_padding (GTK_MISC (label), 8, 0);
gtk_label_set_markup (GTK_LABEL (label), tmpbuf);
if (config.fy_simple_view == FALSE) {
label = gtk_label_new (NULL);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label,
FULL_YEAR_COLS + 3, FULL_YEAR_COLS + 4, month + 1, month + 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_padding (GTK_MISC (label), 8, 0);
gtk_label_set_markup (GTK_LABEL (label), tmpbuf);
}
}
/* start with monday */
g_date_set_dmy (cdate, 1, 1, 2007);
for (i = 0; i < FULL_YEAR_COLS; i++) {
g_date_set_day (cdate, (i % DAYS_PER_WEEK) + 1);
g_date_strftime (buffer, BUFFER_SIZE, "%a", cdate);
if (i % 7 + 1 == G_DATE_SATURDAY || i % 7 + 1 == G_DATE_SUNDAY) {
g_snprintf (tmpbuf, BUFFER_SIZE, "<span foreground='firebrick'>%s</span>", buffer);
} else {
g_snprintf (tmpbuf, BUFFER_SIZE, "%s", buffer);
}
label = gtk_label_new (NULL);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, i + 2, i + 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_padding (GTK_MISC (label), 4, 0);
gtk_label_set_angle (GTK_LABEL (label), 90);
gtk_label_set_markup (GTK_LABEL (label), tmpbuf);
if (config.fy_simple_view == FALSE) {
label = gtk_label_new (NULL);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), label, i + 2, i + 3, MAX_MONTHS + 3, MAX_MONTHS + 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_padding (GTK_MISC (label), 4, 0);
gtk_label_set_angle (GTK_LABEL (label), 90);
gtk_label_set_markup (GTK_LABEL (label), tmpbuf);
}
}
for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) {
for (j = 0; j < FULL_YEAR_COLS; j++) {
i = month - 1;
idx = i * FULL_YEAR_COLS + j;
appGUI->cal->calendar_buttons[idx] = gtk_button_new ();
GTK_WIDGET_UNSET_FLAGS (appGUI->cal->calendar_buttons[idx], GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON (appGUI->cal->calendar_buttons[idx]), GTK_RELIEF_NONE);
gtk_widget_show (appGUI->cal->calendar_buttons[idx]);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_1), appGUI->cal->calendar_buttons[idx], j+2, j+3, i+2, i+3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
}
}
display_calendar (get_current_year (), appGUI);
gtk_widget_set_sensitive (appGUI->cal->cyear_button, FALSE);
/*-------------------------------------------------------------------------------------*/
/* Second view */
appGUI->cal->fycal_table_2 = gtk_table_new (3, 4, FALSE);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fycal_alternative_view_checkbutton)) == TRUE) {
gtk_widget_show (appGUI->cal->fycal_table_2);
}
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->cal->fycal_table_2, TRUE, TRUE, 0);
for (i = y = 0; y < 3; y++) {
for (x = 0; x < 4; x++, i++) {
fycal_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (fycal_vbox);
gtk_table_attach (GTK_TABLE (appGUI->cal->fycal_table_2), fycal_vbox, x, x + 1, y, y + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
fycal_label = gtk_label_new (NULL);
gtk_widget_show (fycal_label);
gtk_box_pack_start (GTK_BOX (fycal_vbox), fycal_label, FALSE, FALSE, 0);
appGUI->cal->fy_calendars[i] = gui_calendar_new ();
gtk_widget_show (appGUI->cal->fy_calendars[i]);
GTK_WIDGET_UNSET_FLAGS (appGUI->cal->fy_calendars[i], GTK_CAN_FOCUS);
gui_calendar_set_display_options (GUI_CALENDAR (appGUI->cal->fy_calendars[i]),
(config.display_options & (GUI_CALENDAR_SHOW_DAY_NAMES |
GUI_CALENDAR_WEEK_START_MONDAY)) | GUI_CALENDAR_NO_MONTH_CHANGE);
gui_calendar_enable_cursor (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), FALSE);
gui_calendar_set_event_marker_type (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.event_marker_type);
gui_calendar_set_event_marker_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.mark_color);
gui_calendar_set_selector_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.selection_color);
gui_calendar_set_header_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.header_color);
gui_calendar_set_weekend_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.weekend_color);
gui_calendar_set_day_note_marker_type (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.day_note_marker);
gui_calendar_set_today_marker_type (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.today_marker_type);
gui_calendar_set_today_marker_color (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.mark_current_day_color);
gui_calendar_set_today_marker_alpha (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), config.mark_current_day_alpha);
year = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton));
month = i + 1;
gui_calendar_select_month (GUI_CALENDAR (appGUI->cal->fy_calendars[i]), month - 1, year);
mark_events (appGUI->cal->fy_calendars[i], month - 1, year, appGUI);
g_date_set_dmy (cdate, 1, month, year);
g_date_strftime (buffer, BUFFER_SIZE, "%B", cdate);
gtk_label_set_text (GTK_LABEL (fycal_label), buffer);
gtk_box_pack_start (GTK_BOX (fycal_vbox), appGUI->cal->fy_calendars[i], FALSE, FALSE, 0);
}
}
/*-------------------------------------------------------------------------------------*/
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4);
if (config.default_stock_icons) {
close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
} else {
close_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CLOSE);
}
gtk_widget_show (close_button);
g_signal_connect (close_button, "clicked", G_CALLBACK (button_fullyear_window_close_cb), appGUI);
gtk_container_add (GTK_CONTAINER (hbuttonbox), close_button);
gtk_widget_show (appGUI->cal->fullyear_window);
}
static GtkWidget *
get_config_frame(PurplePlugin *plugin)
{
GString
*base_dir_name= NULL,
*lang_dir_name= NULL;
GtkObject *stretch_duration_adjustment;
GtkObject *maxlength_adjustment;
GtkWidget
*parent,
*config_vbox, *voices_vbox, *stretch_duration_hbox, *maxlength_hbox,
*frame,
*radio_button,
*message_label,
*stretch_duration_spinbutton,
*maxlength_spinbutton,
*prepend_who_checkbutton,
*replace_url_checkbutton,
*announce_events_checkbutton;
GSList *radio_group=NULL;
DIR *dir, *lang_dir;
struct dirent *next_lang, *next_voice;
int count_lang, count_voices;
int can_activate_voice= FALSE;
parent = gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(parent), 12);
config_vbox = (GtkWidget *) pidgin_make_frame(parent, _("Festival"));
gtk_container_set_border_width(GTK_CONTAINER(config_vbox), 5);
/*--------------- Available Voices -----------*/
base_dir_name= g_string_new(FESTIVAL_VOICES_PATH);
lang_dir_name= g_string_new("");
message_label= gtk_label_new(_("Availables voices:"));
gtk_box_pack_start(GTK_BOX(config_vbox),message_label,FALSE,TRUE,3);
//Examine directory for voices
dir= opendir(base_dir_name->str);
if(!dir) {
GString *error_name;
error_name= g_string_new("");
g_string_printf(error_name, _("Error opening voices directory: %s"), base_dir_name->str);
message_label= gtk_label_new(error_name->str);
g_string_free(error_name,TRUE);
gtk_box_pack_start(GTK_BOX(config_vbox),message_label,FALSE,TRUE,3);
}
else {
count_lang=0;
while( ( next_lang = readdir(dir) ) !=0 ) {
/* hide hidden files */
if( *next_lang->d_name == '.' )
continue;
frame= gtk_frame_new(next_lang->d_name);
gtk_box_pack_start(GTK_BOX(config_vbox),frame,FALSE,TRUE,3);
voices_vbox= gtk_vbox_new(FALSE,5);
gtk_container_set_border_width(GTK_CONTAINER(voices_vbox), 5);
gtk_container_add(GTK_CONTAINER(frame),voices_vbox);
g_string_printf(lang_dir_name,"%s/%s",base_dir_name->str,next_lang->d_name);
lang_dir= opendir(lang_dir_name->str);
if(!lang_dir) {
GString *error_name;
error_name= g_string_new("");
g_string_printf( error_name, _("Error opening voice directory: %s"), lang_dir_name->str);
message_label= gtk_label_new(error_name->str);
g_string_free(error_name,TRUE);
gtk_box_pack_start( GTK_BOX(voices_vbox), message_label, FALSE, TRUE, 3);
break;
}
count_voices=0;
while( ( next_voice = readdir(lang_dir) )!=0 ) {
GString *voice_name;
/* hide hidden files */
if( *next_voice->d_name == '.' )
continue;
radio_button= gtk_radio_button_new_with_label(radio_group,next_voice->d_name);
if( purple_prefs_get_string("/plugins/gtk/festival/speaker/voice") &&
strcmp(purple_prefs_get_string("/plugins/gtk/festival/speaker/voice"),next_voice->d_name ) == 0) {
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(radio_button),TRUE );
can_activate_voice= TRUE;
}
voice_name= g_string_new(next_voice->d_name);
g_signal_connect(GTK_OBJECT(radio_button),"clicked", G_CALLBACK(on_radio_clicked), voice_name);
g_signal_connect(GTK_OBJECT(radio_button),"destroy", G_CALLBACK(on_radio_destroy), voice_name);
gtk_box_pack_start(GTK_BOX(voices_vbox), radio_button, FALSE, TRUE, 3);
radio_group= gtk_radio_button_get_group( GTK_RADIO_BUTTON(radio_button) );
}
closedir(lang_dir);
}
closedir(dir);
}
g_string_free(base_dir_name,TRUE);
g_string_free(lang_dir_name,TRUE);
/*--------------- Replace URL -----------*/
replace_url_checkbutton = gtk_check_button_new_with_label( _("Replace \"http://www.someurl.com\" with URL"));
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/replace_url"))
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(replace_url_checkbutton), TRUE);
g_signal_connect(G_OBJECT(replace_url_checkbutton), "clicked",
G_CALLBACK(on_replace_url_checkbutton_clicked), NULL);
gtk_box_pack_end(GTK_BOX(config_vbox),replace_url_checkbutton,FALSE,TRUE,3);
/*--------------- Prepend Alias -----------*/
prepend_who_checkbutton = gtk_check_button_new_with_label(_("Prepend Buddy Name (Alias) to message"));
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/prepend_who"))
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(prepend_who_checkbutton), TRUE);
g_signal_connect(G_OBJECT(prepend_who_checkbutton), "clicked",
G_CALLBACK(on_prepend_who_checkbutton_clicked), NULL);
gtk_box_pack_end(GTK_BOX(config_vbox),prepend_who_checkbutton,FALSE,TRUE,3);
/*--------------- Announce Events -----------*/
announce_events_checkbutton = gtk_check_button_new_with_label(_("Announce events"));
if(purple_prefs_get_bool("/plugins/gtk/festival/speaker/announce_events"))
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(announce_events_checkbutton), TRUE);
g_signal_connect(G_OBJECT(announce_events_checkbutton), "clicked",
G_CALLBACK(on_announce_events_checkbutton_clicked), NULL);
gtk_box_pack_end(GTK_BOX(config_vbox),announce_events_checkbutton,FALSE,TRUE,3);
/*--------------- Duration -----------*/
stretch_duration_hbox= gtk_hbox_new(FALSE,3);
stretch_duration_adjustment= gtk_adjustment_new(1.0,0.3,10.0,0.1,1.0,1.0);
stretch_duration_spinbutton= gtk_spin_button_new(GTK_ADJUSTMENT(stretch_duration_adjustment),0.1,1);
g_signal_connect(G_OBJECT(stretch_duration_spinbutton), "value_changed",
G_CALLBACK(on_stretch_duration_spinbutton_changed), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(stretch_duration_spinbutton),GTK_UPDATE_IF_VALID);
gtk_entry_set_editable(GTK_ENTRY(stretch_duration_spinbutton),FALSE);
gtk_box_pack_start(GTK_BOX(stretch_duration_hbox),gtk_label_new(_("Pitch")),FALSE,FALSE,3);
gtk_box_pack_start(GTK_BOX(stretch_duration_hbox),stretch_duration_spinbutton,FALSE,FALSE,3);
gtk_box_pack_end(GTK_BOX(config_vbox),stretch_duration_hbox,FALSE,TRUE,3);
gtk_spin_button_set_value( GTK_SPIN_BUTTON(stretch_duration_spinbutton),
atof (purple_prefs_get_string("/plugins/gtk/festival/speaker/duration")));
/*--------------- Max Length -----------*/
maxlength_hbox= gtk_hbox_new(FALSE,3);
maxlength_adjustment= gtk_adjustment_new(256,0,1000,1,256,256);
maxlength_spinbutton= gtk_spin_button_new(GTK_ADJUSTMENT(maxlength_adjustment),1,0);
g_signal_connect(G_OBJECT(maxlength_spinbutton), "value_changed",
G_CALLBACK(on_maxlength_spinbutton_changed), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(maxlength_spinbutton),GTK_UPDATE_IF_VALID);
gtk_entry_set_editable(GTK_ENTRY(maxlength_spinbutton),FALSE);
gtk_box_pack_start(GTK_BOX(maxlength_hbox),gtk_label_new(_("Max Length")),FALSE,FALSE,3);
gtk_box_pack_start(GTK_BOX(maxlength_hbox),maxlength_spinbutton,FALSE,FALSE,3);
gtk_box_pack_end(GTK_BOX(config_vbox),maxlength_hbox,FALSE,TRUE,3);
gtk_spin_button_set_value( GTK_SPIN_BUTTON(maxlength_spinbutton),
purple_prefs_get_int("/plugins/gtk/festival/speaker/maxlength"));
if(!can_activate_voice && radio_group) {
GtkRadioButton *default_radio;
default_radio= GTK_RADIO_BUTTON( g_slist_nth(radio_group,0)->data );
gtk_button_clicked( GTK_BUTTON(default_radio) );
}
gtk_widget_show_all(parent);
return parent;
}
/** \brief Create and initialise time controller widgets.
* \param module The parent GtkSatModule
*
*/
void tmg_create (GtkSatModule *mod)
{
GtkWidget *vbox, *hbox, *table;
GtkWidget *image;
GtkWidget *label;
gchar *title;
gchar *buff;
/* make sure controller is not already active */
if (mod->tmgActive) {
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s is already active"),
__FUNCTION__, mod->name);
/* try to make window visible in case it is covered
by something else */
gtk_window_present (GTK_WINDOW (mod->tmgWin));
return;
}
/* create hbox containing the controls
the controls are implemented as radiobuttons in order
to inherit the mutual exclusion behaviour
*/
hbox = gtk_hbox_new (FALSE, 0);
/* FWD */
mod->tmgFwd = gtk_radio_button_new (NULL);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgFwd), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mod->tmgFwd), TRUE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgFwd), image);
gtk_widget_set_tooltip_text (mod->tmgFwd, _("Play forward"));
g_signal_connect (mod->tmgFwd, "toggled", G_CALLBACK (tmg_fwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgFwd, FALSE, FALSE, 0);
/* STOP */
mod->tmgStop = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgStop), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgStop), image);
gtk_widget_set_tooltip_text (mod->tmgStop, _("Stop"));
g_signal_connect (mod->tmgStop, "toggled", G_CALLBACK (tmg_stop), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgStop, FALSE, FALSE, 0);
/* BWD */
mod->tmgBwd = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (mod->tmgFwd));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (mod->tmgBwd), FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (mod->tmgBwd), image);
gtk_widget_set_tooltip_text (mod->tmgBwd, _("Play backwards"));
g_signal_connect (mod->tmgBwd, "toggled", G_CALLBACK (tmg_bwd), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgBwd, FALSE, FALSE, 0);
/* reset time */
mod->tmgReset = gtk_button_new_with_label (_("Reset"));
gtk_widget_set_tooltip_text (mod->tmgReset, _("Reset to current date and time"));
g_signal_connect (mod->tmgReset, "clicked", G_CALLBACK (tmg_reset), mod);
gtk_box_pack_end (GTK_BOX (hbox), mod->tmgReset, FALSE, FALSE, 10);
/* status label */
mod->tmgState = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (mod->tmgState), 0.0, 0.5);
gtk_label_set_markup (GTK_LABEL (mod->tmgState), _("<b>Real-Time</b>"));
gtk_box_pack_start (GTK_BOX (hbox), mod->tmgState, TRUE, TRUE, 10);
/* create table containing the date and time widgets */
table = gtk_table_new (5, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 0);
mod->tmgCal = gtk_calendar_new ();
gtk_calendar_set_display_options (GTK_CALENDAR (mod->tmgCal),
GTK_CALENDAR_SHOW_HEADING |
GTK_CALENDAR_SHOW_DAY_NAMES |
GTK_CALENDAR_WEEK_START_MONDAY);
g_signal_connect (mod->tmgCal, "day-selected",
G_CALLBACK (tmg_time_set), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgCal,
0, 1, 0, 5, GTK_SHRINK, GTK_SHRINK,
0, 0);
/* Time controllers.
Note that the controllers for hours, minutes, and seconds have ranges;
however, they can wrap around their limits in order to ensure a smooth
and continuous control of the time
*/
/* hour */
label = gtk_label_new (_(" Hour:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgHour = gtk_spin_button_new_with_range (0, 23, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgHour),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgHour), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgHour), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgHour), 2);
gtk_widget_set_tooltip_text (mod->tmgHour,
_("Use this control to set the hour"));
g_signal_connect (mod->tmgHour, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgHour, "wrapped", G_CALLBACK (tmg_hour_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgHour,
2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* minutes */
label = gtk_label_new (_(" Min:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMin = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMin), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMin), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMin), 2);
gtk_widget_set_tooltip_text (mod->tmgMin,
_("Use this control to set the minutes"));
g_signal_connect (mod->tmgMin, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMin, "wrapped", G_CALLBACK (tmg_min_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMin,
2, 3, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* seconds */
label = gtk_label_new (_(" Sec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 2, 3, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgSec = gtk_spin_button_new_with_range (0, 59, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgSec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgSec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgSec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgSec), 2);
gtk_widget_set_tooltip_text (mod->tmgSec,
_("Use this control to set the seconds"));
g_signal_connect (mod->tmgSec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgSec, "wrapped", G_CALLBACK (tmg_sec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgSec,
2, 3, 2, 3, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* milliseconds */
label = gtk_label_new (_(" Msec:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 3, 4, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgMsec = gtk_spin_button_new_with_range (0, 999, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgMsec),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgMsec), 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (mod->tmgMsec), TRUE);
//FIXME gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgMsec), 2);
gtk_widget_set_tooltip_text (mod->tmgMsec,
_("Use this control to set the milliseconds"));
g_signal_connect (mod->tmgMsec, "value-changed",
G_CALLBACK (tmg_time_set), mod);
g_signal_connect (mod->tmgMsec, "wrapped", G_CALLBACK (tmg_msec_wrap), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgMsec,
2, 3, 3, 4, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* time throttle */
label = gtk_label_new (_("Throttle:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 5, 0);
mod->tmgFactor = gtk_spin_button_new_with_range (1, 100, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (mod->tmgFactor), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (mod->tmgFactor),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (mod->tmgFactor), 0);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (mod->tmgFactor), 1);
gtk_widget_set_tooltip_text (mod->tmgFactor,
_("Time throttle / compression factor"));
g_signal_connect (mod->tmgFactor, "value-changed",
G_CALLBACK (tmg_throttle), mod);
gtk_table_attach (GTK_TABLE (table), mod->tmgFactor,
2, 3, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0);
/* add slider */
mod->tmgSlider = gtk_hscale_new_with_range (-0.1, +0.1, 0.0001); // +/- 2.5 hr
/*gtk_widget_set_tooltip_text (mod->tmgSlider,
_("Drag the slider to change the time up to +/- 2.5 hours.\n"\
"Resolution is ~ 8 seconds."));*/
gtk_scale_set_draw_value (GTK_SCALE (mod->tmgSlider), FALSE);
gtk_range_set_value (GTK_RANGE (mod->tmgSlider), 0.0);
g_signal_connect (mod->tmgSlider, "value-changed",
G_CALLBACK (slider_moved), mod);
/* create the vertical box */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), mod->tmgSlider, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* create main window */
mod->tmgWin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
title = g_strconcat (_("Time Controller"), " / ", mod->name, NULL);
gtk_window_set_title (GTK_WINDOW (mod->tmgWin), title);
g_free (title);
gtk_window_set_transient_for (GTK_WINDOW (mod->tmgWin),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (mod))));
g_signal_connect (G_OBJECT (mod->tmgWin), "delete_event",
G_CALLBACK (tmg_delete), mod);
g_signal_connect (G_OBJECT (mod->tmgWin), "destroy",
G_CALLBACK (tmg_destroy), mod);
/* window icon */
buff = icon_file_name ("gpredict-clock.png");
gtk_window_set_icon_from_file (GTK_WINDOW (mod->tmgWin), buff, NULL);
g_free (buff);
gtk_container_add (GTK_CONTAINER (mod->tmgWin), vbox);
gtk_widget_show_all (mod->tmgWin);
mod->tmgActive = TRUE;
sat_log_log (SAT_LOG_LEVEL_INFO,
_("%s: Time Controller for %s launched"),
__FUNCTION__, mod->name);
}
/*****************************************************************************
* create_session_save_dialog()
*****************************************************************************/
void
create_session_save_dialog(void)
{
GError *error = NULL;
GtkWidget *hbox;
GtkWidget *label;
int new_adj = (session_io_start_adj == NULL);
/* this should only need to happen once */
if (session_save_dialog == NULL) {
/* create dialog */
session_save_dialog = gtk_file_chooser_dialog_new("PHASEX - Save Session",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(session_save_dialog), "phasex", "phasex-save");
gtk_window_set_role(GTK_WINDOW(session_save_dialog), "session-save");
gtk_file_chooser_set_preview_widget_active
(GTK_FILE_CHOOSER(session_save_dialog), FALSE);
/* create spinbutton control of session number */
hbox = gtk_hbox_new(FALSE, 8);
label = gtk_label_new("Save into session #:");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8);
if (new_adj) {
session_io_start_adj = gtk_adjustment_new(0, 1, PATCH_BANK_SIZE, 1, 8, 0);
}
session_save_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_save_start_spin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));
gtk_box_pack_start(GTK_BOX(hbox), session_save_start_spin, FALSE, FALSE, 8);
if (new_adj) {
g_signal_connect(GTK_OBJECT(session_save_start_spin), "value_changed",
GTK_SIGNAL_FUNC(set_session_io_start),
(gpointer) session_io_start_adj);
}
gtk_widget_show_all(hbox);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(session_save_dialog), hbox);
/* realize the file chooser before telling it about files */
gtk_widget_realize(session_save_dialog);
#if GTK_CHECK_VERSION(2, 8, 0)
/* this can go away once manual overwrite checks are proven to work properly */
gtk_file_chooser_set_do_overwrite_confirmation
(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
/* add user session dir as shortcut folder (user cannot write to sys) */
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
/* start in user session dir (usually ~/.phasex/user-sessions) */
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir);
}
}
static void mateweather_pref_create(MateWeatherPref* pref)
{
GtkWidget* pref_vbox;
GtkWidget* pref_notebook;
#ifdef RADARMAP
GtkWidget* radar_toggle_hbox;
#endif /* RADARMAP */
GtkWidget* pref_basic_update_alignment;
GtkWidget* pref_basic_update_lbl;
GtkWidget* pref_basic_update_hbox;
GObject* pref_basic_update_spin_adj;
GtkWidget* pref_basic_update_sec_lbl;
GtkWidget* pref_basic_note_lbl;
GtkWidget* pref_loc_hbox;
GtkWidget* pref_loc_note_lbl;
GtkWidget* scrolled_window;
GtkWidget* label;
GtkWidget* value_hbox;
GtkWidget* tree_label;
GtkTreeSelection *selection;
GtkWidget* pref_basic_vbox;
GtkWidget* vbox;
GtkWidget* frame;
GtkWidget* temp_label;
GtkWidget* temp_combo;
GtkWidget* speed_label;
GtkWidget* speed_combo;
GtkWidget* pres_label;
GtkWidget* pres_combo;
GtkWidget* dist_label;
GtkWidget* dist_combo;
#if GTK_CHECK_VERSION (3, 0, 0)
GtkWidget* unit_grid;
#else
GtkWidget* unit_table;
#endif
GtkWidget* pref_find_label;
GtkWidget* pref_find_hbox;
GtkWidget* image;
g_object_set (pref, "destroy-with-parent", TRUE, NULL);
gtk_window_set_title (GTK_WINDOW (pref), _("Weather Preferences"));
gtk_dialog_add_buttons (GTK_DIALOG (pref), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE);
gtk_container_set_border_width (GTK_CONTAINER (pref), 5);
gtk_window_set_resizable (GTK_WINDOW (pref), TRUE);
gtk_window_set_screen (GTK_WINDOW (pref), gtk_widget_get_screen (GTK_WIDGET (pref->priv->applet->applet)));
pref_vbox = gtk_dialog_get_content_area (GTK_DIALOG (pref));
gtk_box_set_spacing (GTK_BOX (pref_vbox), 2);
gtk_widget_show (pref_vbox);
pref_notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (pref_notebook), 5);
gtk_widget_show (pref_notebook);
gtk_box_pack_start (GTK_BOX (pref_vbox), pref_notebook, TRUE, TRUE, 0);
/*
* General settings page.
*/
#if GTK_CHECK_VERSION (3, 0, 0)
pref_basic_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
#else
pref_basic_vbox = gtk_vbox_new (FALSE, 18);
#endif
gtk_container_set_border_width (GTK_CONTAINER (pref_basic_vbox), 12);
gtk_container_add (GTK_CONTAINER (pref_notebook), pref_basic_vbox);
pref_basic_update_alignment = gtk_alignment_new (0, 0.5, 0, 1);
gtk_widget_show (pref_basic_update_alignment);
pref->priv->basic_update_btn = gtk_check_button_new_with_mnemonic (_("_Automatically update every:"));
gtk_widget_show (pref->priv->basic_update_btn);
gtk_container_add (GTK_CONTAINER (pref_basic_update_alignment), pref->priv->basic_update_btn);
g_signal_connect (G_OBJECT (pref->priv->basic_update_btn), "toggled", G_CALLBACK (auto_update_toggled), pref);
if (!g_settings_is_writable (pref->priv->applet->settings, "auto-update"))
{
hard_set_sensitive (pref->priv->basic_update_btn, FALSE);
}
/*
* Units settings page.
*/
/* Temperature Unit */
temp_label = gtk_label_new_with_mnemonic (_("_Temperature unit:"));
gtk_label_set_use_markup (GTK_LABEL (temp_label), TRUE);
gtk_label_set_justify (GTK_LABEL (temp_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (temp_label), 0.0, 0.5);
#endif
gtk_widget_show (temp_label);
temp_combo = gtk_combo_box_text_new ();
pref->priv->basic_temp_combo = temp_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (temp_label), temp_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Default"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Kelvin"));
/* TRANSLATORS: Celsius is sometimes referred Centigrade */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Celsius"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Fahrenheit"));
gtk_widget_show (temp_combo);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "temperature-unit"))
{
hard_set_sensitive (pref->priv->basic_temp_combo, FALSE);
}
/* Speed Unit */
speed_label = gtk_label_new_with_mnemonic (_("_Wind speed unit:"));
gtk_label_set_use_markup (GTK_LABEL (speed_label), TRUE);
gtk_label_set_justify (GTK_LABEL (speed_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (speed_label), 0.0, 0.5);
#endif
gtk_widget_show (speed_label);
speed_combo = gtk_combo_box_text_new ();
pref->priv->basic_speed_combo = speed_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (speed_label), speed_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("Default"));
/* TRANSLATOR: The wind speed unit "meters per second" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("m/s"));
/* TRANSLATOR: The wind speed unit "kilometers per hour" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("km/h"));
/* TRANSLATOR: The wind speed unit "miles per hour" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("mph"));
/* TRANSLATOR: The wind speed unit "knots" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("knots"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("Beaufort scale"));
gtk_widget_show (speed_combo);
if (!g_settings_is_writable (pref->priv->applet->settings, "speed-unit"))
{
hard_set_sensitive (pref->priv->basic_speed_combo, FALSE);
}
/* Pressure Unit */
pres_label = gtk_label_new_with_mnemonic (_("_Pressure unit:"));
gtk_label_set_use_markup (GTK_LABEL (pres_label), TRUE);
gtk_label_set_justify (GTK_LABEL (pres_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (pres_label), 0.0, 0.5);
#endif
gtk_widget_show (pres_label);
pres_combo = gtk_combo_box_text_new ();
pref->priv->basic_pres_combo = pres_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (pres_label), pres_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("Default"));
/* TRANSLATOR: The pressure unit "kiloPascals" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("kPa"));
/* TRANSLATOR: The pressure unit "hectoPascals" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("hPa"));
/* TRANSLATOR: The pressure unit "millibars" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mb"));
/* TRANSLATOR: The pressure unit "millibars of mercury" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mmHg"));
/* TRANSLATOR: The pressure unit "inches of mercury" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("inHg"));
/* TRANSLATOR: The pressure unit "atmospheres" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("atm"));
gtk_widget_show (pres_combo);
if (!g_settings_is_writable(pref->priv->applet->settings, "pressure-unit"))
{
hard_set_sensitive(pref->priv->basic_pres_combo, FALSE);
}
/* Distance Unit */
dist_label = gtk_label_new_with_mnemonic (_("_Visibility unit:"));
gtk_label_set_use_markup (GTK_LABEL (dist_label), TRUE);
gtk_label_set_justify (GTK_LABEL (dist_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (dist_label), 0, 0.5);
#endif
gtk_widget_show (dist_label);
dist_combo = gtk_combo_box_text_new ();
pref->priv->basic_dist_combo = dist_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (dist_label), dist_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("Default"));
/* TRANSLATOR: The distance unit "meters" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("meters"));
/* TRANSLATOR: The distance unit "kilometers" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("km"));
/* TRANSLATOR: The distance unit "miles" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("miles"));
gtk_widget_show (dist_combo);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "distance-unit"))
hard_set_sensitive (pref->priv->basic_dist_combo, FALSE);
#if GTK_CHECK_VERSION (3, 0, 0)
unit_grid = gtk_grid_new ();
gtk_grid_set_row_spacing(GTK_GRID(unit_grid), 6);
gtk_grid_set_column_spacing(GTK_GRID(unit_grid), 12);
gtk_widget_set_halign (temp_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), temp_label, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), temp_combo, 1, 0, 1, 1);
gtk_widget_set_halign (speed_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), speed_label, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), speed_combo, 1, 1, 1, 1);
gtk_widget_set_halign (pres_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), pres_label, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), pres_combo, 1, 2, 1, 1);
gtk_widget_set_halign (dist_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), dist_label, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), dist_combo, 1, 3, 1, 1);
gtk_widget_show(unit_grid);
#else
unit_table = gtk_table_new(5, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(unit_table), 6);
gtk_table_set_col_spacings(GTK_TABLE(unit_table), 12);
gtk_table_attach(GTK_TABLE(unit_table), temp_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), temp_combo, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(unit_table), speed_label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), speed_combo, 1, 2, 1, 2);
gtk_table_attach(GTK_TABLE(unit_table), pres_label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), pres_combo, 1, 2, 2, 3);
gtk_table_attach(GTK_TABLE(unit_table), dist_label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), dist_combo, 1, 2, 3, 4);
gtk_widget_show(unit_table);
#endif
g_signal_connect (temp_combo, "changed", G_CALLBACK (temp_combo_changed_cb), pref);
g_signal_connect (speed_combo, "changed", G_CALLBACK (speed_combo_changed_cb), pref);
g_signal_connect (dist_combo, "changed", G_CALLBACK (dist_combo_changed_cb), pref);
g_signal_connect (pres_combo, "changed", G_CALLBACK (pres_combo_changed_cb), pref);
#ifdef RADARMAP
pref->priv->basic_radar_btn = gtk_check_button_new_with_mnemonic (_("Enable _radar map"));
gtk_widget_show (pref->priv->basic_radar_btn);
g_signal_connect (G_OBJECT (pref->priv->basic_radar_btn), "toggled", G_CALLBACK (radar_toggled), pref);
if (!g_settings_is_writable (pref->priv->applet->settings, "enable-radar-map"))
{
hard_set_sensitive(pref->priv->basic_radar_btn, FALSE);
}
#if GTK_CHECK_VERSION (3, 0, 0)
radar_toggle_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
#else
radar_toggle_hbox = gtk_hbox_new(FALSE, 12);
#endif
gtk_widget_show(radar_toggle_hbox);
label = gtk_label_new (" ");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), label, FALSE, FALSE, 0);
pref->priv->basic_radar_url_btn = gtk_check_button_new_with_mnemonic (_("Use _custom address for radar map"));
gtk_widget_show (pref->priv->basic_radar_url_btn);
gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), pref->priv->basic_radar_url_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_btn), "toggled", G_CALLBACK (use_radar_url_toggled), pref);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "use-custom-radar-url"))
{
hard_set_sensitive (pref->priv->basic_radar_url_btn, FALSE);
}
#if GTK_CHECK_VERSION (3, 0, 0)
pref->priv->basic_radar_url_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
pref->priv->basic_radar_url_hbox = gtk_hbox_new (FALSE, 12);
#endif
gtk_widget_show (pref->priv->basic_radar_url_hbox);
label = gtk_label_new (" ");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("A_ddress:"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0);
pref->priv->basic_radar_url_entry = gtk_entry_new ();
gtk_widget_show (pref->priv->basic_radar_url_entry);
gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), pref->priv->basic_radar_url_entry, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_entry), "focus_out_event", G_CALLBACK (radar_url_changed), pref);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "radar"))
{
hard_set_sensitive (pref->priv->basic_radar_url_entry, FALSE);
}
#endif /* RADARMAP */
#ifdef HAVE_LIBNOTIFY
/* setup show-notifications button */
pref->priv->basic_show_notifications_btn = gtk_check_button_new_with_mnemonic (_("Show _notifications"));
if (!g_settings_is_writable (pref->priv->applet->settings, "show-notifications"))
{
hard_set_sensitive (pref->priv->basic_show_notifications_btn, FALSE);
}
g_signal_connect (G_OBJECT (pref->priv->basic_show_notifications_btn), "toggled", G_CALLBACK (show_notifications_toggled), pref);
#endif
frame = create_hig_category (pref_basic_vbox, _("Update"));
#if GTK_CHECK_VERSION (3, 0, 0)
pref_basic_update_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
pref_basic_update_hbox = gtk_hbox_new (FALSE, 12);
#endif
pref_basic_update_lbl = gtk_label_new_with_mnemonic (_("_Automatically update every:"));
gtk_widget_show (pref_basic_update_lbl);
gtk_widget_show (pref_basic_update_hbox);
pref_basic_update_spin_adj = gtk_adjustment_new (30, 1, 3600, 5, 25, 1);
pref->priv->basic_update_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pref_basic_update_spin_adj), 1, 0);
gtk_widget_show (pref->priv->basic_update_spin);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), GTK_UPDATE_IF_VALID);
g_signal_connect (G_OBJECT (pref->priv->basic_update_spin), "value_changed", G_CALLBACK (update_interval_changed), pref);
pref_basic_update_sec_lbl = gtk_label_new (_("minutes"));
gtk_widget_show (pref_basic_update_sec_lbl);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "auto-update-interval"))
{
hard_set_sensitive (pref->priv->basic_update_spin, FALSE);
hard_set_sensitive (pref_basic_update_sec_lbl, FALSE);
}
#if GTK_CHECK_VERSION (3, 0, 0)
value_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
value_hbox = gtk_hbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), pref_basic_update_alignment, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), value_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (value_hbox), pref->priv->basic_update_spin, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (value_hbox), pref_basic_update_sec_lbl, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), pref_basic_update_hbox);
frame = create_hig_category (pref_basic_vbox, _("Display"));
#if GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_box_pack_start (GTK_BOX (vbox), unit_grid, TRUE, TRUE, 0);
#else
gtk_box_pack_start (GTK_BOX (vbox), unit_table, TRUE, TRUE, 0);
#endif
#ifdef RADARMAP
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_btn, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), radar_toggle_hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_url_hbox, TRUE, TRUE, 0);
#endif /* RADARMAP */
#ifdef HAVE_LIBNOTIFY
/* add the show-notification toggle button to the vbox of the display section */
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_show_notifications_btn, TRUE, TRUE, 0);
#endif
gtk_container_add (GTK_CONTAINER (frame), vbox);
pref_basic_note_lbl = gtk_label_new (_("General"));
gtk_widget_show (pref_basic_note_lbl);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 0), pref_basic_note_lbl);
/*
* Location page.
*/
#if GTK_CHECK_VERSION (3, 0, 0)
pref_loc_hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
pref_loc_hbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_container_set_border_width (GTK_CONTAINER (pref_loc_hbox), 12);
gtk_container_add (GTK_CONTAINER (pref_notebook), pref_loc_hbox);
tree_label = gtk_label_new_with_mnemonic (_("_Select a location:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (tree_label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (tree_label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (pref_loc_hbox), tree_label, FALSE, FALSE, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
pref->priv->tree = gtk_tree_view_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (tree_label), GTK_WIDGET (pref->priv->tree));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pref->priv->tree), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pref->priv->tree));
g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (row_selected_cb), pref);
gtk_container_add (GTK_CONTAINER (scrolled_window), pref->priv->tree);
gtk_widget_show (pref->priv->tree);
gtk_widget_show (scrolled_window);
gtk_box_pack_start (GTK_BOX (pref_loc_hbox), scrolled_window, TRUE, TRUE, 0);
load_locations(pref);
#if GTK_CHECK_VERSION (3, 0, 0)
pref_find_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
pref_find_hbox = gtk_hbox_new (FALSE, 6);
#endif
pref_find_label = gtk_label_new (_("_Find:"));
gtk_label_set_use_underline (GTK_LABEL (pref_find_label), TRUE);
pref->priv->find_entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (pref_find_label), pref->priv->find_entry);
pref->priv->find_next_btn = gtk_button_new_with_mnemonic (_("Find _Next"));
gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (pref->priv->find_next_btn), image);
g_signal_connect (G_OBJECT (pref->priv->find_next_btn), "clicked", G_CALLBACK (find_next_clicked), pref);
g_signal_connect (G_OBJECT (pref->priv->find_entry), "changed", G_CALLBACK (find_entry_changed), pref);
gtk_container_set_border_width (GTK_CONTAINER (pref_find_hbox), 0);
gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref_find_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_next_btn, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (pref_loc_hbox), pref_find_hbox, FALSE, FALSE, 0);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "location0"))
{
hard_set_sensitive (scrolled_window, FALSE);
}
pref_loc_note_lbl = gtk_label_new (_("Location"));
gtk_widget_show (pref_loc_note_lbl);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 1), pref_loc_note_lbl);
g_signal_connect (G_OBJECT (pref), "response", G_CALLBACK (response_cb), pref);
mateweather_pref_set_accessibility (pref);
gtk_label_set_mnemonic_widget (GTK_LABEL (pref_basic_update_sec_lbl), pref->priv->basic_update_spin);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), pref->priv->basic_radar_url_entry);
}
void addParams (GtkNotebook *notebook, PluginParameters *params) {
int n;
GtkWidget *table = gtk_table_new (params->nbParams, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 11);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
for (n=0;n<params->nbParams;++n) {
if (params->params[n] == 0) {
GtkWidget *hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 5);
} else {
PluginParam *p = params->params[n];
if (p->type != PARAM_BOOLVAL) {
GtkWidget *label4 = gtk_label_new (p->name);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table), label4, 0, 1, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
}
switch (p->type) {
case PARAM_INTVAL: {
GtkWidget *spinbutton_adj,*spinbutton;
spinbutton_adj = (GtkWidget*)gtk_adjustment_new (
p->param.ival.value,
p->param.ival.min, p->param.ival.max,
p->param.ival.step, p->param.ival.step*10,
p->param.ival.step*10);
spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_adj), 1, 0);
gtk_widget_show (spinbutton);
gtk_table_attach (GTK_TABLE (table), spinbutton, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinbutton),
GTK_UPDATE_IF_VALID);
p->user_data = spinbutton;
gtk_object_set_data (GTK_OBJECT(spinbutton),"param",(void*)p);
p->change_listener = my_int_listener;
gtk_signal_connect (GTK_OBJECT (spinbutton), "changed",
GTK_SIGNAL_FUNC (on_spinbutton_int_changed),
NULL);
break;
}
case PARAM_FLOATVAL: {
GtkWidget *progress,*prog_adj;
prog_adj = (GtkWidget*)gtk_adjustment_new (
p->param.fval.value,
p->param.fval.min, p->param.fval.max,
p->param.fval.step, p->param.fval.step*10,
p->param.fval.step*10);
progress = gtk_progress_bar_new_with_adjustment(GTK_ADJUSTMENT(prog_adj));
gtk_widget_show(progress);
gtk_table_attach (GTK_TABLE (table), progress, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 1);
p->user_data = progress;
p->change_listener = my_float_listener;
break;
}
case PARAM_LISTVAL: {
int i;
GList *combo_winsize_items = NULL;
GtkWidget *combo_entry_winsize = NULL;
GtkWidget *combo_winsize = gtk_combo_new ();
gtk_widget_show (combo_winsize);
gtk_table_attach (GTK_TABLE (table), combo_winsize, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (combo_winsize), TRUE, TRUE);
for (i=0;i<p->param.slist.nbChoices;++i)
combo_winsize_items = g_list_append (combo_winsize_items,
p->param.slist.choices[i]);
gtk_combo_set_popdown_strings (GTK_COMBO (combo_winsize), combo_winsize_items);
g_list_free (combo_winsize_items);
combo_entry_winsize = GTK_COMBO (combo_winsize)->entry;
gtk_widget_show (combo_entry_winsize);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_winsize), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_winsize), LVAL(*p));
p->change_listener = my_list_listener;
p->user_data = combo_entry_winsize;
gtk_object_set_data (GTK_OBJECT(combo_entry_winsize),"param",(void*)p);
gtk_signal_connect (GTK_OBJECT (combo_entry_winsize), "changed",
GTK_SIGNAL_FUNC (on_list_changed),
NULL);
break;
}
case PARAM_BOOLVAL: {
GtkWidget *checkbutton_double =
gtk_check_button_new_with_label (p->name);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_double),BVAL(*p));
gtk_widget_show (checkbutton_double);
gtk_table_attach (GTK_TABLE (table), checkbutton_double, 1, 2, n, n+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_signal_connect (GTK_OBJECT (checkbutton_double), "toggled",
GTK_SIGNAL_FUNC (on_bool_toggled),
NULL);
gtk_object_set_data (GTK_OBJECT(checkbutton_double),"param",(void*)p);
p->user_data = checkbutton_double;
p->change_listener = my_bool_listener;
break;
}
}
}
}
gtk_widget_show_all(GTK_WIDGET(table));
gtk_container_add(GTK_CONTAINER(notebook),table);
gtk_notebook_set_tab_label_text(notebook,GTK_WIDGET(table),params->name);
}
GtkWidget*
create_config (void)
{
GtkWidget *config;
GtkWidget *config_vbox;
GtkWidget *frame1;
GtkWidget *table1;
GtkWidget *label9;
GtkObject *delay_spin_adj;
GtkWidget *delay_spin;
GtkWidget *focus_but;
GtkWidget *timer_but;
GtkWidget *label8;
GtkWidget *frame2;
GtkWidget *table2;
GtkWidget *delete_but;
GtkWidget *new_but;
GtkWidget *scrolledwindow2;
GtkWidget *treeview;
GtkWidget *edit_but;
GtkWidget *label7;
GtkWidget *hbuttonbox1;
GtkWidget *revert_but;
GtkWidget *save_but;
config = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (config), "SmartEar Configuration");
gtk_window_set_destroy_with_parent (GTK_WINDOW (config), TRUE);
config_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (config_vbox);
gtk_container_add (GTK_CONTAINER (config), config_vbox);
gtk_widget_set_size_request (config_vbox, -1, 640);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (config_vbox), frame1, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame1), 5);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (frame1), table1);
gtk_container_set_border_width (GTK_CONTAINER (table1), 5);
gtk_table_set_row_spacings (GTK_TABLE (table1), 10);
gtk_table_set_col_spacings (GTK_TABLE (table1), 10);
label9 = gtk_label_new ("Time delay between playing sounds for a particular buddy:");
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table1), label9, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
delay_spin_adj = gtk_adjustment_new (60, 0, 1000000, 1, 10, 10);
delay_spin = gtk_spin_button_new (GTK_ADJUSTMENT (delay_spin_adj), 1, 0);
gtk_widget_show (delay_spin);
gtk_table_attach (GTK_TABLE (table1), delay_spin, 1, 2, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (delay_spin), GTK_UPDATE_IF_VALID);
focus_but = gtk_check_button_new_with_mnemonic ("Don't play sounds for the conversation that has focus.");
gtk_widget_show (focus_but);
gtk_table_attach (GTK_TABLE (table1), focus_but, 0, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
timer_but = gtk_check_button_new_with_mnemonic ("Also play sounds if you don't respond to a particular IM within a delay period.");
gtk_widget_show (timer_but);
gtk_table_attach (GTK_TABLE (table1), timer_but, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label8 = gtk_label_new ("Options");
gtk_widget_show (label8);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label8);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (config_vbox), frame2, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame2), 5);
table2 = gtk_table_new (2, 3, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame2), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 5);
gtk_table_set_row_spacings (GTK_TABLE (table2), 10);
gtk_table_set_col_spacings (GTK_TABLE (table2), 10);
delete_but = gtk_button_new_from_stock ("gtk-delete");
gtk_widget_show (delete_but);
gtk_table_attach (GTK_TABLE (table2), delete_but, 2, 3, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
GTK_WIDGET_SET_FLAGS (delete_but, GTK_CAN_DEFAULT);
new_but = gtk_button_new_from_stock ("gtk-new");
gtk_widget_show (new_but);
gtk_table_attach (GTK_TABLE (table2), new_but, 0, 1, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
GTK_WIDGET_SET_FLAGS (new_but, GTK_CAN_DEFAULT);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow2);
gtk_table_attach (GTK_TABLE (table2), scrolledwindow2, 0, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
treeview = gtk_tree_view_new ();
gtk_widget_show (treeview);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview);
edit_but = gtk_button_new_from_stock ("gtk-properties");
gtk_widget_show (edit_but);
gtk_table_attach (GTK_TABLE (table2), edit_but, 1, 2, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
label7 = gtk_label_new ("Entries");
gtk_widget_show (label7);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label7);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (config_vbox), hbuttonbox1, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 5);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_SPREAD);
revert_but = gtk_button_new_from_stock ("gtk-revert-to-saved");
gtk_widget_show (revert_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), revert_but);
GTK_WIDGET_SET_FLAGS (revert_but, GTK_CAN_DEFAULT);
save_but = gtk_button_new_from_stock ("gtk-save");
gtk_widget_show (save_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), save_but);
GTK_WIDGET_SET_FLAGS (save_but, GTK_CAN_DEFAULT);
g_signal_connect ((gpointer) config_vbox, "destroy",
G_CALLBACK (on_config_destroy),
NULL);
g_signal_connect ((gpointer) delay_spin, "changed",
G_CALLBACK (on_delay_changed),
NULL);
g_signal_connect ((gpointer) focus_but, "toggled",
G_CALLBACK (on_focus_toggled),
NULL);
g_signal_connect ((gpointer) timer_but, "toggled",
G_CALLBACK (on_timer_toggled),
NULL);
g_signal_connect ((gpointer) delete_but, "clicked",
G_CALLBACK (on_delete_clicked),
NULL);
g_signal_connect ((gpointer) new_but, "clicked",
G_CALLBACK (on_new_clicked),
NULL);
g_signal_connect ((gpointer) edit_but, "clicked",
G_CALLBACK (on_edit_clicked),
NULL);
g_signal_connect ((gpointer) revert_but, "clicked",
G_CALLBACK (on_revert_clicked),
NULL);
g_signal_connect ((gpointer) save_but, "clicked",
G_CALLBACK (on_save_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (config, config, "config");
GLADE_HOOKUP_OBJECT (config, config_vbox, "config_vbox");
GLADE_HOOKUP_OBJECT (config, frame1, "frame1");
GLADE_HOOKUP_OBJECT (config, table1, "table1");
GLADE_HOOKUP_OBJECT (config, label9, "label9");
GLADE_HOOKUP_OBJECT (config, delay_spin, "delay_spin");
GLADE_HOOKUP_OBJECT (config, focus_but, "focus_but");
GLADE_HOOKUP_OBJECT (config, timer_but, "timer_but");
GLADE_HOOKUP_OBJECT (config, label8, "label8");
GLADE_HOOKUP_OBJECT (config, frame2, "frame2");
GLADE_HOOKUP_OBJECT (config, table2, "table2");
GLADE_HOOKUP_OBJECT (config, delete_but, "delete_but");
GLADE_HOOKUP_OBJECT (config, new_but, "new_but");
GLADE_HOOKUP_OBJECT (config, scrolledwindow2, "scrolledwindow2");
GLADE_HOOKUP_OBJECT (config, treeview, "treeview");
GLADE_HOOKUP_OBJECT (config, edit_but, "edit_but");
GLADE_HOOKUP_OBJECT (config, label7, "label7");
GLADE_HOOKUP_OBJECT (config, hbuttonbox1, "hbuttonbox1");
GLADE_HOOKUP_OBJECT (config, revert_but, "revert_but");
GLADE_HOOKUP_OBJECT (config, save_but, "save_but");
return config;
}
static GtkWidget *server_info_page (struct server *s) {
GtkWidget *page_vbox;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *label;
GSList *sources;
GSList *list;
struct master *m;
struct server_props *props;
char buf[32];
GList *cfgs;
int slots_buffer;
guint row = 0;
props = properties (s);
page_vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8);
/* Address */
table = gtk_table_new (6, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
gtk_box_pack_start (GTK_BOX (page_vbox), table, FALSE, FALSE, 0);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 16);
label = gtk_label_new (_("IP Address:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
gtk_widget_show (label);
label = gtk_label_new (inet_ntoa (s->host->ip));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, row, row+1);
gtk_widget_show (label);
label = gtk_label_new (_("Port:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 2, 3, row, row+1);
gtk_widget_show (label);
g_snprintf (buf, 32, "%d", s->port);
label = gtk_label_new (buf);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 3, 4, row, row+1);
gtk_widget_show (label);
row++;
label = gtk_label_new (_("Host Name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
gtk_widget_show (label);
if (s->host->name) {
label = gtk_label_new (s->host->name);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1);
gtk_widget_show (label);
}
row++;
label = gtk_label_new (_("Country:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
gtk_widget_show (label);
#ifdef USE_GEOIP
if (geoip_name_by_id(s->country_id)) {
GtkWidget* hbox = gtk_hbox_new (FALSE, 4);
struct pixmap* pix = get_pixmap_for_country(s->country_id);
if (pix) {
GtkWidget *pixmap = gtk_pixmap_new(pix->pix,pix->mask);
gtk_box_pack_start (GTK_BOX (hbox), pixmap, FALSE, FALSE, 0);
gtk_widget_show (pixmap);
}
label = gtk_label_new (geoip_name_by_id(s->country_id));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 4, row, row+1);
gtk_widget_show (hbox);
}
#endif
row++;
label = gtk_label_new (_("Refreshed:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
gtk_widget_show (label);
if (s->refreshed) {
char* str = timet2string(&s->refreshed);
label = gtk_label_new (str);
g_free(str);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1);
gtk_widget_show (label);
}
row++;
// translator: last time and date the server answered the query
label = gtk_label_new (_("Last answer:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
gtk_widget_show (label);
if (s->last_answer) {
GtkStyle *style;
GdkColor color;
time_t max_days = 3; // XXX: hardcoded, has to be configurable some time
char* str = timet2string(&s->last_answer);
label = gtk_label_new (str);
g_free(str);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 4, row, row+1);
if (s->last_answer + max_days*24*60*60 < s->refreshed) {
// XXX: I don't know if that is the correct way, it's undocumented :-(
style = gtk_widget_get_style(label);
gdk_color_parse("red",&color);
style->fg [GTK_STATE_NORMAL] = color;
style->fg [GTK_STATE_ACTIVE] = color;
style->fg [GTK_STATE_PRELIGHT] = color;
style->fg [GTK_STATE_SELECTED] = color;
style->fg [GTK_STATE_INSENSITIVE] = color;
gtk_widget_set_style (label, style);
}
gtk_widget_show (label);
}
row++;
/*pulp*/ /*Reserved Slots spin widget*/
if (props) {
if (props->reserved_slots) {
slots_buffer=props->reserved_slots;
}
else {
slots_buffer=0;
}
}
else {
slots_buffer=0;
}
label = gtk_label_new (_("Reserved Slots:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, row, row+1);
gtk_widget_show (label);
adj = (GtkAdjustment *) gtk_adjustment_new (slots_buffer, 0, 9, 1, 2,0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON (spinner), GTK_UPDATE_IF_VALID);
gtk_table_attach_defaults (GTK_TABLE (table), spinner, 1, 2, row, row+1);
gtk_widget_show (spinner);
gtk_widget_show (table);
/* Sources */
frame = gtk_frame_new (_("Sources"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (page_vbox), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
sources = references_to_server (s);
for (list = sources; list; list = list->next) {
m = (struct master *) list->data;
label = gtk_label_new (_(m->name));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
g_slist_free (sources);
gtk_widget_show (vbox);
gtk_widget_show (frame);
/* Custom CFG */
hbox = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (page_vbox), hbox, FALSE, FALSE, 0);
customcfg_combo = gtk_combo_new ();
gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (customcfg_combo)->entry),
256);
gtk_widget_set_usize (GTK_COMBO (customcfg_combo)->entry, 112, -1);
if ((games[s->type].flags & GAME_CONNECT) != 0 &&
games[s->type].custom_cfgs) {
cfgs = (*games[s->type].custom_cfgs) (&games[s->type], NULL, s->game);
combo_set_vals (customcfg_combo, cfgs,
(props && props->custom_cfg)? props->custom_cfg : NULL);
if (cfgs) {
g_list_foreach (cfgs, (GFunc) g_free, NULL);
g_list_free (cfgs);
}
}
else {
gtk_widget_set_sensitive (customcfg_combo, FALSE);
}
gtk_box_pack_end (GTK_BOX (hbox), customcfg_combo, FALSE, FALSE, 0);
gtk_widget_show (customcfg_combo);
label = gtk_label_new (_("Custom CFG:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (hbox);
gtk_widget_show (page_vbox);
return page_vbox;
}
