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; }