/**
* gimp_enum_radio_frame_new_with_range:
* @enum_type: the #GType of an enum.
* @minimum: the minimum enum value
* @maximum: the maximum enum value
* @label_widget: a widget to put into the frame that will hold the radio box.
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Calls gimp_enum_radio_box_new_with_range() and puts the resulting
* vbox into a #GtkFrame.
*
* Return value: a new #GtkFrame holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.4
**/
GtkWidget *
gimp_enum_radio_frame_new_with_range (GType enum_type,
gint minimum,
gint maximum,
GtkWidget *label_widget,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GtkWidget *frame;
GtkWidget *radio_box;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
g_return_val_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget),
NULL);
frame = gimp_frame_new (NULL);
if (label_widget)
{
gtk_frame_set_label_widget (GTK_FRAME (frame), label_widget);
gtk_widget_show (label_widget);
}
radio_box = gimp_enum_radio_box_new_with_range (enum_type,
minimum,
maximum,
callback, callback_data,
first_button);
gtk_container_add (GTK_CONTAINER (frame), radio_box);
gtk_widget_show (radio_box);
return frame;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), -1, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(window), frame);
GtkWidget *label1 = gtk_label_new("<b>Common Frame</b>");
gtk_label_set_use_markup(GTK_LABEL(label1), TRUE);
gtk_frame_set_label_widget(GTK_FRAME(frame), label1);
GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 5, 0, 12, 0);
gtk_container_add(GTK_CONTAINER(frame), alignment);
GtkWidget *label2 = gtk_label_new("Label inside a Common Frame");
gtk_container_add(GTK_CONTAINER(alignment), label2);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget *
gimp_color_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *scale;
GtkWidget *button;
/* the sample average options */
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
scale = gimp_prop_spin_scale_new (config, "average-radius", NULL,
1.0, 10.0, 0);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_widget_show (scale);
button = gimp_prop_check_button_new (config, "sample-average", NULL);
gtk_frame_set_label_widget (GTK_FRAME (frame), button);
gtk_widget_show (button);
g_object_bind_property (config, "sample-average",
scale, "sensitive",
G_BINDING_SYNC_CREATE);
return vbox;
}
void viewer_add_renderer (Viewer *self, Renderer *renderer, int priority)
{
renderer->priority = priority;
renderer->cmi = gtk_check_menu_item_new_with_label (renderer->name);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (renderer->cmi), renderer->enabled);
g_object_set_data (G_OBJECT (renderer->cmi), "Viewer:plugin", renderer);
g_signal_connect (G_OBJECT (renderer->cmi), "toggled",
G_CALLBACK (on_renderer_enabled_toggled), self);
g_ptr_array_add(self->renderers, renderer);
g_ptr_array_add(self->renderers_sorted, renderer);
g_ptr_array_sort(self->renderers_sorted, renderer_name_compare_function);
// What position in the sorted array is this item?
unsigned int menu_idx = g_ptr_array_find_index(self->renderers_sorted, renderer);
// add the menu item, accounting for the tear-off tab at index 0
gtk_menu_shell_insert (GTK_MENU_SHELL (self->renderers_menu), renderer->cmi, menu_idx + 1);
gtk_widget_show (renderer->cmi);
// create a control widget
if (renderer->widget) {
g_ptr_array_add(self->renderers_sorted_with_controls, renderer);
g_ptr_array_sort(self->renderers_sorted_with_controls, renderer_name_compare_function);
unsigned int control_idx = g_ptr_array_find_index(self->renderers_sorted_with_controls, renderer);
renderer->expander = gtk_expander_new (renderer->name);
gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander), TRUE);
renderer->control_frame = gtk_frame_new (NULL);
if (renderer->enabled) {
gtk_widget_show (renderer->control_frame);
} else {
gtk_widget_hide (renderer->control_frame);
}
gtk_frame_set_label_widget (GTK_FRAME (renderer->control_frame), renderer->expander);
gtk_container_add (GTK_CONTAINER (renderer->control_frame), renderer->widget);
gtk_box_pack_start (GTK_BOX (self->controls_box), renderer->control_frame,
FALSE, TRUE, 0);
gtk_box_reorder_child (GTK_BOX (self->controls_box), renderer->control_frame, control_idx);
gtk_widget_show (renderer->expander);
gtk_widget_show (renderer->widget);
g_signal_connect (G_OBJECT (renderer->expander), "notify::expanded",
G_CALLBACK (on_renderer_widget_expander_notify), self);
g_object_set_data (G_OBJECT (renderer->expander),
"Viewer:plugin", renderer);
g_object_set_data (G_OBJECT (renderer->widget),
"Viewer:expander", renderer->expander);
g_object_set_data (G_OBJECT (renderer->widget),
"Viewer:frame", renderer->control_frame);
}
g_ptr_array_sort(self->renderers, sort_renderers_priority_decreasing);
}
GtkWidget *
mk_properties()
{
GtkWidget *vbox, *hbox, *hbox2, *label, *frame;
ENTER;
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL (label),"<span weight=\"bold\">Properties</span>");
gtk_frame_set_label_widget(GTK_FRAME (frame), label);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 6);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox2), hbox, FALSE, TRUE, 0);
gtk_widget_set_size_request(hbox, 20, 1);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox2), vbox, FALSE, TRUE, 0);
prop_dt_checkb = gtk_check_button_new_with_label("Set Dock Type");
gtk_box_pack_start(GTK_BOX (vbox), prop_dt_checkb, FALSE, FALSE, 0);
prop_st_checkb = gtk_check_button_new_with_label("Set Strut");
gtk_box_pack_start(GTK_BOX (vbox), prop_st_checkb, FALSE, FALSE, 0);
RET(frame);
}
GtkWidget *
balsa_mime_widget_crypto_frame(LibBalsaMessageBody * mime_body, GtkWidget * child,
gboolean was_encrypted, gboolean no_signature,
GtkWidget * signature)
{
GtkWidget * frame;
GtkWidget * vbox;
GtkWidget * icon_box;
frame = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, BMW_VBOX_SPACE);
gtk_container_add(GTK_CONTAINER(frame), vbox);
icon_box = gtk_hbox_new(FALSE, BMW_VBOX_SPACE);
if (was_encrypted)
gtk_box_pack_start(GTK_BOX(icon_box),
gtk_image_new_from_stock(BALSA_PIXMAP_ENCR, GTK_ICON_SIZE_MENU),
FALSE, FALSE, 0);
if (!no_signature) {
const gchar * icon_name =
balsa_mime_widget_signature_icon_name(libbalsa_message_body_protect_state(mime_body));
if (!icon_name)
icon_name = BALSA_PIXMAP_SIGN;
gtk_box_pack_start(GTK_BOX(icon_box),
gtk_image_new_from_stock(icon_name, GTK_ICON_SIZE_MENU),
FALSE, FALSE, 0);
}
gtk_frame_set_label_widget(GTK_FRAME(frame), icon_box);
gtk_container_set_border_width(GTK_CONTAINER(vbox), BMW_MESSAGE_PADDING);
gtk_box_pack_start(GTK_BOX(vbox), child, FALSE, FALSE, 0);
if (signature)
gtk_box_pack_end(GTK_BOX(vbox), signature, FALSE, FALSE, 0);
return frame;
}
static GtkWidget *
user_interface_mode_frame (SettingsDlg *dialog)
{
GtkWidget *frame;
GtkWidget *label;
GtkWidget *frame_vbox;
GtkWidget *button;
/* Build UI. */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new (_("<b>User interface</b>"));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
frame_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), frame_vbox);
button = gtk_check_button_new_with_mnemonic (_("Use _advanced mode"));
gtk_container_add (GTK_CONTAINER (frame_vbox), button);
dialog->ui.advanced_mode = GTK_TOGGLE_BUTTON (button);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (advanced_mode_toggled), dialog);
button = gtk_check_button_new_with_mnemonic (_("Show advanced _options"));
gtk_container_add (GTK_CONTAINER (frame_vbox), button);
dialog->ui.show_advanced_options = GTK_TOGGLE_BUTTON (button);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (show_advanced_options_toggled), dialog);
return frame;
}
static GtkWidget *
default_keyserver_frame (SettingsDlg *dialog)
{
GtkWidget *frame;
GtkWidget *label;
GtkWidget *combo;
GList *servers;
/* Build UI */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new_with_mnemonic (_("<b>Default key_server</b>"));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
combo = gtk_combo_box_entry_new_text ();
gtk_container_set_border_width (GTK_CONTAINER (combo), 5);
gtk_container_add (GTK_CONTAINER (frame), combo);
/* Set current value. */
servers = keyserver_get_as_glist ();
g_list_foreach (servers, append_to_combo, combo);
g_list_free (servers);
dialog->keyserver.combo = GTK_COMBO_BOX (combo);
g_signal_connect_swapped (G_OBJECT (combo),
"changed",
G_CALLBACK (keyserver_selected_from_list_cb),
dialog);
dialog->keyserver.frame = frame;
return frame;
}
GtkWidget* createFrame(GPtrArray *entries, GPtrArray *all, const gchar name[], const gchar *names[], const gchar *wnames[], const int size)
{
GtkWidget *_frame;
GtkWidget *_label;
GtkWidget *_vbox;
int i;
_frame = gtk_frame_new(NULL);
_vbox = gtk_vbox_new(FALSE, 5);
_label = gtk_check_button_new_with_label(name);
g_ptr_array_add(all, _label);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_label), TRUE);
gtk_frame_set_label_widget(GTK_FRAME(_frame), GTK_WIDGET(_label));
for ( i=0; i<size; i++ )
{
gtk_container_add(GTK_CONTAINER(_vbox), createEntry(entries, all, names[i], wnames[i]));
}
gtk_container_add(GTK_CONTAINER(_frame), GTK_WIDGET(_vbox));
gtk_container_set_border_width(GTK_CONTAINER(_frame), 5);
g_signal_connect(G_OBJECT(_label), "toggled",
G_CALLBACK(toggle_action), (gpointer) _vbox);
return _frame;
}
GtkWidget *
gimp_clone_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_paint_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *combo;
GtkWidget *source_vbox;
GtkWidget *button;
GtkWidget *hbox;
/* the source frame */
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
/* the source type menu */
combo = gimp_prop_enum_combo_box_new (config, "clone-type", 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo), _("Source"));
g_object_set (combo, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_frame_set_label_widget (GTK_FRAME (frame), combo);
gtk_widget_show (combo);
source_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), source_vbox);
gtk_widget_show (source_vbox);
button = gimp_prop_check_button_new (config, "sample-merged", NULL);
gtk_box_pack_start (GTK_BOX (source_vbox), button, FALSE, FALSE, 0);
g_object_bind_property_full (config, "clone-type",
button, "visible",
G_BINDING_SYNC_CREATE,
gimp_clone_options_sync_source,
NULL,
GINT_TO_POINTER (GIMP_CLONE_IMAGE), NULL);
hbox = gimp_prop_pattern_box_new (NULL, GIMP_CONTEXT (tool_options),
NULL, 2,
"pattern-view-type", "pattern-view-size");
gtk_box_pack_start (GTK_BOX (source_vbox), hbox, FALSE, FALSE, 0);
g_object_bind_property_full (config, "clone-type",
hbox, "visible",
G_BINDING_SYNC_CREATE,
gimp_clone_options_sync_source,
NULL,
GINT_TO_POINTER (GIMP_CLONE_PATTERN), NULL);
combo = gimp_prop_enum_combo_box_new (config, "align-mode", 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo), _("Alignment"));
g_object_set (combo, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_box_pack_start (GTK_BOX (vbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
return vbox;
}
GtkWidget* wxControl::GTKCreateFrame(const wxString& label)
{
const wxString labelGTK = GTKConvertMnemonics(label);
GtkWidget* labelwidget = gtk_label_new_with_mnemonic(wxGTK_CONV(labelGTK));
gtk_widget_show(labelwidget); // without this it won't show...
GtkWidget* framewidget = gtk_frame_new(NULL);
gtk_frame_set_label_widget(GTK_FRAME(framewidget), labelwidget);
return framewidget; // note that the label is already set so you'll
// only need to call wxControl::SetLabel afterwards
}
GtkWidget *
pgd_movie_view_new (void)
{
GtkWidget *frame, *label;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<b>Movie Properties</b>");
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_widget_show (label);
return frame;
}
GtkWidget *
pgd_action_view_new (PopplerDocument *document)
{
GtkWidget *frame, *label;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<b>Action Properties</b>");
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_widget_show (label);
g_object_set_data (G_OBJECT (frame), "document", document);
return frame;
}
void verification( void )
{
GtkWidget *logo_with_name, *instruction_label, *cancel_button, *logo, *body_frame;
//GtkWidget *status_label, *install_button, *unlock_button;
gtk_window_set_title( GTK_WINDOW( main_window), "Advanced Server Management( Software verification )" );
//destroy the main table so that new table can be created
gtk_widget_destroy( main_table);
instruction_label = gtk_label_new( NULL );
status_label = gtk_label_new( NULL ); //show the status of the app ( locked or unlocked )
install_button = gtk_button_new();
unlock_button = gtk_button_new(); //click here to unlock the app
cancel_button = gtk_button_new_with_label( "ABORT" ); //terminate the app
logo = gtk_image_new_from_file ("trans.png");
logo_with_name = gtk_image_new_from_file ("small.png");
body_frame = gtk_frame_new( NULL );
main_table = gtk_table_new( 14, 12, TRUE );
gtk_label_set_markup( GTK_LABEL( instruction_label ), "<span fgcolor=\"green\" font=\"13\">Unlock and click on logo to start</span>" );
gtk_frame_set_label_widget ( GTK_FRAME( body_frame ), instruction_label );
gtk_label_set_markup( GTK_LABEL( status_label ), "<span fgcolor=\"red\" font=\"12\">LOCKED</span>" );
gtk_container_add( GTK_CONTAINER( unlock_button), status_label );
gtk_widget_set_sensitive (GTK_WIDGET (install_button), FALSE);
gtk_container_add( GTK_CONTAINER( install_button), logo );
g_signal_connect( GTK_OBJECT( install_button), "clicked", GTK_SIGNAL_FUNC( selection_menu ), NULL );
g_signal_connect( GTK_OBJECT( cancel_button), "clicked", GTK_SIGNAL_FUNC( gtk_main_quit ), NULL );
g_signal_connect( GTK_OBJECT( unlock_button), "clicked", GTK_SIGNAL_FUNC( verify_user ), NULL );
gtk_table_attach_defaults ( GTK_TABLE (main_table), logo_with_name, 1, 6, 10, 13);
gtk_table_attach_defaults ( GTK_TABLE (main_table), install_button, 1, 11, 2, 9);
gtk_table_attach_defaults ( GTK_TABLE (main_table), unlock_button, 7, 9, 11, 12);
gtk_table_attach_defaults ( GTK_TABLE (main_table), cancel_button, 9, 11, 11, 12);
gtk_table_attach_defaults ( GTK_TABLE (main_table), body_frame, 1, 11, 1, 9);
gtk_container_add( GTK_CONTAINER( main_window), main_table );
gtk_widget_show_all( main_window );
}
/* This function constructs the container holding all widgets making
up this data widget. It is called during instance creation. */
static void
construct_data_widget (GpaCMDinsig *card)
{
GtkWidget *frame;
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *label;
int rowidx;
char *text;
/* General frame. */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new (_("<b>General</b>"));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
table = gtk_table_new (2, 3, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 10);
gtk_container_add (GTK_CONTAINER (frame), table);
rowidx = 0;
card->entries[ENTRY_SERIALNO] = gtk_label_new (NULL);
add_table_row (table, &rowidx, _("Serial number:"),
card->entries[ENTRY_SERIALNO], NULL, 0);
gtk_box_pack_start (GTK_BOX (card), frame, FALSE, TRUE, 0);
/* Info frame. */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
vbox = gtk_vbox_new (FALSE, 5);
text = g_strdup_printf
(_("There is not much information to display for a %s card. "
"You may want to use the application selector button to "
"switch to another application available on this card."), "DINSIG");
label = gtk_label_new (text);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_box_pack_start (GTK_BOX (card), frame, FALSE, TRUE, 0);
}
GtkWidget *
mk_transparency()
{
GtkWidget *hbox, *hbox2, *label, *frame;
ENTER;
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL (label),"<span weight=\"bold\">Transparency</span>");
gtk_frame_set_label_widget(GTK_FRAME (frame), label);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 6);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox2), hbox, FALSE, TRUE, 0);
gtk_widget_set_size_request(hbox, 20, 1);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX (hbox2), hbox, FALSE, TRUE, 0);
tr_checkb = gtk_check_button_new_with_label("Enable Transparency");
gtk_widget_show(tr_checkb);
gtk_box_pack_start(GTK_BOX (hbox), tr_checkb, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(tr_checkb), "toggled", G_CALLBACK(transparency_toggle), NULL);
//gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tr_checkb), FALSE);
tr_colorl = gtk_label_new("Tint color:");
gtk_misc_set_alignment(GTK_MISC(tr_colorl), 0.0, 0.5);
gtk_widget_show(tr_colorl);
gtk_box_pack_start(GTK_BOX (hbox), tr_colorl, FALSE, FALSE, 5);
//gtk_widget_set_sensitive(tr_colorl, FALSE);
tr_colorb = gtk_color_button_new();
gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(tr_colorb), TRUE);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON(tr_colorb), 65535/256*125);
gtk_box_pack_start(GTK_BOX (hbox), tr_colorb, FALSE, FALSE, 0);
//gtk_widget_set_sensitive(tr_colorb, FALSE);
RET(frame);
}
static GtkWidget *
default_key_frame (SettingsDlg *dialog)
{
GtkWidget *frame;
GtkWidget *label;
GtkWidget *list;
GtkWidget *scroller;
/* Build UI. */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new_with_mnemonic (_("<b>Default _key</b>"));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
list = gpa_key_selector_new (TRUE, FALSE);
dialog->default_key.list = GPA_KEY_SELECTOR (list);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection
(GTK_TREE_VIEW (list)), GTK_SELECTION_SINGLE);
scroller = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroller),
GTK_SHADOW_IN);
gtk_widget_set_size_request (scroller, 320, 120);
gtk_container_set_border_width (GTK_CONTAINER (scroller), 5);
gtk_container_add (GTK_CONTAINER (scroller), list);
gtk_container_add (GTK_CONTAINER (frame), scroller);
/* Connect signals. */
g_signal_connect_swapped (G_OBJECT (gtk_tree_view_get_selection
(GTK_TREE_VIEW (list))),
"changed", G_CALLBACK (key_selected_cb), dialog);
dialog->default_key.frame = frame;
return frame;
}
static WIDGET *
frame_beginprop_get_widget(FrameProperty *prop, PropDialog *dialog)
{
gchar *foldstring = g_strdup_printf("%s <<<", _(prop->common.descr->description));
gchar *unfoldstring = g_strdup_printf("%s >>>", _(prop->common.descr->description));
GtkWidget *frame = gtk_frame_new(NULL);
GtkWidget *vbox = gtk_vbox_new(FALSE,2);
GtkWidget *foldbutton = gtk_button_new_with_label(foldstring);
GtkWidget *unfoldbutton = gtk_button_new_with_label(unfoldstring);
struct FoldButtonInfo *info = g_new(struct FoldButtonInfo, 1);
g_free(foldstring);
g_free(unfoldstring);
info->frame = frame;
info->unfoldbutton = unfoldbutton;
gtk_frame_set_label_widget(GTK_FRAME(frame), foldbutton);
gtk_container_set_border_width (GTK_CONTAINER(frame), 2);
gtk_container_add(GTK_CONTAINER(frame),vbox);
gtk_widget_set_sensitive (unfoldbutton, FALSE);
gtk_widget_show(foldbutton);
gtk_widget_show(frame);
gtk_widget_show(vbox);
prop_dialog_add_raw(dialog, frame);
prop_dialog_add_raw_with_flags(dialog, unfoldbutton, FALSE, FALSE);
g_signal_connect(G_OBJECT (foldbutton), "clicked",
G_CALLBACK (frame_fold_unfold), info);
g_signal_connect(G_OBJECT (unfoldbutton), "clicked",
G_CALLBACK (frame_fold_unfold), info);
prop_dialog_container_push(dialog,vbox);
return NULL; /* there is no single widget to add with a label next to it. */
}
/* функция для создания виджета GtkFrame с заданными параметрами и *
* необходимыми дополнительными виджетами. *
* *
* В функцию передаются следующие параметры: *
* > GPtrArray *entries - массив указателей на виджеты. В него *
* записываются указатели всех создаваемых виджетов для ввода информации *
* > gchar *frameName - указатель на строку с текстом для метки *
* фрейма *
* > gchar *names[] - указатель на массив размерностью size, *
* который содержит строки для меток для каждого поля ввода *
* > gchar *wnames[] - указатель на массив размерностью size, *
* который содержит строки для указания имени виджета (используется в *
* SQL запросах) *
* > int size - содержит количество виджетов ввода во *
* фрейме *
* *
* функция возвращает указатель на фрейм, содержащий size виджетов ввода */
GtkWidget* createFrame(GPtrArray *entries, const gchar *frameName, const gchar *names[], const gchar *wnames[], const int size)
{
GtkWidget *_frame; // фрейм
GtkWidget *_checkButtonWLabel; // GtkCheckButton с меткой
GtkWidget *_vbox; // Вертикальный бокс
int i;
// Создаем пустой фрейм
_frame = gtk_frame_new(NULL);
// Создаем вертикальный бокс
_vbox = gtk_vbox_new(FALSE, 5);
// Создаем GtkCheckButton с меткой frameName
_checkButtonWLabel = gtk_check_button_new_with_label(frameName);
// Устанавливаем GtkCheckButton в активное состояние
//gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_checkButtonWLabel), TRUE);
// Устанавливаем GtkCheckButton в качестве метки фрейма
gtk_frame_set_label_widget(GTK_FRAME(_frame), GTK_WIDGET(_checkButtonWLabel));
// Заполняем фрейм полями ввода
for ( i=0; i<size; i++ )
{
// Вызываем функцию createEntry для создания виджета ввода с меткой и
// GtkCheckButton
gtk_container_add(GTK_CONTAINER(_vbox), createEntry(entries, names[i], wnames[i]));
}
// Добавляем в вертикальный бокс фрейм
gtk_container_add(GTK_CONTAINER(_frame), GTK_WIDGET(_vbox));
gtk_container_set_border_width(GTK_CONTAINER(_frame), 5);
// Соединяем сигнал снятия галочки с GtkCheckButton с вертикальным боксом.
// Вообще _vbox заведен для того, чтобы не блокировался сам фрейм и _checkButtonWLabel
g_signal_connect(G_OBJECT(_checkButtonWLabel), "toggled",
G_CALLBACK(toggle_action), (gpointer) _vbox);
g_signal_emit_by_name(_checkButtonWLabel, "toggled", (gpointer)_vbox);
return _frame;
}
/* This function constructs the container holding all widgets making
up this data widget. It is called during instance creation. */
static void
construct_data_widget (GpaCMUnknown *card)
{
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *label;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
label = gtk_label_new (_("<b>Unknown Card</b>"));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_box_pack_start (GTK_BOX (card), frame, FALSE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
vbox = gtk_vbox_new (FALSE, 5);
card->label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), card->label, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_box_pack_start (GTK_BOX (card), frame, FALSE, TRUE, 0);
}
GtkWidget *
utl_gui_create_frame (GtkWidget *container, const gchar *name)
{
GtkWidget *frame, *label, *alignment;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
/* gtk_container_add (GTK_CONTAINER (container), frame);*/
gtk_box_pack_start (GTK_BOX (container), frame, FALSE, FALSE, 0);
label = utl_gui_create_label ("<b>%s</b>", name);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
ALIGNMENT_PADDING_TOP, ALIGNMENT_PADDING_BOTTOM,
ALIGNMENT_PADDING_LEFT, ALIGNMENT_PADDING_RIGHT);
return alignment;
}
static void calendar_properties_dialog_polish(EConfigHookItemFactoryData *data)
{
GtkTable *table = GTK_TABLE(data->parent);
GtkFrame *frame = gtk_widget_get_parent(
GTK_WIDGET(gtk_widget_get_parent(GTK_WIDGET(table))));
GtkLabel *label = gtk_label_new("General");
gtk_widget_show(GTK_WIDGET(label));
PangoAttribute *attr = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
PangoAttrList *list = pango_attr_list_new();
pango_attr_list_insert(list, attr);
gtk_label_set_attributes(label, list);
gtk_frame_set_label_widget(frame, GTK_WIDGET(label));
GSList *children = g_slist_reverse(gtk_container_get_children(GTK_CONTAINER(table)));
gtk_widget_hide(GTK_WIDGET(children->data));
gtk_widget_hide(GTK_WIDGET(children->next->data));
// XXX: Changing width of colorButton is not so easy, will see
//GSList *iter;
//for (iter = children; iter; iter = iter->next)
//{
// gchar *name = gtk_widget_get_name(GTK_WIDGET(iter->data));
// if (g_strcmp0(name, "GtkColorButton") == 0 )
// {
// gint x, y;
// gtk_widget_get_size_request(GTK_WIDGET(iter->data), &x, &y);
// printf("\tsize: %dx%d\n", x, y);
// gtk_widget_set_size_request(GTK_WIDGET(iter->data), 20, -1);
// gtk_widget_get_size_request(GTK_WIDGET(iter->data), &x, &y);
// printf("\tsize: %dx%d\n", x, y);
// }
//}
g_slist_free(children);
}
/**
* Create a vbox that contains all controls used to display
* information related to current reconciliation.
*
* \return A newly-allocated frame containing the reconcile widget
*/
GtkWidget *gsb_reconcile_create_box ( void )
{
GtkWidget *frame, *label, *table, *vbox, *hbox, *button, *separator;
frame = gtk_frame_new ( NULL );
vbox = gtk_vbox_new ( FALSE, 3 );
gtk_container_set_border_width ( GTK_CONTAINER ( vbox ), 3 );
gtk_container_add ( GTK_CONTAINER ( frame ), vbox );
/* the title of the frame */
label = gtk_label_new ( NULL );
gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
gtk_misc_set_alignment ( GTK_MISC (label), 0.0, 0.0 );
gtk_frame_set_label_widget ( GTK_FRAME(frame), label);
/* number of reconcile */
hbox = gtk_hbox_new ( FALSE, 5 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 0);
label = gtk_label_new ( _("Reconciliation reference: ") );
gtk_box_pack_start ( GTK_BOX ( hbox ), label, FALSE, FALSE, 0);
reconcile_number_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text ( GTK_WIDGET (reconcile_number_entry),
_("If reconciliation reference ends in a digit, it is "
"automatically incremented at each reconciliation.\n"
"You can let it empty if you don't want to keep a trace of "
"the reconciliation.") );
gtk_box_pack_start ( GTK_BOX ( hbox ), reconcile_number_entry, TRUE, TRUE, 0);
separator = gtk_hseparator_new();
gtk_box_pack_start ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
/* under the reconcile number, we have a table */
table = gtk_table_new ( 3, 5, FALSE );
gtk_table_set_row_spacings ( GTK_TABLE ( table ), 3 );
gtk_box_pack_start ( GTK_BOX ( vbox ), table, FALSE, FALSE, 0);
separator = gtk_hseparator_new();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 0, 3, 1, 2 );
separator = gtk_hseparator_new();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 0, 3, 3, 4 );
separator = gtk_vseparator_new ();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 1, 2, 0, 5 );
label = gtk_label_new ( _("Date") );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 0, 1);
label = gtk_label_new ( _("Balance") );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 2, 3, 0, 1);
reconcile_last_date_label = gtk_label_new ( NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_last_date_label,
0, 1, 2, 3 );
/* set the old balance,
* an entry the first time, will be unsensitive after */
reconcile_initial_balance_entry = gtk_entry_new ( );
gtk_widget_set_size_request ( reconcile_initial_balance_entry, 50, -1 );
g_signal_connect ( G_OBJECT ( reconcile_initial_balance_entry ),
"changed",
G_CALLBACK (gsb_reconcile_update_amounts),
NULL );
g_signal_connect ( G_OBJECT ( reconcile_initial_balance_entry ),
"focus-out-event",
G_CALLBACK ( gsb_reconcile_entry_lose_focus ),
NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_initial_balance_entry,
2, 3, 2, 3 );
/* make the new date entry */
reconcile_new_date_entry = gsb_calendar_entry_new (TRUE);
gtk_widget_set_size_request ( reconcile_new_date_entry, 50, -1 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_new_date_entry,
0, 1, 4, 5 );
/* set the new balance */
reconcile_final_balance_entry = gtk_entry_new ();
gtk_widget_set_size_request ( reconcile_final_balance_entry, 50, -1 );
g_signal_connect ( G_OBJECT ( reconcile_final_balance_entry ),
"changed",
G_CALLBACK (gsb_reconcile_update_amounts),
NULL );
g_signal_connect ( G_OBJECT ( reconcile_final_balance_entry ),
"focus-out-event",
G_CALLBACK ( gsb_reconcile_entry_lose_focus ),
NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_final_balance_entry,
2, 3, 4, 5 );
separator = gtk_hseparator_new();
gtk_box_pack_start ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
/* 2nd table under that, with the balances labels */
table = gtk_table_new ( 5, 2, FALSE );
gtk_table_set_row_spacings ( GTK_TABLE ( table ), 5 );
gtk_box_pack_start ( GTK_BOX ( vbox ), table, FALSE, FALSE, 0);
label = gtk_label_new ( _("Initial balance: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 0, 1);
reconcile_initial_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_initial_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_initial_balance_label, 1, 2, 0, 1);
label = gtk_label_new ( _("Final balance: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 1, 2);
reconcile_final_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_final_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_final_balance_label, 1, 2, 1, 2);
label = gtk_label_new ( _("Checking: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 2, 3);
reconcile_marked_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_marked_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_marked_balance_label, 1, 2, 2, 3);
separator = gtk_hseparator_new();
gtk_table_attach_defaults ( GTK_TABLE ( table ), separator, 0, 2, 3, 4);
label = gtk_label_new ( _("Variance: ") );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), label, 0, 1, 4, 5);
reconcile_variation_balance_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( reconcile_variation_balance_label ), 1, 0.5 );
gtk_table_attach_defaults ( GTK_TABLE ( table ), reconcile_variation_balance_label, 1, 2, 4, 5);
/* set the button to sort with the method of paymen */
separator = gtk_hseparator_new();
gtk_box_pack_start ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
hbox = gtk_hbox_new ( TRUE, 3 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 0);
reconcile_sort_list_button = gtk_check_button_new_with_label (_("Sort by method of payment"));
gtk_button_set_relief ( GTK_BUTTON (reconcile_sort_list_button), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (reconcile_sort_list_button), "clicked",
G_CALLBACK (gsb_reconcile_list_button_clicked), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), reconcile_sort_list_button, FALSE, FALSE, 0);
/* make the buttons */
hbox = gtk_hbox_new ( TRUE, 3 );
gtk_box_pack_end ( GTK_BOX ( vbox ), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock ( GTK_STOCK_CANCEL );
gtk_button_set_relief ( GTK_BUTTON ( button), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (button), "clicked",
G_CALLBACK (gsb_reconcile_cancel), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), button, FALSE, FALSE, 0);
reconcile_ok_button = gtk_button_new_from_stock ( GTK_STOCK_OK );
gtk_button_set_relief ( GTK_BUTTON ( reconcile_ok_button), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT ( reconcile_ok_button ), "clicked",
G_CALLBACK (gsb_reconcile_finish_reconciliation), NULL );
gtk_box_pack_start ( GTK_BOX ( hbox ), reconcile_ok_button, FALSE, FALSE, 0);
separator = gtk_hseparator_new();
gtk_box_pack_end ( GTK_BOX ( vbox ), separator, FALSE, FALSE, 0);
gtk_widget_show_all ( frame );
return ( frame );
}
GtkWidget*
create_threshold_dialog (void)
{
GtkWidget *threshold_dialog;
GtkWidget *dialogVbox;
GtkWidget *allButButtonsVbox;
GtkWidget *settingsOuterHbox;
GtkWidget *settingsOuterVbox;
GtkWidget *minValueVbox;
GtkWidget *minValueLabel;
GtkWidget *minValueHbox;
GtkWidget *minValueSlider;
GtkObject *minValueSpinner_adj;
GtkWidget *minValueSpinner;
GtkWidget *maxValueVbox;
GtkWidget *maxValueLabel;
GtkWidget *maxValueHbox;
GtkWidget *maxValueSlider;
GtkObject *maxValueSpinner_adj;
GtkWidget *maxValueSpinner;
GtkWidget *outputValuesHbox;
GtkWidget *outputValuesLabel;
GtkWidget *outputValuesMenu;
GtkWidget *debugHbox;
GtkWidget *debugLabel;
GtkObject *debugSpinButton_adj;
GtkWidget *debugSpinButton;
GtkWidget *previewFrame;
GtkWidget *previewAlignment;
GtkWidget *previewVbox;
GtkWidget *previewControlHbox;
GtkWidget *previewOutputMenu;
GtkWidget *previewSlider;
GtkWidget *previewVideo;
GtkWidget *previewLabel;
GtkWidget *dialogButtonBox;
GtkWidget *cancelButton;
GtkWidget *okButton;
threshold_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (threshold_dialog), QT_TR_NOOP("Threshold"));
gtk_window_set_type_hint (GTK_WINDOW (threshold_dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialogVbox = GTK_DIALOG (threshold_dialog)->vbox;
gtk_widget_show (dialogVbox);
allButButtonsVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (allButButtonsVbox);
gtk_box_pack_start (GTK_BOX (dialogVbox), allButButtonsVbox, TRUE, TRUE, 0);
settingsOuterHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (settingsOuterHbox);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), settingsOuterHbox, FALSE, TRUE, 0);
settingsOuterVbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (settingsOuterVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterHbox), settingsOuterVbox, TRUE, TRUE, 0);
minValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (minValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), minValueVbox, FALSE, FALSE, 0);
minValueLabel = gtk_label_new (QT_TR_NOOP("Minimum value to be in-range:"));
gtk_widget_show (minValueLabel);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueLabel, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (minValueLabel), 0.5, 1);
gtk_misc_set_padding (GTK_MISC (minValueLabel), 0, 8);
minValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (minValueHbox);
gtk_box_pack_start (GTK_BOX (minValueVbox), minValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 255, 1, 1, 0)));
#else
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 1, 0);
minValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (minValueSpinner_adj));
#endif
gtk_widget_show (minValueSlider);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (minValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (minValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (minValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
minValueSpinner_adj = gtk_adjustment_new (0, 0, 255, 1, 10, 10);
#endif
minValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (minValueSpinner_adj), 1, 0);
gtk_widget_show (minValueSpinner);
gtk_box_pack_start (GTK_BOX (minValueHbox), minValueSpinner, FALSE, TRUE, 0);
maxValueVbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (maxValueVbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), maxValueVbox, FALSE, FALSE, 0);
maxValueLabel = gtk_label_new (QT_TR_NOOP("Maximum value to be in-range:"));
gtk_widget_show (maxValueLabel);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueLabel, FALSE, FALSE, 0);
maxValueHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (maxValueHbox);
gtk_box_pack_start (GTK_BOX (maxValueVbox), maxValueHbox, TRUE, TRUE, 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (255, 0, 255, 1, 1, 0)));
#else
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 1, 0);
maxValueSlider = gtk_hscale_new (GTK_ADJUSTMENT (maxValueSpinner_adj));
#endif
gtk_widget_show (maxValueSlider);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSlider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (maxValueSlider), FALSE);
gtk_scale_set_value_pos (GTK_SCALE (maxValueSlider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (maxValueSlider), 0);
#ifdef ORIGINAL_CODE_GENERATED_BY_GLADE
maxValueSpinner_adj = gtk_adjustment_new (255, 0, 255, 1, 10, 10);
#endif
maxValueSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (maxValueSpinner_adj), 1, 0);
gtk_widget_show (maxValueSpinner);
gtk_box_pack_start (GTK_BOX (maxValueHbox), maxValueSpinner, FALSE, TRUE, 0);
outputValuesHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (outputValuesHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputValuesHbox, TRUE, TRUE, 0);
outputValuesLabel = gtk_label_new (QT_TR_NOOP("Output values: "));
gtk_widget_show (outputValuesLabel);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesLabel, FALSE, FALSE, 0);
outputValuesMenu = gtk_combo_box_new_text ();
gtk_widget_show (outputValuesMenu);
gtk_box_pack_start (GTK_BOX (outputValuesHbox), outputValuesMenu, TRUE, TRUE, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go black, out-of-range values go white"));
gtk_combo_box_append_text (GTK_COMBO_BOX (outputValuesMenu), QT_TR_NOOP("In-range values go white, out-of-range values go black"));
debugHbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (debugHbox);
gtk_box_pack_start (GTK_BOX (settingsOuterVbox), debugHbox, TRUE, TRUE, 0);
debugLabel = gtk_label_new (QT_TR_NOOP("Debugging settings (bits): "));
gtk_widget_show (debugLabel);
gtk_box_pack_start (GTK_BOX (debugHbox), debugLabel, FALSE, FALSE, 0);
debugSpinButton_adj = gtk_adjustment_new (0, 0, 16777215, 1, 10, 10);
debugSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (debugSpinButton_adj), 1, 0);
gtk_widget_show (debugSpinButton);
gtk_box_pack_start (GTK_BOX (debugHbox), debugSpinButton, TRUE, TRUE, 0);
previewFrame = gtk_frame_new (NULL);
gtk_widget_show (previewFrame);
gtk_box_pack_start (GTK_BOX (allButButtonsVbox), previewFrame, TRUE, TRUE, 0);
previewAlignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (previewAlignment);
gtk_container_add (GTK_CONTAINER (previewFrame), previewAlignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (previewAlignment), 0, 8, 6, 8);
previewVbox = gtk_vbox_new (FALSE, 5);
gtk_widget_show (previewVbox);
gtk_container_add (GTK_CONTAINER (previewAlignment), previewVbox);
previewControlHbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (previewControlHbox);
gtk_box_pack_start (GTK_BOX (previewVbox), previewControlHbox, TRUE, TRUE, 0);
previewOutputMenu = gtk_combo_box_new_text ();
gtk_widget_show (previewOutputMenu);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewOutputMenu, FALSE, TRUE, 0);
previewSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (previewSlider);
gtk_box_pack_start (GTK_BOX (previewControlHbox), previewSlider, TRUE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (previewSlider), 0);
previewVideo = gtk_drawing_area_new ();
gtk_widget_show (previewVideo);
gtk_box_pack_start (GTK_BOX (previewVbox), previewVideo, TRUE, TRUE, 0);
gtk_widget_set_size_request (previewVideo, 30, 30);
gtk_widget_set_events (previewVideo, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_PRESS_MASK);
previewLabel = gtk_label_new (QT_TR_NOOP("Preview"));
gtk_widget_show (previewLabel);
gtk_frame_set_label_widget (GTK_FRAME (previewFrame), previewLabel);
dialogButtonBox = GTK_DIALOG (threshold_dialog)->action_area;
gtk_widget_show (dialogButtonBox);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogButtonBox), GTK_BUTTONBOX_END);
cancelButton = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), cancelButton, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelButton, GTK_CAN_DEFAULT);
okButton = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okButton);
gtk_dialog_add_action_widget (GTK_DIALOG (threshold_dialog), okButton, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, threshold_dialog, "threshold_dialog");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogVbox, "dialogVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, allButButtonsVbox, "allButButtonsVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterHbox, "settingsOuterHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, settingsOuterVbox, "settingsOuterVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueVbox, "minValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueLabel, "minValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueHbox, "minValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSlider, "minValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, minValueSpinner, "minValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueVbox, "maxValueVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueLabel, "maxValueLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueHbox, "maxValueHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSlider, "maxValueSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, maxValueSpinner, "maxValueSpinner");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesHbox, "outputValuesHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesLabel, "outputValuesLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, outputValuesMenu, "outputValuesMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugHbox, "debugHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugLabel, "debugLabel");
GLADE_HOOKUP_OBJECT (threshold_dialog, debugSpinButton, "debugSpinButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewFrame, "previewFrame");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewAlignment, "previewAlignment");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVbox, "previewVbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewControlHbox, "previewControlHbox");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewOutputMenu, "previewOutputMenu");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewSlider, "previewSlider");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewVideo, "previewVideo");
GLADE_HOOKUP_OBJECT (threshold_dialog, previewLabel, "previewLabel");
GLADE_HOOKUP_OBJECT_NO_REF (threshold_dialog, dialogButtonBox, "dialogButtonBox");
GLADE_HOOKUP_OBJECT (threshold_dialog, cancelButton, "cancelButton");
GLADE_HOOKUP_OBJECT (threshold_dialog, okButton, "okButton");
return threshold_dialog;
}
void CUIHandler::ShowSettingsDlg(void)
{
GtkWidget* settingsDlg;
GtkWidget* dialog_vbox1;
GtkWidget* frame4;
GtkWidget* alignment4;
GtkWidget* vbox2;
GtkWidget* radiobuttonBt;
GtkWidget* hbox2;
GtkWidget* radiobuttonInet;
GtkWidget* label5;
GtkWidget* inetPort;
GtkWidget* label4;
GtkWidget* dialog_action_area1;
CUserSettings crtSettings = pSmartEngine->GetSettings();
settingsDlg = gtk_dialog_new_with_buttons("SmartCam Preferences",
GTK_WINDOW(pSmartEngine->GetMainWindow()),
GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_type_hint(GTK_WINDOW (settingsDlg), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (settingsDlg)->vbox;
gtk_widget_show (dialog_vbox1);
frame4 = gtk_frame_new (NULL);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), frame4, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_IN);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (frame4), alignment4);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 10, 10, 12, 12);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (alignment4), vbox2);
radiobuttonBt = gtk_radio_button_new_with_mnemonic(NULL, "Bluetooth");
gtk_box_pack_start(GTK_BOX (vbox2), radiobuttonBt, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
radiobuttonInet = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radiobuttonBt), "TCP/IP (WiFi)");
gtk_box_pack_start(GTK_BOX (hbox2), radiobuttonInet, FALSE, FALSE, 0);
label5 = gtk_label_new(" Port: ");
gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0);
inetPort = gtk_spin_button_new_with_range(1025, 65536, 1);
gtk_box_pack_start(GTK_BOX(hbox2), inetPort, TRUE, TRUE, 0);
label4 = gtk_label_new("Connection");
gtk_frame_set_label_widget(GTK_FRAME(frame4), label4);
gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
dialog_action_area1 = GTK_DIALOG(settingsDlg)->action_area;
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
g_signal_connect(G_OBJECT(radiobuttonBt), "toggled", G_CALLBACK(OnRadiobuttonBluetooth), inetPort);
if(crtSettings.connectionType == CONN_BLUETOOTH)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), FALSE);
g_object_set(G_OBJECT(inetPort), "sensitive", FALSE, NULL);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), TRUE);
g_object_set(G_OBJECT(inetPort), "sensitive", TRUE, NULL);
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(inetPort), crtSettings.inetPort);
gtk_widget_show_all(settingsDlg);
if(gtk_dialog_run(GTK_DIALOG(settingsDlg)) == GTK_RESPONSE_OK)
{
CUserSettings newSettings = crtSettings;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobuttonBt)))
{
newSettings.connectionType = CONN_BLUETOOTH;
}
else
{
newSettings.connectionType = CONN_INET;
newSettings.inetPort = gtk_spin_button_get_value(GTK_SPIN_BUTTON(inetPort));
}
pSmartEngine->SaveSettings(newSettings);
}
gtk_widget_destroy(settingsDlg);
}
GtkWidget*
create_config (void)
{
GtkWidget *config;
GtkWidget *config_vbox;
GtkWidget *frame1;
GtkWidget *table1;
GtkWidget *label9;
GtkObject *delay_spin_adj;
GtkWidget *delay_spin;
GtkWidget *focus_but;
GtkWidget *timer_but;
GtkWidget *label8;
GtkWidget *frame2;
GtkWidget *table2;
GtkWidget *delete_but;
GtkWidget *new_but;
GtkWidget *scrolledwindow2;
GtkWidget *treeview;
GtkWidget *edit_but;
GtkWidget *label7;
GtkWidget *hbuttonbox1;
GtkWidget *revert_but;
GtkWidget *save_but;
config = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (config), "SmartEar Configuration");
gtk_window_set_destroy_with_parent (GTK_WINDOW (config), TRUE);
config_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (config_vbox);
gtk_container_add (GTK_CONTAINER (config), config_vbox);
gtk_widget_set_size_request (config_vbox, -1, 640);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (config_vbox), frame1, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame1), 5);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (frame1), table1);
gtk_container_set_border_width (GTK_CONTAINER (table1), 5);
gtk_table_set_row_spacings (GTK_TABLE (table1), 10);
gtk_table_set_col_spacings (GTK_TABLE (table1), 10);
label9 = gtk_label_new ("Time delay between playing sounds for a particular buddy:");
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table1), label9, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
delay_spin_adj = gtk_adjustment_new (60, 0, 1000000, 1, 10, 10);
delay_spin = gtk_spin_button_new (GTK_ADJUSTMENT (delay_spin_adj), 1, 0);
gtk_widget_show (delay_spin);
gtk_table_attach (GTK_TABLE (table1), delay_spin, 1, 2, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (delay_spin), GTK_UPDATE_IF_VALID);
focus_but = gtk_check_button_new_with_mnemonic ("Don't play sounds for the conversation that has focus.");
gtk_widget_show (focus_but);
gtk_table_attach (GTK_TABLE (table1), focus_but, 0, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
timer_but = gtk_check_button_new_with_mnemonic ("Also play sounds if you don't respond to a particular IM within a delay period.");
gtk_widget_show (timer_but);
gtk_table_attach (GTK_TABLE (table1), timer_but, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label8 = gtk_label_new ("Options");
gtk_widget_show (label8);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label8);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (config_vbox), frame2, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame2), 5);
table2 = gtk_table_new (2, 3, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame2), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 5);
gtk_table_set_row_spacings (GTK_TABLE (table2), 10);
gtk_table_set_col_spacings (GTK_TABLE (table2), 10);
delete_but = gtk_button_new_from_stock ("gtk-delete");
gtk_widget_show (delete_but);
gtk_table_attach (GTK_TABLE (table2), delete_but, 2, 3, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
GTK_WIDGET_SET_FLAGS (delete_but, GTK_CAN_DEFAULT);
new_but = gtk_button_new_from_stock ("gtk-new");
gtk_widget_show (new_but);
gtk_table_attach (GTK_TABLE (table2), new_but, 0, 1, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
GTK_WIDGET_SET_FLAGS (new_but, GTK_CAN_DEFAULT);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow2);
gtk_table_attach (GTK_TABLE (table2), scrolledwindow2, 0, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
treeview = gtk_tree_view_new ();
gtk_widget_show (treeview);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview);
edit_but = gtk_button_new_from_stock ("gtk-properties");
gtk_widget_show (edit_but);
gtk_table_attach (GTK_TABLE (table2), edit_but, 1, 2, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
label7 = gtk_label_new ("Entries");
gtk_widget_show (label7);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label7);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (config_vbox), hbuttonbox1, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 5);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_SPREAD);
revert_but = gtk_button_new_from_stock ("gtk-revert-to-saved");
gtk_widget_show (revert_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), revert_but);
GTK_WIDGET_SET_FLAGS (revert_but, GTK_CAN_DEFAULT);
save_but = gtk_button_new_from_stock ("gtk-save");
gtk_widget_show (save_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), save_but);
GTK_WIDGET_SET_FLAGS (save_but, GTK_CAN_DEFAULT);
g_signal_connect ((gpointer) config_vbox, "destroy",
G_CALLBACK (on_config_destroy),
NULL);
g_signal_connect ((gpointer) delay_spin, "changed",
G_CALLBACK (on_delay_changed),
NULL);
g_signal_connect ((gpointer) focus_but, "toggled",
G_CALLBACK (on_focus_toggled),
NULL);
g_signal_connect ((gpointer) timer_but, "toggled",
G_CALLBACK (on_timer_toggled),
NULL);
g_signal_connect ((gpointer) delete_but, "clicked",
G_CALLBACK (on_delete_clicked),
NULL);
g_signal_connect ((gpointer) new_but, "clicked",
G_CALLBACK (on_new_clicked),
NULL);
g_signal_connect ((gpointer) edit_but, "clicked",
G_CALLBACK (on_edit_clicked),
NULL);
g_signal_connect ((gpointer) revert_but, "clicked",
G_CALLBACK (on_revert_clicked),
NULL);
g_signal_connect ((gpointer) save_but, "clicked",
G_CALLBACK (on_save_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (config, config, "config");
GLADE_HOOKUP_OBJECT (config, config_vbox, "config_vbox");
GLADE_HOOKUP_OBJECT (config, frame1, "frame1");
GLADE_HOOKUP_OBJECT (config, table1, "table1");
GLADE_HOOKUP_OBJECT (config, label9, "label9");
GLADE_HOOKUP_OBJECT (config, delay_spin, "delay_spin");
GLADE_HOOKUP_OBJECT (config, focus_but, "focus_but");
GLADE_HOOKUP_OBJECT (config, timer_but, "timer_but");
GLADE_HOOKUP_OBJECT (config, label8, "label8");
GLADE_HOOKUP_OBJECT (config, frame2, "frame2");
GLADE_HOOKUP_OBJECT (config, table2, "table2");
GLADE_HOOKUP_OBJECT (config, delete_but, "delete_but");
GLADE_HOOKUP_OBJECT (config, new_but, "new_but");
GLADE_HOOKUP_OBJECT (config, scrolledwindow2, "scrolledwindow2");
GLADE_HOOKUP_OBJECT (config, treeview, "treeview");
GLADE_HOOKUP_OBJECT (config, edit_but, "edit_but");
GLADE_HOOKUP_OBJECT (config, label7, "label7");
GLADE_HOOKUP_OBJECT (config, hbuttonbox1, "hbuttonbox1");
GLADE_HOOKUP_OBJECT (config, revert_but, "revert_but");
GLADE_HOOKUP_OBJECT (config, save_but, "save_but");
return config;
}
GtkWidget*
create_edit_win (void)
{
GtkWidget *edit_win;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label29;
GtkWidget *name_entry;
GtkWidget *label30;
GtkWidget *type_option;
GtkWidget *menu1;
GtkWidget *item_buddy;
GtkWidget *item_group;
GtkWidget *hbuttonbox2;
GtkWidget *applysave_but;
GtkWidget *apply_but;
GtkWidget *cancel_but;
GtkWidget *frame3;
GtkWidget *table5;
GtkWidget *label31;
GtkWidget *label34;
GtkWidget *label33;
GtkWidget *label32;
GtkWidget *unaway_sound_entry;
GtkWidget *unidle_sound_entry;
GtkWidget *signon_sound_entry;
GtkWidget *unaway_test_but;
GtkWidget *unidle_test_but;
GtkWidget *signon_test_but;
GtkWidget *unaway_browse_but;
GtkWidget *unidle_browse_but;
GtkWidget *signon_browse_but;
GtkWidget *im_browse_but;
GtkWidget *im_sound_entry;
GtkWidget *im_test_but;
GtkWidget *label24;
edit_win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (edit_win, 600, 300);
gtk_window_set_title (GTK_WINDOW (edit_win), "Edit Entry");
gtk_window_set_default_size (GTK_WINDOW (edit_win), 600, 300);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (edit_win), vbox1);
hbox1 = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, TRUE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
label29 = gtk_label_new ("Name:");
gtk_widget_show (label29);
gtk_box_pack_start (GTK_BOX (hbox1), label29, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label29), 1, 0.5);
name_entry = gtk_entry_new ();
gtk_widget_show (name_entry);
gtk_box_pack_start (GTK_BOX (hbox1), name_entry, TRUE, TRUE, 0);
label30 = gtk_label_new ("Type:");
gtk_widget_show (label30);
gtk_box_pack_start (GTK_BOX (hbox1), label30, FALSE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label30), 1, 0.5);
type_option = gtk_option_menu_new ();
gtk_widget_show (type_option);
gtk_box_pack_start (GTK_BOX (hbox1), type_option, FALSE, FALSE, 0);
menu1 = gtk_menu_new ();
item_buddy = gtk_menu_item_new_with_mnemonic ("Buddy");
gtk_widget_show (item_buddy);
gtk_container_add (GTK_CONTAINER (menu1), item_buddy);
item_group = gtk_menu_item_new_with_mnemonic ("Group");
gtk_widget_show (item_group);
gtk_container_add (GTK_CONTAINER (menu1), item_group);
gtk_option_menu_set_menu (GTK_OPTION_MENU (type_option), menu1);
hbuttonbox2 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox2);
gtk_box_pack_end (GTK_BOX (vbox1), hbuttonbox2, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox2), 5);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_SPREAD);
applysave_but = gtk_button_new_with_mnemonic ("Apply and Save");
gtk_widget_show (applysave_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox2), applysave_but);
GTK_WIDGET_SET_FLAGS (applysave_but, GTK_CAN_DEFAULT);
apply_but = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (apply_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox2), apply_but);
GTK_WIDGET_SET_FLAGS (apply_but, GTK_CAN_DEFAULT);
cancel_but = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancel_but);
gtk_container_add (GTK_CONTAINER (hbuttonbox2), cancel_but);
GTK_WIDGET_SET_FLAGS (cancel_but, GTK_CAN_DEFAULT);
frame3 = gtk_frame_new (NULL);
gtk_widget_show (frame3);
gtk_box_pack_start (GTK_BOX (vbox1), frame3, FALSE, FALSE, 0);
gtk_widget_set_size_request (frame3, -1, 200);
gtk_container_set_border_width (GTK_CONTAINER (frame3), 5);
table5 = gtk_table_new (4, 5, FALSE);
gtk_widget_show (table5);
gtk_container_add (GTK_CONTAINER (frame3), table5);
gtk_widget_set_size_request (table5, 600, 400);
gtk_container_set_border_width (GTK_CONTAINER (table5), 5);
gtk_table_set_row_spacings (GTK_TABLE (table5), 10);
gtk_table_set_col_spacings (GTK_TABLE (table5), 10);
label31 = gtk_label_new ("Play On IM:");
gtk_widget_show (label31);
gtk_table_attach (GTK_TABLE (table5), label31, 0, 1, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label31), 0, 0.5);
label34 = gtk_label_new ("Play On Unaway:");
gtk_widget_show (label34);
gtk_table_attach (GTK_TABLE (table5), label34, 0, 1, 3, 4,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5);
label33 = gtk_label_new ("Play On Unidle:");
gtk_widget_show (label33);
gtk_table_attach (GTK_TABLE (table5), label33, 0, 1, 2, 3,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label33), 0, 0.5);
label32 = gtk_label_new ("Play On Signon:");
gtk_widget_show (label32);
gtk_table_attach (GTK_TABLE (table5), label32, 0, 1, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label32), 0, 0.5);
unaway_sound_entry = gtk_entry_new ();
gtk_widget_show (unaway_sound_entry);
gtk_table_attach (GTK_TABLE (table5), unaway_sound_entry, 1, 3, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
unidle_sound_entry = gtk_entry_new ();
gtk_widget_show (unidle_sound_entry);
gtk_table_attach (GTK_TABLE (table5), unidle_sound_entry, 1, 3, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
signon_sound_entry = gtk_entry_new ();
gtk_widget_show (signon_sound_entry);
gtk_table_attach (GTK_TABLE (table5), signon_sound_entry, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
unaway_test_but = gtk_button_new_with_mnemonic ("Test");
gtk_widget_show (unaway_test_but);
gtk_table_attach (GTK_TABLE (table5), unaway_test_but, 4, 5, 3, 4,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
unidle_test_but = gtk_button_new_with_mnemonic ("Test");
gtk_widget_show (unidle_test_but);
gtk_table_attach (GTK_TABLE (table5), unidle_test_but, 4, 5, 2, 3,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
signon_test_but = gtk_button_new_with_mnemonic ("Test");
gtk_widget_show (signon_test_but);
gtk_table_attach (GTK_TABLE (table5), signon_test_but, 4, 5, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
unaway_browse_but = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (unaway_browse_but);
gtk_table_attach (GTK_TABLE (table5), unaway_browse_but, 3, 4, 3, 4,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
unidle_browse_but = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (unidle_browse_but);
gtk_table_attach (GTK_TABLE (table5), unidle_browse_but, 3, 4, 2, 3,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
signon_browse_but = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (signon_browse_but);
gtk_table_attach (GTK_TABLE (table5), signon_browse_but, 3, 4, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
im_browse_but = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (im_browse_but);
gtk_table_attach (GTK_TABLE (table5), im_browse_but, 3, 4, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
im_sound_entry = gtk_entry_new ();
gtk_widget_show (im_sound_entry);
gtk_table_attach (GTK_TABLE (table5), im_sound_entry, 1, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
im_test_but = gtk_button_new_with_mnemonic ("Test");
gtk_widget_show (im_test_but);
gtk_table_attach (GTK_TABLE (table5), im_test_but, 4, 5, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
label24 = gtk_label_new ("Sound Events");
gtk_widget_show (label24);
gtk_frame_set_label_widget (GTK_FRAME (frame3), label24);
g_signal_connect ((gpointer) edit_win, "destroy",
G_CALLBACK (on_edit_win_destroy),
NULL);
g_signal_connect ((gpointer) applysave_but, "clicked",
G_CALLBACK (on_apply_clicked),
NULL);
g_signal_connect ((gpointer) applysave_but, "clicked",
G_CALLBACK (on_save_clicked),
NULL);
g_signal_connect_swapped ((gpointer) applysave_but, "clicked",
G_CALLBACK (gtk_widget_destroy),
GTK_OBJECT (edit_win));
g_signal_connect ((gpointer) apply_but, "clicked",
G_CALLBACK (on_apply_clicked),
NULL);
g_signal_connect_swapped ((gpointer) apply_but, "clicked",
G_CALLBACK (gtk_widget_destroy),
GTK_OBJECT (edit_win));
g_signal_connect_swapped ((gpointer) cancel_but, "clicked",
G_CALLBACK (gtk_widget_destroy),
GTK_OBJECT (edit_win));
g_signal_connect ((gpointer) unaway_test_but, "clicked",
G_CALLBACK (on_unaway_test_clicked),
NULL);
g_signal_connect ((gpointer) unidle_test_but, "clicked",
G_CALLBACK (on_unidle_test_clicked),
NULL);
g_signal_connect ((gpointer) signon_test_but, "clicked",
G_CALLBACK (on_signon_test_clicked),
NULL);
g_signal_connect ((gpointer) unaway_browse_but, "clicked",
G_CALLBACK (on_unaway_browse_clicked),
NULL);
g_signal_connect ((gpointer) unidle_browse_but, "clicked",
G_CALLBACK (on_unidle_browse_clicked),
NULL);
g_signal_connect ((gpointer) signon_browse_but, "clicked",
G_CALLBACK (on_signon_browse_clicked),
NULL);
g_signal_connect ((gpointer) im_browse_but, "clicked",
G_CALLBACK (on_im_browse_clicked),
NULL);
g_signal_connect ((gpointer) im_test_but, "clicked",
G_CALLBACK (on_im_test_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (edit_win, edit_win, "edit_win");
GLADE_HOOKUP_OBJECT (edit_win, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (edit_win, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (edit_win, label29, "label29");
GLADE_HOOKUP_OBJECT (edit_win, name_entry, "name_entry");
GLADE_HOOKUP_OBJECT (edit_win, label30, "label30");
GLADE_HOOKUP_OBJECT (edit_win, type_option, "type_option");
GLADE_HOOKUP_OBJECT (edit_win, menu1, "menu1");
GLADE_HOOKUP_OBJECT (edit_win, item_buddy, "item_buddy");
GLADE_HOOKUP_OBJECT (edit_win, item_group, "item_group");
GLADE_HOOKUP_OBJECT (edit_win, hbuttonbox2, "hbuttonbox2");
GLADE_HOOKUP_OBJECT (edit_win, applysave_but, "applysave_but");
GLADE_HOOKUP_OBJECT (edit_win, apply_but, "apply_but");
GLADE_HOOKUP_OBJECT (edit_win, cancel_but, "cancel_but");
GLADE_HOOKUP_OBJECT (edit_win, frame3, "frame3");
GLADE_HOOKUP_OBJECT (edit_win, table5, "table5");
GLADE_HOOKUP_OBJECT (edit_win, label31, "label31");
GLADE_HOOKUP_OBJECT (edit_win, label34, "label34");
GLADE_HOOKUP_OBJECT (edit_win, label33, "label33");
GLADE_HOOKUP_OBJECT (edit_win, label32, "label32");
GLADE_HOOKUP_OBJECT (edit_win, unaway_sound_entry, "unaway_sound_entry");
GLADE_HOOKUP_OBJECT (edit_win, unidle_sound_entry, "unidle_sound_entry");
GLADE_HOOKUP_OBJECT (edit_win, signon_sound_entry, "signon_sound_entry");
GLADE_HOOKUP_OBJECT (edit_win, unaway_test_but, "unaway_test_but");
GLADE_HOOKUP_OBJECT (edit_win, unidle_test_but, "unidle_test_but");
GLADE_HOOKUP_OBJECT (edit_win, signon_test_but, "signon_test_but");
GLADE_HOOKUP_OBJECT (edit_win, unaway_browse_but, "unaway_browse_but");
GLADE_HOOKUP_OBJECT (edit_win, unidle_browse_but, "unidle_browse_but");
GLADE_HOOKUP_OBJECT (edit_win, signon_browse_but, "signon_browse_but");
GLADE_HOOKUP_OBJECT (edit_win, im_browse_but, "im_browse_but");
GLADE_HOOKUP_OBJECT (edit_win, im_sound_entry, "im_sound_entry");
GLADE_HOOKUP_OBJECT (edit_win, im_test_but, "im_test_but");
GLADE_HOOKUP_OBJECT (edit_win, label24, "label24");
return edit_win;
}
static void
bt_main_page_info_init_ui (const BtMainPageInfo * self,
const BtMainPages * pages)
{
GtkWidget *label, *frame, *box;
GtkWidget *table;
GtkWidget *scrolledwindow;
GtkAdjustment *spin_adjustment;
GParamSpecULong *pspec, *pspec2;
GObjectClass *song_info_class;
gulong def, min, max;
GST_DEBUG ("!!!! self=%p", self);
gtk_widget_set_name (GTK_WIDGET (self), "song information");
song_info_class = g_type_class_ref (BT_TYPE_SONG_INFO);
// first row of vbox
frame = gtk_frame_new (NULL);
label = make_heading (_("song meta data"));
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), BOX_BORDER);
gtk_widget_set_name (frame, "song meta data");
gtk_box_pack_start (GTK_BOX (self), frame, FALSE, TRUE, 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, BOX_BORDER);
gtk_container_add (GTK_CONTAINER (frame), box);
/* left side padding */
gtk_box_pack_start (GTK_BOX (box), gtk_label_new (" "), FALSE, TRUE, 0);
// first column
table = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (box), table, TRUE, TRUE, 0);
label = gtk_label_new (_("name"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
self->priv->name = GTK_ENTRY (gtk_entry_new ());
g_object_set (self->priv->name, "hexpand", TRUE, "margin-left", LABEL_PADDING,
NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->name), 1, 0, 1, 1);
g_signal_connect (self->priv->name, "changed", G_CALLBACK (on_name_changed),
(gpointer) self);
label = gtk_label_new (_("genre"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 1, 1, 1);
self->priv->genre = GTK_ENTRY (gtk_entry_new ());
g_object_set (self->priv->genre, "hexpand", TRUE, "margin-left",
LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->genre), 1, 1, 1,
1);
g_signal_connect (self->priv->genre, "changed", G_CALLBACK (on_genre_changed),
(gpointer) self);
label = gtk_label_new (_("author"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 2, 1, 1);
self->priv->author = GTK_ENTRY (gtk_entry_new ());
g_object_set (self->priv->author, "hexpand", TRUE, "margin-left",
LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->author), 1, 2, 1,
1);
g_signal_connect (self->priv->author, "changed",
G_CALLBACK (on_author_changed), (gpointer) self);
label = gtk_label_new (_("created"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 3, 1, 1);
self->priv->date_created = GTK_ENTRY (gtk_entry_new ());
gtk_editable_set_editable (GTK_EDITABLE (self->priv->date_created), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (self->priv->date_created), FALSE);
g_object_set (self->priv->date_created, "hexpand", TRUE, "margin-left",
LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->date_created), 1,
3, 1, 1);
// second column
table = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (box), table, TRUE, TRUE, 0);
label = gtk_label_new (_("beats per minute"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);
pspec =
(GParamSpecULong *) g_object_class_find_property (song_info_class, "bpm");
spin_adjustment = gtk_adjustment_new (pspec->default_value, pspec->minimum,
pspec->maximum, 1.0, 5.0, 0.0);
self->priv->bpm =
GTK_SPIN_BUTTON (gtk_spin_button_new (spin_adjustment, 1.0, 0));
g_object_set (self->priv->bpm, "margin-left", LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->bpm), 1, 0, 1, 1);
g_signal_connect (self->priv->bpm, "value-changed",
G_CALLBACK (on_bpm_changed), (gpointer) self);
label = gtk_label_new (_("beats"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 1, 1, 1);
pspec =
(GParamSpecULong *) g_object_class_find_property (song_info_class, "tpb");
pspec2 =
(GParamSpecULong *) g_object_class_find_property (song_info_class,
"bars");
def = pspec2->default_value / pspec->default_value;
min = pspec2->minimum / pspec->maximum;
max = pspec2->maximum / pspec->minimum;
if (min < 1)
min = 1;
spin_adjustment = gtk_adjustment_new (def, min, max, 1.0, 4.0, 0.0);
self->priv->beats =
GTK_SPIN_BUTTON (gtk_spin_button_new (spin_adjustment, 1.0, 0));
g_object_set (self->priv->beats, "margin-left", LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->beats), 1, 1, 1,
1);
g_signal_connect (self->priv->beats, "value-changed",
G_CALLBACK (on_beats_changed), (gpointer) self);
label = gtk_label_new (_("ticks per beat"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 2, 1, 1);
spin_adjustment = gtk_adjustment_new (pspec->default_value, pspec->minimum,
pspec->maximum, 1.0, 4.0, 0.0);
self->priv->tpb =
GTK_SPIN_BUTTON (gtk_spin_button_new (spin_adjustment, 1.0, 0));
g_object_set (self->priv->tpb, "margin-left", LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->tpb), 1, 2, 1, 1);
g_signal_connect (self->priv->tpb, "value-changed",
G_CALLBACK (on_tpb_changed), (gpointer) self);
label = gtk_label_new (_("last saved"));
g_object_set (label, "xalign", 1.0, NULL);
gtk_grid_attach (GTK_GRID (table), label, 0, 3, 1, 1);
self->priv->date_changed = GTK_ENTRY (gtk_entry_new ());
gtk_editable_set_editable (GTK_EDITABLE (self->priv->date_changed), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (self->priv->date_changed), FALSE);
g_object_set (self->priv->date_changed, "hexpand", TRUE, "margin-left",
LABEL_PADDING, NULL);
gtk_grid_attach (GTK_GRID (table), GTK_WIDGET (self->priv->date_changed), 1,
3, 1, 1);
// @idea show tick and subtick interval as time (s:ms)
// second row of hbox
frame = gtk_frame_new (NULL);
label = make_heading (_("free text info"));
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), BOX_BORDER);
gtk_box_pack_start (GTK_BOX (self), frame, TRUE, TRUE, 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, BOX_BORDER);
gtk_container_add (GTK_CONTAINER (frame), box);
/* left side padding */
gtk_box_pack_start (GTK_BOX (box), gtk_label_new (" "), FALSE, TRUE, 0);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (box), scrolledwindow, TRUE, TRUE, 0);
self->priv->info = GTK_TEXT_VIEW (gtk_text_view_new ());
gtk_widget_set_name (GTK_WIDGET (self->priv->info), "free text info");
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (self->priv->info), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolledwindow),
GTK_WIDGET (self->priv->info));
g_signal_connect (gtk_text_view_get_buffer (self->priv->info), "changed",
G_CALLBACK (on_info_changed), (gpointer) self);
// register event handlers
g_signal_connect_object (self->priv->app, "notify::song",
G_CALLBACK (on_song_changed), (gpointer) self, 0);
// listen to page changes
g_signal_connect ((gpointer) pages, "notify::page",
G_CALLBACK (on_page_switched), (gpointer) self);
g_signal_connect ((gpointer) self, "map",
G_CALLBACK (on_page_mapped), (gpointer) self);
GST_DEBUG (" done");
}
GtkWidget*
create_ChromaShift (void)
{
GtkWidget *ChromaShift;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkObject *spinbutton_U_adj;
GtkWidget *spinbutton_U;
GtkObject *spinbutton_V_adj;
GtkWidget *spinbutton_V;
GtkWidget *hscale;
GtkWidget *frame1;
GtkWidget *alignment1;
GtkWidget *drawingarea1;
GtkWidget *label3;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *applybutton1;
GtkWidget *okbutton1;
ChromaShift = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (ChromaShift), QT_TR_NOOP("ChromaShift"));
gtk_window_set_type_hint (GTK_WINDOW (ChromaShift), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (ChromaShift)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP("U Shift :"));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (QT_TR_NOOP("V Shift :"));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
spinbutton_U_adj = gtk_adjustment_new (0, -32, 32, 1, 10, 0);
spinbutton_U = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_U_adj), 1, 0);
gtk_widget_show (spinbutton_U);
gtk_table_attach (GTK_TABLE (table1), spinbutton_U, 1, 2, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_U), TRUE);
spinbutton_V_adj = gtk_adjustment_new (0, -32, 32, 1, 10, 0);
spinbutton_V = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_V_adj), 1, 0);
gtk_widget_show (spinbutton_V);
gtk_table_attach (GTK_TABLE (table1), spinbutton_V, 1, 2, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_V), TRUE);
hscale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale);
gtk_box_pack_start (GTK_BOX (vbox1), hscale, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale), 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (frame1), alignment1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 12, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_container_add (GTK_CONTAINER (alignment1), drawingarea1);
label3 = gtk_label_new (QT_TR_NOOP("<b>Preview</b>"));
gtk_widget_show (label3);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label3);
gtk_label_set_use_markup (GTK_LABEL (label3), TRUE);
dialog_action_area1 = GTK_DIALOG (ChromaShift)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (ChromaShift), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
applybutton1 = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (applybutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (ChromaShift), applybutton1, GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS (applybutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (ChromaShift), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (ChromaShift, ChromaShift, "ChromaShift");
GLADE_HOOKUP_OBJECT_NO_REF (ChromaShift, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (ChromaShift, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (ChromaShift, table1, "table1");
GLADE_HOOKUP_OBJECT (ChromaShift, label1, "label1");
GLADE_HOOKUP_OBJECT (ChromaShift, label2, "label2");
GLADE_HOOKUP_OBJECT (ChromaShift, spinbutton_U, "spinbutton_U");
GLADE_HOOKUP_OBJECT (ChromaShift, spinbutton_V, "spinbutton_V");
GLADE_HOOKUP_OBJECT (ChromaShift, hscale, "hscale");
GLADE_HOOKUP_OBJECT (ChromaShift, frame1, "frame1");
GLADE_HOOKUP_OBJECT (ChromaShift, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (ChromaShift, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT (ChromaShift, label3, "label3");
GLADE_HOOKUP_OBJECT_NO_REF (ChromaShift, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (ChromaShift, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (ChromaShift, applybutton1, "applybutton1");
GLADE_HOOKUP_OBJECT (ChromaShift, okbutton1, "okbutton1");
return ChromaShift;
}
static void lcrt_serial_show(struct lcrt_qconnect *lqconnect)
{
GtkWidget *vbox;
GtkWidget *vbox_spec;
GtkWidget *hbox1;
GtkWidget *label_port;
GtkWidget *combobox_port;
GtkWidget *label_baud_rate;
GtkWidget *combobox_baud_rate;
GtkWidget *label_data_bits;
GtkWidget *combobox_data_bits;
GtkWidget *label_parity;
GtkWidget *combobox_parity;
GtkWidget *label_stop_bits;
GtkWidget *combobox_stop_bits;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *hbox_frame;
GtkWidget *checkbutton_software;
GtkWidget *checkbutton_hardware;
GtkWidget *label_flow_control;
int i;
const char *sport[LCRT_SERIAL_PORT_NUMBER] = {LCRT_SERIAL_PORT};
const struct lcrt_serial_map sbaud_rate[LCRT_SERIAL_BAUD_RATE_NUMBER] = {LCRT_SERIAL_BAUD_RATE_TABLE};
const struct lcrt_serial_map sdata_bits[LCRT_SERIAL_DATA_BITS_NUMBER] = {LCRT_SERIAL_DATA_BITS_TABLE};
const struct lcrt_serial_map sparity[LCRT_SERIAL_PARITY_NUMBER] = {LCRT_SERIAL_PARITY_TABLE};
const struct lcrt_serial_map sstop_bits[LCRT_SERIAL_STOP_BITS_NUMBER] = {LCRT_SERIAL_STOP_BITS_TABLE};
const struct lcrt_serial_map flow_control[LCRT_SEROAL_FLOW_CONTROL_NUMBER] = {LCRT_SEROAL_FLOW_CONTROL_TABLE};
static struct lcrt_serial_if slserial, *lserial = &slserial;
struct lcrtc_user *user = NULL;
char s_port[USERNAME_LEN];
boolean f_option = FALSE;
int s_baud_rate,s_databit,s_parity,s_stopbit,s_software,s_hardware;
if (lqconnect->flag == LCRT_QCONNECT_SESSION_OPTION &&
(user = lcrt_user_find_by_name(&lqconnect->parent->u_config, lqconnect->uname)) != NULL) {
sscanf(user->password, "%s %d %d %d %d %d %d",
s_port,
&s_baud_rate,
&s_databit,
&s_parity,
&s_stopbit,
&s_software,
&s_hardware);
debug_print("SERIAL PORT: %s %d %d %d %d %d %d\n",
s_port,
s_baud_rate,
s_databit,
s_parity,
s_stopbit,
s_software,
s_hardware);
f_option = TRUE;
}
memset(lserial, 0, sizeof(struct lcrt_serial_if));
lqconnect->private_data = lserial;
vbox = GTK_DIALOG (lqconnect->q_connect)->vbox;
debug_where();
vbox_spec = gtk_vbox_new (FALSE, 0);
lqconnect->q_vbox_spec = vbox_spec;
gtk_widget_show (vbox_spec);
gtk_box_pack_start (GTK_BOX (vbox), vbox_spec, TRUE, TRUE, 0);
gtk_box_reorder_child (GTK_BOX (vbox), vbox_spec, 1);
gtk_widget_set_size_request (vbox_spec, -1, 210);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0);
gtk_widget_set_size_request (hbox1, -1, 25);
label_port = gtk_label_new (lqconnect->config.value[LCRT_Q_SPORT]);
gtk_widget_show (label_port);
gtk_box_pack_start (GTK_BOX (hbox1), label_port, FALSE, FALSE, 0);
gtk_widget_set_size_request (label_port, 90, 25);
gtk_misc_set_alignment (GTK_MISC (label_port), 0, 0.5);
combobox_port = gtk_combo_box_entry_new_text ();
lserial->port = combobox_port;
gtk_widget_show (combobox_port);
gtk_box_pack_start (GTK_BOX (hbox1), combobox_port, FALSE, TRUE, 0);
gtk_widget_set_size_request (combobox_port, SERIAL_COMBOBOX_WIDTH, 25);
for (i = 0; i < LCRT_SERIAL_PORT_NUMBER; i++) {
gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_port), sport[i]);
if (f_option && strcmp(s_port, sport[i]) == 0)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_port), i);
}
debug_where();
//gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_port)->child), FALSE);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0);
gtk_widget_set_size_request (hbox1, -1, 25);
label_baud_rate = gtk_label_new (lqconnect->config.value[LCRT_Q_SBAUD_RATE]);
gtk_widget_show (label_baud_rate);
gtk_box_pack_start (GTK_BOX (hbox1), label_baud_rate, FALSE, FALSE, 0);
gtk_widget_set_size_request (label_baud_rate, 90, 25);
gtk_misc_set_alignment (GTK_MISC (label_baud_rate), 0, 0.5);
combobox_baud_rate = gtk_combo_box_entry_new_text ();
lserial->baud_rate = combobox_baud_rate;
gtk_widget_show (combobox_baud_rate);
gtk_box_pack_start (GTK_BOX (hbox1), combobox_baud_rate, FALSE, TRUE, 0);
gtk_widget_set_size_request (combobox_baud_rate, SERIAL_COMBOBOX_WIDTH, 25);
for (i = 0; i < LCRT_SERIAL_BAUD_RATE_NUMBER; i++) {
gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_baud_rate), sbaud_rate[i].name);
if (f_option && s_baud_rate == sbaud_rate[i].data)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_baud_rate), i);
}
debug_where();
gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_baud_rate)->child), FALSE);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0);
gtk_widget_set_size_request (hbox1, -1, 25);
label_data_bits = gtk_label_new (lqconnect->config.value[LCRT_Q_SDATA_BITS]);
gtk_widget_show (label_data_bits);
gtk_box_pack_start (GTK_BOX (hbox1), label_data_bits, FALSE, FALSE, 0);
gtk_widget_set_size_request (label_data_bits, 90, 25);
gtk_misc_set_alignment (GTK_MISC (label_data_bits), 0, 0.5);
combobox_data_bits = gtk_combo_box_entry_new_text ();
lserial->data_bits = combobox_data_bits;
gtk_widget_show (combobox_data_bits);
gtk_box_pack_start (GTK_BOX (hbox1), combobox_data_bits, FALSE, TRUE, 0);
gtk_widget_set_size_request (combobox_data_bits, SERIAL_COMBOBOX_WIDTH, 25);
for (i = 0; i < LCRT_SERIAL_DATA_BITS_NUMBER; i++) {
gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_data_bits), sdata_bits[i].name);
if (f_option && s_databit == sdata_bits[i].data)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_data_bits), i);
}
debug_where();
gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_data_bits)->child), FALSE);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0);
gtk_widget_set_size_request (hbox1, -1, 25);
label_parity = gtk_label_new (lqconnect->config.value[LCRT_Q_SPARITY]);
gtk_widget_show (label_parity);
gtk_box_pack_start (GTK_BOX (hbox1), label_parity, FALSE, FALSE, 0);
gtk_widget_set_size_request (label_parity, 90, 25);
gtk_misc_set_alignment (GTK_MISC (label_parity), 0, 0.5);
combobox_parity = gtk_combo_box_entry_new_text ();
lserial->parity = combobox_parity;
gtk_widget_show (combobox_parity);
gtk_box_pack_start (GTK_BOX (hbox1), combobox_parity, FALSE, TRUE, 0);
gtk_widget_set_size_request (combobox_parity, SERIAL_COMBOBOX_WIDTH, 25);
for (i = 0; i < LCRT_SERIAL_PARITY_NUMBER; i++) {
gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_parity), sparity[i].name);
}
if (f_option)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_parity), s_parity);
debug_where();
gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_parity)->child), FALSE);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0);
gtk_widget_set_size_request (hbox1, -1, 25);
label_stop_bits = gtk_label_new (lqconnect->config.value[LCRT_Q_SSTOP_BITS]);
gtk_widget_show (label_stop_bits);
gtk_box_pack_start (GTK_BOX (hbox1), label_stop_bits, FALSE, FALSE, 0);
gtk_widget_set_size_request (label_stop_bits, 90, 25);
gtk_misc_set_alignment (GTK_MISC (label_stop_bits), 0, 0.5);
combobox_stop_bits = gtk_combo_box_entry_new_text ();
lserial->stop_bits = combobox_stop_bits;
gtk_widget_show (combobox_stop_bits);
gtk_box_pack_start (GTK_BOX (hbox1), combobox_stop_bits, FALSE, TRUE, 0);
gtk_widget_set_size_request (combobox_stop_bits, SERIAL_COMBOBOX_WIDTH, 25);
for (i = 0; i < LCRT_SERIAL_STOP_BITS_NUMBER; i++) {
gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_stop_bits), sstop_bits[i].name);
}
if (f_option)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_stop_bits), s_stopbit);
debug_where();
gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_stop_bits)->child), FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_widget_set_size_request (frame, -1, 40);
gtk_box_pack_start (GTK_BOX (vbox_spec), frame, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
hbox_frame = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox_frame);
gtk_container_add (GTK_CONTAINER (alignment), hbox_frame);
checkbutton_software = gtk_check_button_new_with_mnemonic (flow_control[0].name);
lserial->software = checkbutton_software;
gtk_widget_show (checkbutton_software);
gtk_box_pack_start (GTK_BOX (hbox_frame), checkbutton_software, FALSE, FALSE, 0);
gtk_widget_set_size_request (checkbutton_software, 150, -1);
if (f_option)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_software), s_software);
checkbutton_hardware = gtk_check_button_new_with_mnemonic (flow_control[1].name);
lserial->hardware = checkbutton_hardware;
gtk_widget_show (checkbutton_hardware);
gtk_box_pack_start (GTK_BOX (hbox_frame), checkbutton_hardware, FALSE, FALSE, 0);
gtk_widget_set_size_request (checkbutton_hardware, 150, -1);
if (f_option)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_hardware), s_hardware);
label_flow_control = gtk_label_new (lqconnect->config.value[LCRT_Q_SFLOW_CONTROL]);
gtk_widget_show (label_flow_control);
gtk_frame_set_label_widget (GTK_FRAME (frame), label_flow_control);
gtk_label_set_use_markup (GTK_LABEL (label_flow_control), TRUE);
if (!f_option) {
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_port), 1); //ttyS0
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_baud_rate), 10); //115200
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_data_bits), 3); //8
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_parity), 0); //None
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_stop_bits), 0); //1
debug_print("active = %d\n", gtk_combo_box_get_active(GTK_COMBO_BOX(combobox_baud_rate)));
}
gtk_widget_set_sensitive(lqconnect->q_bt_connect, TRUE);
}
