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