GtkWidget * gtk_utils_create_spin_button (GtkAdjustment *adjustment, gdouble climb_rate, guint num_digits, gboolean snap_to_ticks) { GtkWidget *spin_button = gtk_spin_button_new (adjustment, climb_rate, num_digits); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (spin_button), snap_to_ticks); gtk_entry_set_alignment (GTK_ENTRY (spin_button), 1.0); gtk_entry_set_activates_default (GTK_ENTRY (spin_button), TRUE); return spin_button; }
/* Sets whether a number typed into a spin button should * be snapped to the nearest step increment. */ int clip_GTK_SPINBUTTONSETSNAPTOTICKS(ClipMachine * ClipMachineMemory) { C_widget *cspb = _fetch_cw_arg(ClipMachineMemory); gboolean snap_to_ticks = BOOL_OPTION(ClipMachineMemory, 2, TRUE); CHECKCWID(cspb, GTK_IS_SPIN_BUTTON); CHECKOPT(2, LOGICAL_type_of_ClipVarType); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(cspb->widget), snap_to_ticks); 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 GtkWidget* property_item_double_real_create_widget (PropertyItem* base) { PropertyItemDouble * self; GtkWidget* result = NULL; GtkSpinButton* doubleSpinButton = NULL; gdouble _tmp0_ = 0.0; gdouble _tmp1_ = 0.0; GtkSpinButton* _tmp2_ = NULL; gdouble _tmp3_ = 0.0; self = (PropertyItemDouble*) base; _tmp0_ = self->priv->min; _tmp1_ = self->priv->max; _tmp2_ = (GtkSpinButton*) gtk_spin_button_new_with_range (_tmp0_, _tmp1_, (gdouble) 1); g_object_ref_sink (_tmp2_); doubleSpinButton = _tmp2_; _tmp3_ = self->data; gtk_spin_button_set_value (doubleSpinButton, _tmp3_); gtk_spin_button_set_digits (doubleSpinButton, (guint) 10); gtk_spin_button_set_snap_to_ticks (doubleSpinButton, FALSE); result = (GtkWidget*) doubleSpinButton; return result; }
void toggle_snap(GtkWidget *widget, GtkSpinButton *spin) { gtk_spin_button_set_snap_to_ticks(spin, GTK_TOGGLE_BUTTON(widget)->active); }
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void) { GtkWidget *vbox2; GtkWidget *hbox2; GtkWidget *vbox4; GtkWidget *table1; GtkWidget *style_om; GtkWidget *type_om; GtkWidget *type_lb; GtkWidget *style_lb; GtkWidget *customized_cb; GtkWidget *frame1; GtkWidget *table2; GtkComboBox *font_om; GtkListStore *font_om_menu; GtkWidget *format_en; GtkWidget *decimal_en; GtkAdjustment *start_sb_adj; GtkWidget *start_sb; GtkAdjustment *text_align_sb_adj; GtkWidget *text_align_sb; GtkAdjustment *label_align_sb_adj; GtkWidget *label_align_sb; GtkWidget *format_lb; GtkWidget *font_lb; GtkWidget *delimiter_lb; GtkWidget *start_at_lb; GtkWidget *text_align_lb; GtkWidget *label_align_lb; GtkWidget *vbox3; GtkWidget *preview_lb; GtkWidget *hbox1; GSList *action_group = NULL; GtkWidget *start_list_rb; GtkWidget *apply_list_rb; GtkWidget *resume_list_rb; GtkWidget *preview_area; GtkWidget *preview_frame; const XAP_StringSet * pSS = m_pApp->getStringSet(); UT_UTF8String s; GtkWidget * wNoteBook = NULL; vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vbox2); if(!isModal()) { // Note Book creation wNoteBook = gtk_notebook_new (); gtk_widget_show(wNoteBook); // Container for the lists pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s); GtkWidget * lbPageLists = gtk_label_new(s.utf8_str()); gtk_widget_show(lbPageLists); gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists); m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2); // Container for Text Folding pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s); GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str()); GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE); gtk_widget_show(lbPageFolding); gtk_widget_show(wFoldingTable); gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding); m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable); // Left Spacing Here GtkWidget * lbLeftSpacer = gtk_label_new(""); gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0); gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0); gtk_widget_show(lbLeftSpacer); // Bold markup GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>"); gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE); localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp); gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(lbFoldHeading); // Mid Left Spacing Here GtkWidget * lbMidLeftSpacer = gtk_label_new(""); gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0); gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0); gtk_widget_show(lbMidLeftSpacer); m_vecFoldCheck.clear(); m_vecFoldID.clear(); UT_uint32 ID =0; // RadioButtons pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s); GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str()); GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); gtk_widget_show(wFoldingTable); gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists); } // List Page gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8); gtk_widget_show (hbox2); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0); vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_widget_show (vbox4); gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table1), 4); style_om = gtk_combo_box_text_new(); gtk_widget_show (style_om); gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); _fillNoneStyleMenu(m_wListStyleNone_menu.obj()); m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); _fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj()); m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); _fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj()); // This is the default list. Change if the list style changes // m_wListStyle_menu = m_wListStyleNumbered_menu; gtk_combo_box_set_model(GTK_COMBO_BOX (style_om), GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj())); type_om = gtk_combo_box_text_new(); gtk_widget_show (type_om); gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str()); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str()); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str()); gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s); type_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (type_lb); gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s); style_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (style_lb); gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s); customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET); gtk_widget_show (customized_cb); /* todo gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (0), 0, 0); */ frame1 = gtk_frame_new (NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE); //gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0); table2 = gtk_table_new (6, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (frame1), table2); gtk_container_set_border_width (GTK_CONTAINER (table2), 4); gtk_widget_set_sensitive (table2, TRUE); gtk_table_set_row_spacings (GTK_TABLE (table2), 4); gtk_table_set_col_spacings (GTK_TABLE (table2), 4); font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); _fillFontMenu(font_om_menu); font_om = GTK_COMBO_BOX(gtk_combo_box_new()); gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu)); gtk_widget_show (GTK_WIDGET(font_om)); gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); format_en = gtk_entry_new (); gtk_entry_set_max_length(GTK_ENTRY(format_en), 20); gtk_widget_show (format_en); gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_text (GTK_ENTRY (format_en), "%L"); decimal_en = gtk_entry_new (); gtk_widget_show (decimal_en); gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_text (GTK_ENTRY (format_en), ""); start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10); start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0); gtk_widget_show (start_sb); gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1); text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2); gtk_widget_show (text_align_sb); gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE); label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1); label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2); gtk_widget_show (label_align_sb); gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s); format_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (format_lb); gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s); font_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (font_lb); gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s); delimiter_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (delimiter_lb); gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s); start_at_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (start_at_lb); gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s); text_align_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (text_align_lb); gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s); label_align_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (label_align_lb); gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5); vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s); preview_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (preview_lb); gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5); preview_frame = gtk_frame_new (NULL); gtk_widget_show (preview_frame); gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3); gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE); preview_area = createDrawingArea (); gtk_widget_set_size_request (preview_area,180,225); gtk_widget_show (preview_area); gtk_container_add (GTK_CONTAINER (preview_frame), preview_area); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); if(!isModal()) gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s); start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str()); action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb)); if(!isModal()) gtk_widget_show (start_list_rb); gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s); apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str()); action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb)); if(!isModal()) gtk_widget_show (apply_list_rb); gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s); resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str()); action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb)); if(!isModal()) gtk_widget_show (resume_list_rb); gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0); // Save useful widgets in member variables if(isModal()) { m_wContents = vbox2; } else { m_wContents = wNoteBook; } m_wStartNewList = start_list_rb; m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb)); m_wApplyCurrent = apply_list_rb; m_wStartSubList = resume_list_rb; m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb)); m_wRadioGroup = action_group; m_wPreviewArea = preview_area; m_wDelimEntry = format_en; m_oAlignList_adj = text_align_sb_adj; m_wAlignListSpin = text_align_sb; m_oIndentAlign_adj = label_align_sb_adj; m_wIndentAlignSpin = label_align_sb; m_wDecimalEntry = decimal_en; m_oStartSpin_adj = start_sb_adj; m_wStartSpin = start_sb; m_wFontOptions = font_om; m_wFontOptions_menu = font_om_menu; m_wCustomFrame = frame1; m_wCustomLabel = customized_cb; m_wCustomTable = table2; m_wListStyleBox = GTK_COMBO_BOX(style_om); m_wListTypeBox = GTK_COMBO_BOX(type_om); m_wListType_menu = m_wListStyleNumbered_menu; // Start by hiding the Custom frame // // gtk_widget_hide(m_wCustomFrame); gtk_widget_show(m_wCustomFrame); setbisCustomized(false); return m_wContents; }
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; }
GtkWidget *pref_start_gui(){ GtkWidget *vbox; GtkWidget *hbox; GtkWidget *table; GtkWidget *label; GtkObject *adj; GtkAttachOptions xoption, yoption; LOG(LOG_DEBUG, "IN : pref_start_gui()"); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_set_size_request(vbox, 300, 200); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); xoption = GTK_SHRINK|GTK_FILL; yoption = GTK_SHRINK; table = gtk_table_new(2, 12, FALSE); gtk_box_pack_start (GTK_BOX(vbox) , table,FALSE, FALSE, 0); hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 0, 1, xoption, yoption, 10, 10); label = gtk_label_new(_("Maximum words in history")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 10, //value 0, // lower 20, //upper 1, // step increment 10,// page_increment, (gfloat)0.0); spin_words = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_words), max_remember_words ); gtk_widget_set_size_request(spin_words,60,20); gtk_table_attach(GTK_TABLE(table), spin_words, 1, 2, 0, 1, xoption, yoption, 10, 10); gtk_tooltips_set_tip(tooltip, spin_words, _("Maximum number of words to remember in word history"), "Private"); hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 1, 2, xoption, yoption, 10, 10); label = gtk_label_new(_("Chars in dictionary bar")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 10, //value 1, // lower 32, //upper 1, // step increment 1,// page_increment, 0.0); spin_dict_label = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_dict_label), dict_button_length ); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(spin_dict_label), TRUE); gtk_widget_set_size_request(spin_dict_label,60,20); gtk_table_attach(GTK_TABLE(table), spin_dict_label, 1, 2, 1, 2, xoption, yoption, 10, 10); gtk_tooltips_set_tip(tooltip, spin_dict_label, _("Specify the number of characters to display on top of each toggle buttons in dictionary bar."),"Private"); check_splash = gtk_check_button_new_with_label(_("Show splash screen")); gtk_tooltips_set_tip(tooltip, check_splash, _("Show splash screen on loading."),"Private"); gtk_table_attach(GTK_TABLE(table), check_splash, 0, 1, 5, 6, xoption, yoption, 10, 10); // gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_splash), bshow_splash); check_heading_auto = gtk_check_button_new_with_label(_("Calculate heading automatically")); gtk_tooltips_set_tip(tooltip, check_heading_auto, _("Calculate the number of cells in heading list to suit the window size."),"Private"); gtk_table_attach(GTK_TABLE(table), check_heading_auto, 0, 1, 6, 7, xoption, yoption, 10, 10); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_heading_auto), bheading_auto_calc); // hbox = gtk_hbox_new(FALSE,10); gtk_container_set_border_width(GTK_CONTAINER(hbox), 2); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 7, 8, xoption, yoption, 10, 10); label = gtk_label_new(_("Maximum hits to display")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0); adj = gtk_adjustment_new( 100, //value 1, // lower 1000, //upper 1, // step increment 10,// page_increment, 0.0); spin_max_heading = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_max_heading), max_heading ); gtk_widget_set_size_request(spin_max_heading,60,20); gtk_table_attach(GTK_TABLE(table), spin_max_heading, 1, 2, 7, 8, xoption, yoption, 10, 10); gtk_tooltips_set_tip(tooltip, spin_max_heading, _("Maximum number of hits to be displayed at once.\nYou can go forward and backward using buttons. Valid only if automatic calculation is disabled."), "Private"); // check_button_color = gtk_check_button_new_with_label(_("Enable dictionary button color")); gtk_tooltips_set_tip(tooltip, check_button_color, _("Enable background color of dictionary button."),"Private"); gtk_table_attach(GTK_TABLE(table), check_button_color, 0, 1, 8, 9, xoption, yoption, 10, 10); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_color), benable_button_color); LOG(LOG_DEBUG, "OUT : pref_start_gui()"); return(vbox); }
static void thunar_sbr_insert_renamer_init (ThunarSbrInsertRenamer *insert_renamer) { AtkRelationSet *relations; GtkAdjustment *adjustment; AtkRelation *relation; GEnumClass *klass; AtkObject *object; GtkWidget *spinner; GtkWidget *combo; GtkWidget *entry; GtkWidget *label; GtkWidget *table; GtkWidget *hbox; guint n; table = gtk_table_new (2, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_box_pack_start (GTK_BOX (insert_renamer), table, TRUE, TRUE, 0); gtk_widget_show (table); combo = gtk_combo_box_text_new (); klass = g_type_class_ref (THUNAR_SBR_TYPE_INSERT_MODE); for (n = 0; n < klass->n_values; ++n) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _(klass->values[n].value_nick)); exo_mutual_binding_new (G_OBJECT (insert_renamer), "mode", G_OBJECT (combo), "active"); gtk_table_attach (GTK_TABLE (table), combo, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); g_type_class_unref (klass); gtk_widget_show (combo); label = gtk_label_new_with_mnemonic (_("_Text:")); gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_FILL, 0, 0, 0); gtk_widget_show (label); entry = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); exo_mutual_binding_new (G_OBJECT (entry), "text", G_OBJECT (insert_renamer), "text"); gtk_table_attach (GTK_TABLE (table), entry, 2, 3, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry); gtk_widget_show (entry); /* set Atk label relation for the entry */ object = gtk_widget_get_accessible (entry); relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label)); relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR); atk_relation_set_add (relations, relation); g_object_unref (G_OBJECT (relation)); label = gtk_label_new_with_mnemonic (_("_At position:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f); gtk_table_attach (GTK_TABLE (table), label, 0, 2, 1, 2, GTK_FILL, 0, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 12); gtk_table_attach (GTK_TABLE (table), hbox, 2, 3, 1, 2, GTK_FILL, 0, 0, 0); gtk_widget_show (hbox); spinner = gtk_spin_button_new_with_range (0u, G_MAXUINT, 1u); gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4); gtk_entry_set_alignment (GTK_ENTRY (spinner), 1.0f); gtk_entry_set_activates_default (GTK_ENTRY (spinner), TRUE); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner), 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinner), TRUE); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (spinner), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); gtk_widget_show (spinner); adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinner)); exo_mutual_binding_new (G_OBJECT (insert_renamer), "offset", G_OBJECT (adjustment), "value"); /* set Atk label relation for the entry */ object = gtk_widget_get_accessible (spinner); relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label)); relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR); atk_relation_set_add (relations, relation); g_object_unref (G_OBJECT (relation)); combo = gtk_combo_box_text_new (); klass = g_type_class_ref (THUNAR_SBR_TYPE_OFFSET_MODE); for (n = 0; n < klass->n_values; ++n) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), _(klass->values[n].value_nick)); exo_mutual_binding_new (G_OBJECT (insert_renamer), "offset-mode", G_OBJECT (combo), "active"); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); g_type_class_unref (klass); gtk_widget_show (combo); }
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; }
void wxSpinCtrlGTKBase::SetSnapToTicks(bool snap_to_ticks) { wxCHECK_RET( (m_widget != NULL), "invalid spin button" ); gtk_spin_button_set_snap_to_ticks( GTK_SPIN_BUTTON(m_widget), snap_to_ticks); }
/***************************************************************************** * 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); } }
GtkWidget* create_MainWindow (void) { GtkWidget *MainWindow; GtkWidget *dialog_vbox1; GtkWidget *notebook1; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *frame1; GtkWidget *calendar1; GtkWidget *label3; GtkWidget *frame2; GtkWidget *table1; GtkWidget *label6; GtkWidget *label7; GtkWidget *label8; GtkWidget *label9; GtkWidget *label10; GtkObject *spinbutton1_adj; GtkWidget *spinbutton1; GtkObject *spinbutton2_adj; GtkWidget *spinbutton2; GtkObject *spinbutton3_adj; GtkWidget *spinbutton3; GtkWidget *label4; GtkWidget *frame3; GtkWidget *vbox2; GtkWidget *label11; GtkWidget *checkbutton1; GtkWidget *hbox2; GtkWidget *label12; GtkWidget *combo1; GtkWidget *combo_entry1; GtkWidget *label5; GtkWidget *label1; GtkWidget *vbox3; GtkWidget *label13; GtkWidget *drawingarea1; GtkWidget *label14; GtkWidget *hseparator1; GtkWidget *scrolledwindow1; GtkWidget *treeview1; GtkWidget *checkbutton2; GtkWidget *label2; GtkWidget *dialog_action_area1; GtkWidget *helpbutton1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; MainWindow = gtk_dialog_new (); gtk_widget_set_size_request (MainWindow, 500, 650); gtk_window_set_title (GTK_WINDOW (MainWindow), _("Date / Time Properties")); gtk_window_set_position (GTK_WINDOW (MainWindow), GTK_WIN_POS_CENTER); dialog_vbox1 = GTK_DIALOG (MainWindow)->vbox; gtk_widget_show (dialog_vbox1); notebook1 = gtk_notebook_new (); gtk_widget_show (notebook1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), notebook1, TRUE, TRUE, 0); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (notebook1), vbox1); hbox1 = gtk_hbox_new (TRUE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0); frame1 = gtk_frame_new (NULL); gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame1), 8); calendar1 = gtk_calendar_new (); gtk_widget_show (calendar1); gtk_container_add (GTK_CONTAINER (frame1), calendar1); gtk_calendar_display_options (GTK_CALENDAR (calendar1), GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_SHOW_DAY_NAMES); label3 = gtk_label_new (_("Date")); gtk_widget_show (label3); gtk_frame_set_label_widget (GTK_FRAME (frame1), label3); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame2), 8); table1 = gtk_table_new (4, 2, TRUE); gtk_widget_show (table1); gtk_container_add (GTK_CONTAINER (frame2), table1); label6 = gtk_label_new (_("Current Time:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new (_("00:00:00")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); label8 = gtk_label_new (_("Hour:")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table1), label8, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); label9 = gtk_label_new (_("Minute:")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table1), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); label10 = gtk_label_new (_("Second:")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table1), label10, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); spinbutton1_adj = gtk_adjustment_new (22, 0, 23, 1, 10, 10); spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0); gtk_widget_show (spinbutton1); gtk_table_attach (GTK_TABLE (table1), spinbutton1, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (spinbutton1), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinbutton1), TRUE); spinbutton2_adj = gtk_adjustment_new (0, 0, 59, 1, 10, 10); spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton2_adj), 1, 0); gtk_widget_show (spinbutton2); gtk_table_attach (GTK_TABLE (table1), spinbutton2, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton2), TRUE); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (spinbutton2), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinbutton2), TRUE); spinbutton3_adj = gtk_adjustment_new (0, 0, 59, 1, 10, 10); spinbutton3 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton3_adj), 1, 0); gtk_widget_show (spinbutton3); gtk_table_attach (GTK_TABLE (table1), spinbutton3, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton3), TRUE); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (spinbutton3), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinbutton3), TRUE); label4 = gtk_label_new (_("Time")); gtk_widget_show (label4); gtk_frame_set_label_widget (GTK_FRAME (frame2), label4); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); frame3 = gtk_frame_new (NULL); gtk_widget_show (frame3); gtk_box_pack_start (GTK_BOX (vbox1), frame3, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame3), 8); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (frame3), vbox2); label11 = gtk_label_new (_("Your computer can synchronize its clock with a remote time server using the Network Time Protocol")); gtk_widget_show (label11); gtk_box_pack_start (GTK_BOX (vbox2), label11, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label11), TRUE); checkbutton1 = gtk_check_button_new_with_mnemonic (_("_Enable Network Time Protocol")); gtk_widget_show (checkbutton1); gtk_box_pack_start (GTK_BOX (vbox2), checkbutton1, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (checkbutton1), 8); hbox2 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox2); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox2), 8); label12 = gtk_label_new (_("Server: ")); gtk_widget_show (label12); gtk_box_pack_start (GTK_BOX (hbox2), label12, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT); combo1 = gtk_combo_new (); g_object_set_data (G_OBJECT (GTK_COMBO (combo1)->popwin), "GladeParentKey", combo1); gtk_widget_show (combo1); gtk_box_pack_start (GTK_BOX (hbox2), combo1, TRUE, TRUE, 0); combo_entry1 = GTK_COMBO (combo1)->entry; gtk_widget_show (combo_entry1); label5 = gtk_label_new (_("Network Time Protocol")); gtk_widget_show (label5); gtk_frame_set_label_widget (GTK_FRAME (frame3), label5); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); label1 = gtk_label_new (_("Date & Time")); gtk_widget_show (label1); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label1); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox3); gtk_container_add (GTK_CONTAINER (notebook1), vbox3); label13 = gtk_label_new (_("Please select the nearest city in your timezone:")); gtk_widget_show (label13); gtk_box_pack_start (GTK_BOX (vbox3), label13, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_LEFT); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox3), drawingarea1, FALSE, TRUE, 0); gtk_widget_set_size_request (drawingarea1, 480, 240); label14 = gtk_label_new (""); gtk_widget_show (label14); gtk_box_pack_start (GTK_BOX (vbox3), label14, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_LEFT); hseparator1 = gtk_hseparator_new (); gtk_widget_show (hseparator1); gtk_box_pack_start (GTK_BOX (vbox3), hseparator1, FALSE, FALSE, 8); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (vbox3), scrolledwindow1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow1), 8); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview1 = gtk_tree_view_new (); gtk_widget_show (treeview1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview1); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), FALSE); checkbutton2 = gtk_check_button_new_with_mnemonic (_("_System clock uses UTC")); gtk_widget_show (checkbutton2); gtk_box_pack_start (GTK_BOX (vbox3), checkbutton2, FALSE, FALSE, 0); label2 = gtk_label_new (_("Timezone")); gtk_widget_show (label2); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (MainWindow)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); helpbutton1 = gtk_button_new_from_stock ("gtk-help"); gtk_widget_show (helpbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (MainWindow), helpbutton1, GTK_RESPONSE_HELP); GTK_WIDGET_SET_FLAGS (helpbutton1, GTK_CAN_DEFAULT); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (MainWindow), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (MainWindow), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); g_signal_connect ((gpointer) MainWindow, "delete_event", G_CALLBACK (on_MainWindow_close), NULL); g_signal_connect ((gpointer) calendar1, "day_selected", G_CALLBACK (on_calendar1_day_selected), NULL); g_signal_connect ((gpointer) calendar1, "month_changed", G_CALLBACK (on_calendar1_month_changed), NULL); g_signal_connect ((gpointer) spinbutton1, "changed", G_CALLBACK (on_spinbutton1_changed), NULL); g_signal_connect ((gpointer) spinbutton2, "changed", G_CALLBACK (on_spinbutton2_changed), NULL); g_signal_connect ((gpointer) spinbutton3, "changed", G_CALLBACK (on_spinbutton3_changed), NULL); g_signal_connect ((gpointer) checkbutton1, "toggled", G_CALLBACK (on_checkbutton1_toggled), NULL); g_signal_connect ((gpointer) combo_entry1, "changed", G_CALLBACK (on_combo_entry1_changed), NULL); g_signal_connect ((gpointer) drawingarea1, "motion_notify_event", G_CALLBACK (on_drawingarea1_motion_notify_event), NULL); g_signal_connect ((gpointer) drawingarea1, "button_press_event", G_CALLBACK (on_drawingarea1_button_press_event), NULL); g_signal_connect ((gpointer) drawingarea1, "leave_notify_event", G_CALLBACK (on_drawingarea1_leave_notify_event), NULL); g_signal_connect ((gpointer) drawingarea1, "expose_event", G_CALLBACK (on_drawingarea1_expose_event), NULL); g_signal_connect ((gpointer) treeview1, "row_activated", G_CALLBACK (on_treeview1_row_activated), NULL); g_signal_connect ((gpointer) checkbutton2, "toggled", G_CALLBACK (on_checkbutton2_toggled), NULL); g_signal_connect ((gpointer) helpbutton1, "clicked", G_CALLBACK (on_helpbutton1_clicked), NULL); g_signal_connect ((gpointer) cancelbutton1, "clicked", G_CALLBACK (on_cancelbutton1_clicked), NULL); g_signal_connect ((gpointer) okbutton1, "clicked", G_CALLBACK (on_okbutton1_clicked), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (MainWindow, MainWindow, "MainWindow"); GLADE_HOOKUP_OBJECT_NO_REF (MainWindow, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (MainWindow, notebook1, "notebook1"); GLADE_HOOKUP_OBJECT (MainWindow, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (MainWindow, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (MainWindow, frame1, "frame1"); GLADE_HOOKUP_OBJECT (MainWindow, calendar1, "calendar1"); GLADE_HOOKUP_OBJECT (MainWindow, label3, "label3"); GLADE_HOOKUP_OBJECT (MainWindow, frame2, "frame2"); GLADE_HOOKUP_OBJECT (MainWindow, table1, "table1"); GLADE_HOOKUP_OBJECT (MainWindow, label6, "label6"); GLADE_HOOKUP_OBJECT (MainWindow, label7, "label7"); GLADE_HOOKUP_OBJECT (MainWindow, label8, "label8"); GLADE_HOOKUP_OBJECT (MainWindow, label9, "label9"); GLADE_HOOKUP_OBJECT (MainWindow, label10, "label10"); GLADE_HOOKUP_OBJECT (MainWindow, spinbutton1, "spinbutton1"); GLADE_HOOKUP_OBJECT (MainWindow, spinbutton2, "spinbutton2"); GLADE_HOOKUP_OBJECT (MainWindow, spinbutton3, "spinbutton3"); GLADE_HOOKUP_OBJECT (MainWindow, label4, "label4"); GLADE_HOOKUP_OBJECT (MainWindow, frame3, "frame3"); GLADE_HOOKUP_OBJECT (MainWindow, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (MainWindow, label11, "label11"); GLADE_HOOKUP_OBJECT (MainWindow, checkbutton1, "checkbutton1"); GLADE_HOOKUP_OBJECT (MainWindow, hbox2, "hbox2"); GLADE_HOOKUP_OBJECT (MainWindow, label12, "label12"); GLADE_HOOKUP_OBJECT (MainWindow, combo1, "combo1"); GLADE_HOOKUP_OBJECT (MainWindow, combo_entry1, "combo_entry1"); GLADE_HOOKUP_OBJECT (MainWindow, label5, "label5"); GLADE_HOOKUP_OBJECT (MainWindow, label1, "label1"); GLADE_HOOKUP_OBJECT (MainWindow, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT (MainWindow, label13, "label13"); GLADE_HOOKUP_OBJECT (MainWindow, drawingarea1, "drawingarea1"); GLADE_HOOKUP_OBJECT (MainWindow, label14, "label14"); GLADE_HOOKUP_OBJECT (MainWindow, hseparator1, "hseparator1"); GLADE_HOOKUP_OBJECT (MainWindow, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT (MainWindow, treeview1, "treeview1"); GLADE_HOOKUP_OBJECT (MainWindow, checkbutton2, "checkbutton2"); GLADE_HOOKUP_OBJECT (MainWindow, label2, "label2"); GLADE_HOOKUP_OBJECT_NO_REF (MainWindow, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (MainWindow, helpbutton1, "helpbutton1"); GLADE_HOOKUP_OBJECT (MainWindow, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (MainWindow, okbutton1, "okbutton1"); return MainWindow; }
GtkWidget * range_widget_create() { GtkWidget *range_dialog; GtkWidget *dialog_vbox4; GtkWidget *vbox7; GtkWidget *hbox46; GtkWidget *label43; GtkWidget *label44; GtkWidget *hbox42; GtkWidget *hbox43; GtkWidget *hbox44; GtkObject *start_hours_adj; GtkObject *start_minutes_adj; GtkObject *start_seconds_adj; GtkWidget *hbox45; GtkObject *end_hours_adj; GtkObject *end_minutes_adj; GtkObject *end_seconds_adj; GtkWidget *dialog_action_area4; GtkWidget *cancel_button; GtkWidget *ok_button; GtkWidget *alignment55; GtkWidget *hbox341; GtkWidget *image49; GtkWidget *label97; gchar *val; range_dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(range_dialog), TIMELOG_TITLE); gtk_window_set_modal(GTK_WINDOW(range_dialog), FALSE); gtk_window_set_type_hint(GTK_WINDOW(range_dialog), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox4 = GTK_DIALOG(range_dialog)->vbox; gtk_widget_show(dialog_vbox4); vbox7 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox7); gtk_box_pack_start(GTK_BOX(dialog_vbox4), vbox7, TRUE, TRUE, 0); hbox46 = gtk_hbox_new(FALSE, 20); gtk_widget_show(hbox46); gtk_box_pack_start(GTK_BOX(vbox7), hbox46, FALSE, FALSE, 5); label43 = gtk_label_new(_("Start Time")); gtk_widget_show(label43); gtk_box_pack_start(GTK_BOX(hbox46), label43, TRUE, TRUE, 0); label44 = gtk_label_new(_("End Time")); gtk_widget_show(label44); gtk_box_pack_start(GTK_BOX(hbox46), label44, TRUE, TRUE, 0); hbox42 = gtk_hbox_new(FALSE, 20); gtk_widget_show(hbox42); gtk_box_pack_start(GTK_BOX(vbox7), hbox42, TRUE, TRUE, 0); start_calendar = gtk_calendar_new(); gtk_widget_show(start_calendar); gtk_box_pack_start(GTK_BOX(hbox42), start_calendar, TRUE, TRUE, 0); gtk_calendar_display_options(GTK_CALENDAR(start_calendar), GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_SHOW_DAY_NAMES); end_calendar = gtk_calendar_new(); gtk_widget_show(end_calendar); gtk_box_pack_start(GTK_BOX(hbox42), end_calendar, TRUE, TRUE, 0); gtk_calendar_display_options(GTK_CALENDAR(end_calendar), GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_SHOW_DAY_NAMES); hbox43 = gtk_hbox_new(FALSE, 20); gtk_widget_show(hbox43); gtk_box_pack_start(GTK_BOX(vbox7), hbox43, FALSE, TRUE, 10); hbox44 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox44); gtk_box_pack_start(GTK_BOX(hbox43), hbox44, TRUE, TRUE, 0); start_hours_adj = gtk_adjustment_new(0, -100, 100, 1, 10, 10); start_hours = gtk_spin_button_new(GTK_ADJUSTMENT(start_hours_adj), 1, 0); gtk_widget_show(start_hours); gtk_box_pack_start(GTK_BOX(hbox44), start_hours, TRUE, TRUE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(start_hours), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(start_hours), TRUE); start_minutes_adj = gtk_adjustment_new(0, -100, 100, 1, 10, 10); start_minutes = gtk_spin_button_new(GTK_ADJUSTMENT(start_minutes_adj), 1, 0); gtk_widget_show(start_minutes); gtk_box_pack_start(GTK_BOX(hbox44), start_minutes, TRUE, TRUE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(start_minutes), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(start_minutes), TRUE); start_seconds_adj = gtk_adjustment_new(0, -100, 100, 1, 10, 10); start_seconds = gtk_spin_button_new(GTK_ADJUSTMENT(start_seconds_adj), 1, 0); gtk_widget_show(start_seconds); gtk_box_pack_start(GTK_BOX(hbox44), start_seconds, TRUE, TRUE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(start_seconds), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(start_seconds), TRUE); hbox45 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox45); gtk_box_pack_start(GTK_BOX(hbox43), hbox45, TRUE, TRUE, 0); end_hours_adj = gtk_adjustment_new(0, -100, 100, 1, 10, 10); end_hours = gtk_spin_button_new(GTK_ADJUSTMENT(end_hours_adj), 1, 0); gtk_widget_show(end_hours); gtk_box_pack_start(GTK_BOX(hbox45), end_hours, TRUE, TRUE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(end_hours), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(end_hours), TRUE); end_minutes_adj = gtk_adjustment_new(0, -100, 100, 1, 10, 10); end_minutes = gtk_spin_button_new(GTK_ADJUSTMENT(end_minutes_adj), 1, 0); gtk_widget_show(end_minutes); gtk_box_pack_start(GTK_BOX(hbox45), end_minutes, TRUE, TRUE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(end_minutes), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(end_minutes), TRUE); end_seconds_adj = gtk_adjustment_new(0, -100, 100, 1, 10, 10); end_seconds = gtk_spin_button_new(GTK_ADJUSTMENT(end_seconds_adj), 1, 0); gtk_widget_show(end_seconds); gtk_box_pack_start(GTK_BOX(hbox45), end_seconds, TRUE, TRUE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(end_seconds), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(end_seconds), TRUE); dialog_action_area4 = GTK_DIALOG(range_dialog)->action_area; gtk_widget_show(dialog_action_area4); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area4), GTK_BUTTONBOX_END); cancel_button = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancel_button); gtk_dialog_add_action_widget(GTK_DIALOG(range_dialog), cancel_button, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT); ok_button = gtk_button_new(); gtk_widget_show(ok_button); gtk_dialog_add_action_widget(GTK_DIALOG(range_dialog), ok_button, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); alignment55 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment55); gtk_container_add(GTK_CONTAINER(ok_button), alignment55); hbox341 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox341); gtk_container_add(GTK_CONTAINER(alignment55), hbox341); image49 = gtk_image_new_from_stock("gtk-ok", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image49); gtk_box_pack_start(GTK_BOX(hbox341), image49, FALSE, FALSE, 0); label97 = gtk_label_new_with_mnemonic(_("Select Time Range")); gtk_widget_show(label97); gtk_box_pack_start(GTK_BOX(hbox341), label97, FALSE, FALSE, 0); g_signal_connect((gpointer) start_hours, "value_changed", G_CALLBACK(cb_time_value_changed), NULL); g_signal_connect((gpointer) start_minutes, "value_changed", G_CALLBACK(cb_time_value_changed), NULL); g_signal_connect((gpointer) start_seconds, "value_changed", G_CALLBACK(cb_time_value_changed), NULL); g_signal_connect((gpointer) end_hours, "value_changed", G_CALLBACK(cb_time_value_changed), NULL); g_signal_connect((gpointer) end_minutes, "value_changed", G_CALLBACK(cb_time_value_changed), NULL); g_signal_connect((gpointer) end_seconds, "value_changed", G_CALLBACK(cb_time_value_changed), NULL); val = g_strdup_printf("%02d", 0); gtk_entry_set_text(GTK_ENTRY(start_hours), val); gtk_entry_set_text(GTK_ENTRY(start_minutes), val); gtk_entry_set_text(GTK_ENTRY(start_seconds), val); gtk_entry_set_text(GTK_ENTRY(end_hours), val); gtk_entry_set_text(GTK_ENTRY(end_minutes), val); gtk_entry_set_text(GTK_ENTRY(end_seconds), val); g_free(val); gtk_widget_grab_default(ok_button); return range_dialog; }
static void dt_time_edit_window(GtkWidget *button, cbdata *cbd) { GtkWidget *hbox = cbd->hbox; GtkWidget *inputbox = dt_time_retrieve_inputbox(hbox); GtkWidget *editwindow, *main_vbox, *calendar, *w; GtkWidget *hbox2, *button2; GtkAdjustment *adj; char titlebuffer[1024]; /* FIXME: fixed buffer length */ struct tm tm; int y, m, d, offset; int ofs_h, ofs_m, ofs_sign; time_t t; struct tm *l; gchar *content; #if ! defined(HAVE_TM_GMTOFF) && defined(HAVE_TIMEZONE) extern long timezone; #endif time(&t); l = localtime(&t); /* implicitly calls tzset() for us */ y = l->tm_year + 1900; m = l->tm_mon + 1; d = l->tm_mday; #ifdef HAVE_TM_GMTOFF ofs_sign = l->TM_GMTOFF < 0 ? 1 : -1; ofs_m = (l->TM_GMTOFF > 0 ? l->TM_GMTOFF : -l->TM_GMTOFF) / 60; ofs_h = ofs_m / 60; ofs_m = ofs_m % 60; #else /* HAVE_TM_GMTOFF */ # ifdef HAVE_TIMEZONE ofs_sign = timezone > 0 ? 1 : -1; ofs_m = (timezone > 0 ? timezone : -timezone) / 60; ofs_h = ofs_m / 60; ofs_m = ofs_m % 60; /* extern long timezone does not take DST into account */ if (l->tm_isdst) { ofs_h++; } # else /* HAVE_TIMEZONE */ ofs_h = ofs_m = 0; # endif /* HAVE_TIMEZONE */ #endif /* HAVE_TM_GMTOFF */ /* NOTE: generalizedTime includes offset relative to GMT while the timezone variable hold seconds west of GMT */ offset = -ofs_sign * (100 * ofs_h + ofs_m); #ifdef GTK_WINDOW_DIALOG editwindow = gtk_window_new(GTK_WINDOW_DIALOG); #else editwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif cbd->editwindow = editwindow; g_snprintf(titlebuffer, sizeof(titlebuffer), _("%s: choose date and time"), cbd->form->attrname); gtk_window_set_title(GTK_WINDOW(editwindow), titlebuffer); gtk_window_set_policy(GTK_WINDOW(editwindow), TRUE, TRUE, FALSE); main_vbox = gtk_vbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(main_vbox), 5); gtk_widget_show(main_vbox); gtk_container_add(GTK_CONTAINER(editwindow), main_vbox); calendar = gtk_calendar_new(); gtk_box_pack_start(GTK_BOX(main_vbox), calendar, TRUE, TRUE, 0); gtk_widget_show(calendar); gtk_object_set_data(GTK_OBJECT(editwindow), "calendar", calendar); content = gtk_editable_get_chars(GTK_EDITABLE(inputbox), 0, -1); if (content) { int n = parse_time(content, &tm, &offset); /* printf("n=%d\n", n); */ if (n >= 1) y = tm.tm_year + 1900; if (n >= 2) m = tm.tm_mon + 1; if (n >= 3) d = tm.tm_mday; g_free(content); } gtk_calendar_select_month(GTK_CALENDAR(calendar), m - 1, y); gtk_calendar_select_day(GTK_CALENDAR(calendar), d); hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, TRUE, TRUE, 5); gtk_widget_show(hbox2); w = gtk_label_new(_("Time [hh:mm:ss]")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 23.0, 1.0, 1.0, 1.0)), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_hour); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "hour", w); w = gtk_label_new(_(":")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 59.0, 1.0, 1.0, 1.0)), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_min); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "minute", w); w = gtk_label_new(_(":")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 59.0, 1.0, 1.0, 1.0)), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_sec); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "second", w); hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, TRUE, TRUE, 0); gtk_widget_show(hbox2); w = gtk_label_new(_("Timezone (Offset) [+-hhmm]")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, -1259.0, 1259.0, 100.0, 100.0, 100.0)); w = gtk_spin_button_new(adj, 100.0, 0); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(w), FALSE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), offset); g_signal_connect(adj, "value-changed", G_CALLBACK(tz_value_changed_callback), w); gtk_box_pack_start(GTK_BOX(hbox2), w, TRUE, TRUE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "timezone", w); hbox2 = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, FALSE, TRUE, 5); gtk_widget_show(hbox2); button2 = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_widget_show(button2); g_signal_connect(button2, "clicked", G_CALLBACK(dt_time_ok_callback), cbd); gtk_box_pack_start(GTK_BOX(hbox2), button2, FALSE, TRUE, 0); GTK_WIDGET_SET_FLAGS(button2, GTK_CAN_DEFAULT); gtk_widget_grab_default(button2); button2 = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_box_pack_end(GTK_BOX(hbox2), button2, FALSE, TRUE, 0); g_signal_connect_swapped(button2, "clicked", G_CALLBACK(gtk_widget_destroy), editwindow); gtk_widget_show(button2); gtk_widget_show(editwindow); }
GtkWidget *create_hdhomerun_config(void) { GtkWidget *hdhomerun_config; GtkWidget *hbox1; GtkWidget *frame1; GtkWidget *vbox2; GtkWidget *scrolledwindow1; GtkWidget *DeviceListTree; GtkWidget *RescanBtn; GtkWidget *label1; GtkWidget *Tab; GtkWidget *vbox1; GtkWidget *frame2; GtkWidget *table2; GtkWidget *label11; GtkWidget *label12; GtkWidget *label13; GtkWidget *LaunchVlcBtn; GtkWidget *StopVlcBtn; GtkWidget *hbox2; GtkWidget *ChannelMapEdit; GtkObject *ChannelNumberSpin_adj; GtkWidget *ChannelNumberSpin; GtkWidget *ProgramList; GtkWidget *ScanDownBtn; GtkWidget *ScanUpBtn; GtkWidget *label15; GtkWidget *frame3; GtkWidget *table1; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *label8; GtkWidget *SignalStrengthStatus; GtkWidget *SignalQualityStatus; GtkWidget *SymbolQualityStatus; GtkWidget *PhysicalChannelStatus; GtkWidget *label10; GtkWidget *NetworkRateStatus; GtkWidget *label4; GtkWidget *label2; GtkWidget *vbox3; GtkWidget *frame4; GtkWidget *table3; GtkWidget *FirmwareVersion; GtkWidget *UpgradeBtn; GtkWidget *hbox3; GtkWidget *UpgradeFilename; GtkWidget *UpgradeFilenameBtn; GtkWidget *label14; GtkWidget *label3; hdhomerun_config = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(hdhomerun_config), _("HDHomeRun Config")); gtk_window_set_resizable(GTK_WINDOW(hdhomerun_config), FALSE); hbox1 = gtk_hbox_new(FALSE, 6); gtk_widget_show(hbox1); gtk_container_add(GTK_CONTAINER(hdhomerun_config), hbox1); gtk_container_set_border_width(GTK_CONTAINER(hbox1), 3); frame1 = gtk_frame_new(NULL); gtk_widget_show(frame1); gtk_box_pack_start(GTK_BOX(hbox1), frame1, TRUE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 3); gtk_widget_show(vbox2); gtk_container_add(GTK_CONTAINER(frame1), vbox2); gtk_container_set_border_width(GTK_CONTAINER(vbox2), 3); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow1, TRUE, TRUE, 0); DeviceListTree = gtk_tree_view_new(); gtk_widget_show(DeviceListTree); gtk_container_add(GTK_CONTAINER(scrolledwindow1), DeviceListTree); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(DeviceListTree), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(DeviceListTree), FALSE); RescanBtn = gtk_button_new_with_mnemonic(_("_Rescan")); gtk_widget_show(RescanBtn); gtk_box_pack_start(GTK_BOX(vbox2), RescanBtn, FALSE, FALSE, 0); label1 = gtk_label_new(_("Device")); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame1), label1); gtk_label_set_use_markup(GTK_LABEL(label1), TRUE); gtk_misc_set_padding(GTK_MISC(label1), 3, 0); Tab = gtk_notebook_new(); gtk_widget_show(Tab); gtk_box_pack_start(GTK_BOX(hbox1), Tab, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_container_add(GTK_CONTAINER(Tab), vbox1); frame2 = gtk_frame_new(NULL); gtk_widget_show(frame2); gtk_box_pack_start(GTK_BOX(vbox1), frame2, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame2), 3); table2 = gtk_table_new(3, 4, TRUE); gtk_widget_show(table2); gtk_container_add(GTK_CONTAINER(frame2), table2); gtk_container_set_border_width(GTK_CONTAINER(table2), 6); gtk_table_set_row_spacings(GTK_TABLE(table2), 3); gtk_table_set_col_spacings(GTK_TABLE(table2), 3); label11 = gtk_label_new(_("Channel")); gtk_widget_show(label11); gtk_table_attach(GTK_TABLE(table2), label11, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label12 = gtk_label_new(_("Program")); gtk_widget_show(label12); gtk_table_attach(GTK_TABLE(table2), label12, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label13 = gtk_label_new(_("Scan")); gtk_widget_show(label13); gtk_table_attach(GTK_TABLE(table2), label13, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); LaunchVlcBtn = gtk_button_new_with_mnemonic(_("_View")); gtk_widget_show(LaunchVlcBtn); gtk_table_attach(GTK_TABLE(table2), LaunchVlcBtn, 3, 4, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); StopVlcBtn = gtk_button_new_with_mnemonic(_("_Stop")); gtk_widget_show(StopVlcBtn); gtk_table_attach(GTK_TABLE(table2), StopVlcBtn, 3, 4, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_widget_set_sensitive(StopVlcBtn, FALSE); hbox2 = gtk_hbox_new(FALSE, 3); gtk_widget_show(hbox2); gtk_table_attach(GTK_TABLE(table2), hbox2, 1, 3, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); ChannelMapEdit = gtk_combo_box_new_text(); gtk_widget_show(ChannelMapEdit); gtk_box_pack_start(GTK_BOX(hbox2), ChannelMapEdit, TRUE, TRUE, 0); ChannelNumberSpin_adj = gtk_adjustment_new(0, 0, 300, 1, 10, 0); ChannelNumberSpin = gtk_spin_button_new(GTK_ADJUSTMENT(ChannelNumberSpin_adj), 1, 0); gtk_widget_show(ChannelNumberSpin); gtk_box_pack_start(GTK_BOX(hbox2), ChannelNumberSpin, FALSE, FALSE, 0); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(ChannelNumberSpin), TRUE); ProgramList = gtk_combo_box_new_text(); gtk_widget_show(ProgramList); gtk_table_attach(GTK_TABLE(table2), ProgramList, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); ScanDownBtn = gtk_toggle_button_new_with_mnemonic("_<<-"); gtk_widget_show(ScanDownBtn); gtk_table_attach(GTK_TABLE(table2), ScanDownBtn, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); ScanUpBtn = gtk_toggle_button_new_with_mnemonic("->_>"); gtk_widget_show(ScanUpBtn); gtk_table_attach(GTK_TABLE(table2), ScanUpBtn, 2, 3, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label15 = gtk_label_new(_("Configuration")); gtk_widget_show(label15); gtk_frame_set_label_widget(GTK_FRAME(frame2), label15); gtk_label_set_use_markup(GTK_LABEL(label15), TRUE); gtk_misc_set_padding(GTK_MISC(label15), 3, 0); frame3 = gtk_frame_new(NULL); gtk_widget_show(frame3); gtk_box_pack_start(GTK_BOX(vbox1), frame3, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame3), 3); table1 = gtk_table_new(6, 2, FALSE); gtk_widget_show(table1); gtk_container_add(GTK_CONTAINER(frame3), table1); gtk_container_set_border_width(GTK_CONTAINER(table1), 6); gtk_table_set_row_spacings(GTK_TABLE(table1), 2); gtk_table_set_col_spacings(GTK_TABLE(table1), 2); label5 = gtk_label_new(_("Physical Channel")); gtk_widget_show(label5); gtk_table_attach(GTK_TABLE(table1), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label6 = gtk_label_new(_("Signal Strength %")); gtk_widget_show(label6); gtk_table_attach(GTK_TABLE(table1), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label7 = gtk_label_new(_("Signal Quality %")); gtk_widget_show(label7); gtk_table_attach(GTK_TABLE(table1), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label8 = gtk_label_new(_("Symbol Quality %")); gtk_widget_show(label8); gtk_table_attach(GTK_TABLE(table1), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); SignalStrengthStatus = gtk_progress_bar_new(); gtk_widget_show(SignalStrengthStatus); gtk_table_attach(GTK_TABLE(table1), SignalStrengthStatus, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); SignalQualityStatus = gtk_progress_bar_new(); gtk_widget_show(SignalQualityStatus); gtk_table_attach(GTK_TABLE(table1), SignalQualityStatus, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); SymbolQualityStatus = gtk_progress_bar_new(); gtk_widget_show(SymbolQualityStatus); gtk_table_attach(GTK_TABLE(table1), SymbolQualityStatus, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); PhysicalChannelStatus = gtk_entry_new(); gtk_widget_show(PhysicalChannelStatus); gtk_table_attach(GTK_TABLE(table1), PhysicalChannelStatus, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_sensitive(PhysicalChannelStatus, FALSE); GTK_WIDGET_UNSET_FLAGS(PhysicalChannelStatus, GTK_CAN_FOCUS); gtk_editable_set_editable(GTK_EDITABLE(PhysicalChannelStatus), FALSE); gtk_entry_set_text(GTK_ENTRY(PhysicalChannelStatus), _("none")); gtk_entry_set_invisible_char(GTK_ENTRY(PhysicalChannelStatus), 9679); label10 = gtk_label_new(_("Network Rate")); gtk_widget_show(label10); gtk_table_attach(GTK_TABLE(table1), label10, 0, 1, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); NetworkRateStatus = gtk_entry_new(); gtk_widget_show(NetworkRateStatus); gtk_table_attach(GTK_TABLE(table1), NetworkRateStatus, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_sensitive(NetworkRateStatus, FALSE); GTK_WIDGET_UNSET_FLAGS(NetworkRateStatus, GTK_CAN_FOCUS); gtk_editable_set_editable(GTK_EDITABLE(NetworkRateStatus), FALSE); gtk_entry_set_text(GTK_ENTRY(NetworkRateStatus), _("0.000 Mbps")); gtk_entry_set_invisible_char(GTK_ENTRY(NetworkRateStatus), 9679); label4 = gtk_label_new(_("Status")); gtk_widget_show(label4); gtk_frame_set_label_widget(GTK_FRAME(frame3), label4); gtk_label_set_use_markup(GTK_LABEL(label4), TRUE); gtk_misc_set_padding(GTK_MISC(label4), 3, 0); label2 = gtk_label_new(_("Tuner")); gtk_widget_show(label2); gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 0), label2); vbox3 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox3); gtk_container_add(GTK_CONTAINER(Tab), vbox3); frame4 = gtk_frame_new(NULL); gtk_widget_show(frame4); gtk_box_pack_start(GTK_BOX(vbox3), frame4, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame4), 3); table3 = gtk_table_new(2, 2, FALSE); gtk_widget_show(table3); gtk_container_add(GTK_CONTAINER(frame4), table3); gtk_container_set_border_width(GTK_CONTAINER(table3), 3); gtk_table_set_row_spacings(GTK_TABLE(table3), 3); gtk_table_set_col_spacings(GTK_TABLE(table3), 3); FirmwareVersion = gtk_label_new(""); gtk_widget_show(FirmwareVersion); gtk_table_attach(GTK_TABLE(table3), FirmwareVersion, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_misc_set_alignment(GTK_MISC(FirmwareVersion), 0, 0.5); UpgradeBtn = gtk_button_new_with_mnemonic(_("Upgrade")); gtk_widget_show(UpgradeBtn); gtk_table_attach(GTK_TABLE(table3), UpgradeBtn, 1, 2, 1, 2, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_sensitive(UpgradeBtn, FALSE); hbox3 = gtk_hbox_new(FALSE, 3); gtk_widget_show(hbox3); gtk_table_attach(GTK_TABLE(table3), hbox3, 0, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); UpgradeFilename = gtk_entry_new(); gtk_widget_show(UpgradeFilename); gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilename, TRUE, TRUE, 0); gtk_entry_set_invisible_char(GTK_ENTRY(UpgradeFilename), 9679); UpgradeFilenameBtn = gtk_button_new_with_mnemonic("..."); gtk_widget_show(UpgradeFilenameBtn); gtk_box_pack_start(GTK_BOX(hbox3), UpgradeFilenameBtn, FALSE, FALSE, 0); label14 = gtk_label_new(_("Upgrade")); gtk_widget_show(label14); gtk_frame_set_label_widget(GTK_FRAME(frame4), label14); gtk_misc_set_padding(GTK_MISC(label14), 3, 0); label3 = gtk_label_new(_("Upgrade")); gtk_widget_show(label3); gtk_notebook_set_tab_label(GTK_NOTEBOOK(Tab), gtk_notebook_get_nth_page(GTK_NOTEBOOK(Tab), 1), label3); g_signal_connect((gpointer) hdhomerun_config, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect((gpointer) hdhomerun_config, "key_press_event", G_CALLBACK(on_hdhomerun_config_key_press_event), NULL); g_signal_connect((gpointer) RescanBtn, "clicked", G_CALLBACK(on_RescanBtn_clicked), NULL); g_signal_connect_after((gpointer) Tab, "switch_page", G_CALLBACK(on_Tab_switch_page), NULL); g_signal_connect((gpointer) LaunchVlcBtn, "clicked", G_CALLBACK(on_LaunchVlcBtn_clicked), NULL); g_signal_connect((gpointer) StopVlcBtn, "clicked", G_CALLBACK(on_StopVlcBtn_clicked), NULL); g_signal_connect((gpointer) ChannelMapEdit, "changed", G_CALLBACK(on_ChannelMapEdit_changed), NULL); g_signal_connect((gpointer) ChannelNumberSpin, "value_changed", G_CALLBACK(on_ChannelNumberSpin_value_changed), NULL); g_signal_connect_after((gpointer) ChannelNumberSpin, "activate", G_CALLBACK(on_ChannelNumberSpin_activate), NULL); g_signal_connect((gpointer) ProgramList, "changed", G_CALLBACK(on_ProgramList_changed), NULL); g_signal_connect((gpointer) ScanDownBtn, "clicked", G_CALLBACK(on_ScanDownBtn_clicked), NULL); g_signal_connect((gpointer) ScanUpBtn, "clicked", G_CALLBACK(on_ScanUpBtn_clicked), NULL); g_signal_connect((gpointer) UpgradeBtn, "clicked", G_CALLBACK(on_UpgradeBtn_clicked), NULL); g_signal_connect((gpointer) UpgradeFilename, "changed", G_CALLBACK(on_UpgradeFilename_changed), NULL); g_signal_connect((gpointer) UpgradeFilenameBtn, "clicked", G_CALLBACK(on_UpgradeFilenameBtn_clicked), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF(hdhomerun_config, hdhomerun_config, "hdhomerun_config"); GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame1, "frame1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, DeviceListTree, "DeviceListTree"); GLADE_HOOKUP_OBJECT(hdhomerun_config, RescanBtn, "RescanBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label1, "label1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, Tab, "Tab"); GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame2, "frame2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, table2, "table2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label11, "label11"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label12, "label12"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label13, "label13"); GLADE_HOOKUP_OBJECT(hdhomerun_config, LaunchVlcBtn, "LaunchVlcBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, StopVlcBtn, "StopVlcBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox2, "hbox2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelMapEdit, "ChannelMapEdit"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ChannelNumberSpin, "ChannelNumberSpin"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ProgramList, "ProgramList"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanDownBtn, "ScanDownBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, ScanUpBtn, "ScanUpBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label15, "label15"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame3, "frame3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, table1, "table1"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label5, "label5"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label6, "label6"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label7, "label7"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label8, "label8"); GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalStrengthStatus, "SignalStrengthStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, SignalQualityStatus, "SignalQualityStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, SymbolQualityStatus, "SymbolQualityStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, PhysicalChannelStatus, "PhysicalChannelStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label10, "label10"); GLADE_HOOKUP_OBJECT(hdhomerun_config, NetworkRateStatus, "NetworkRateStatus"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label4, "label4"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label2, "label2"); GLADE_HOOKUP_OBJECT(hdhomerun_config, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, frame4, "frame4"); GLADE_HOOKUP_OBJECT(hdhomerun_config, table3, "table3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, FirmwareVersion, "FirmwareVersion"); GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeBtn, "UpgradeBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, hbox3, "hbox3"); GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilename, "UpgradeFilename"); GLADE_HOOKUP_OBJECT(hdhomerun_config, UpgradeFilenameBtn, "UpgradeFilenameBtn"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label14, "label14"); GLADE_HOOKUP_OBJECT(hdhomerun_config, label3, "label3"); return hdhomerun_config; }