void get_folder_to_play(GtkWidget *widget, gpointer user_data) {
/** User folder selection. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *folder_chooser_dialog = gtk_file_chooser_dialog_new("Choose a folder contains music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog), current_folder.c_str() ) ;
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
gtk_window_set_position(GTK_WINDOW(folder_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_widget_set_size_request(folder_chooser_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(folder_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
gtk_window_set_transient_for(GTK_WINDOW(folder_chooser_dialog), GTK_WINDOW(gui->window)) ;
gchar *folderpath = NULL ; // Selected folder.
gint result = gtk_dialog_run (GTK_DIALOG (folder_chooser_dialog));
switch (result) {
case GTK_RESPONSE_CANCEL :
if (! is_playing) {
gtk_button_set_label(GTK_BUTTON(gui->folder_chooser_button), "Select a folder to play content") ;
}
gtk_widget_destroy(folder_chooser_dialog);
return ;
case GTK_RESPONSE_ACCEPT :
folderpath = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog));
gtk_widget_destroy(folder_chooser_dialog);
break ;
}
parse_folder(folderpath) ;
gchar *dirname = g_path_get_dirname(folderpath) ;
current_folder = dirname ;
g_free(dirname) ;
#ifdef DEBUG
fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
#endif
g_free(folderpath) ;
}
static void
setup_widgets (WirelessApplet *applet)
{
GtkRequisition req;
gint total_size = 0;
gboolean horizontal = FALSE;
gint panel_size;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *viewport;
panel_size = panel_applet_get_size (PANEL_APPLET (applet));
switch (panel_applet_get_orient(PANEL_APPLET (applet))) {
case PANEL_APPLET_ORIENT_LEFT:
case PANEL_APPLET_ORIENT_RIGHT:
horizontal = FALSE;
break;
case PANEL_APPLET_ORIENT_UP:
case PANEL_APPLET_ORIENT_DOWN:
horizontal = TRUE;
break;
}
/* construct pixmap widget */
applet->pixmap = gtk_image_new ();
gtk_image_set_from_pixbuf (GTK_IMAGE (applet->pixmap), applet->pixmaps[PIX_BROKEN]);
gtk_widget_size_request (applet->pixmap, &req);
gtk_widget_show (applet->pixmap);
if (horizontal)
total_size += req.height;
else
total_size += req.width;
/* construct pct widget */
applet->pct_label = gtk_label_new ("N/A");
if (applet->show_percent == TRUE) {
gtk_widget_show (applet->pct_label);
gtk_widget_size_request (applet->pct_label, &req);
if (horizontal)
total_size += req.height;
else
total_size += req.width;
}
/* construct ap popup window */
applet->ap_popup = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW (applet->ap_popup),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_set_resizable (GTK_WINDOW (applet->ap_popup),
FALSE);
gtk_window_stick (GTK_WINDOW (applet->ap_popup));
gtk_window_set_default_size (GTK_WINDOW (applet->ap_popup),
0, 0);
gtk_window_set_decorated (GTK_WINDOW (applet->ap_popup), FALSE);
applet->ap_store = gtk_list_store_new (1, wireless_ap_get_type());
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (applet->ap_store),
0,
ap_compare_func,
applet,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (applet->ap_store),
0, GTK_SORT_DESCENDING);
applet->ap_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (applet->ap_store));
g_signal_connect (applet->ap_view, "row_activated",
G_CALLBACK (wireless_applet_row_activate_cb),
applet);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (applet->ap_view),
FALSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (applet->ap_view),
FALSE);
/* the quality column */
renderer = GTK_CELL_RENDERER (ephy_cell_renderer_progress_new ());
column = gtk_tree_view_column_new_with_attributes ("Quality",
renderer,
NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
ap_quality_cell_data_cb,
applet, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (applet->ap_view),
column);
viewport = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport),
GTK_SHADOW_ETCHED_IN);
gtk_container_add (GTK_CONTAINER (viewport), applet->ap_view);
gtk_container_add (GTK_CONTAINER(applet->ap_popup), viewport);
gtk_widget_show_all (viewport);
/* the essid column */
renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
column = gtk_tree_view_column_new_with_attributes ("ESSID",
renderer,
NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
ap_essid_cell_data_cb,
applet, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (applet->ap_view),
column);
/* encryption column */
renderer = GTK_CELL_RENDERER (gtk_cell_renderer_pixbuf_new ());
column = gtk_tree_view_column_new_with_attributes ("Encryption",
renderer,
NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
ap_encryption_cell_data_cb,
applet, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (applet->ap_view),
column);
/* pack */
if (applet->button)
gtk_widget_destroy (applet->button);
if (horizontal && (total_size <= panel_size))
applet->box = gtk_vbox_new (FALSE, 0);
else if (horizontal && (total_size > panel_size))
applet->box = gtk_hbox_new (FALSE, 0);
else if (!horizontal && (total_size <= panel_size))
applet->box = gtk_hbox_new (FALSE, 0);
else
applet->box = gtk_vbox_new (FALSE, 0);
applet->button = gtk_toggle_button_new ();
g_signal_connect(applet->button, "toggled",
G_CALLBACK(applet_button_toggled), applet);
gtk_button_set_relief (GTK_BUTTON (applet->button), GTK_RELIEF_NONE);
gtk_container_add (GTK_CONTAINER(applet->button), applet->box);
gtk_box_pack_start (GTK_BOX (applet->box), applet->pixmap, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (applet->box), applet->pct_label, TRUE, TRUE, 0);
/* note, I don't use show_all, because this way the percent label is
* only realised if it's enabled */
gtk_widget_show (applet->button);
gtk_widget_show (applet->box);
gtk_container_add (GTK_CONTAINER (applet), applet->button);
applet->current_pixbuf = NULL;
applet->about_dialog = NULL;
}
static void
gtk_shortcuts_window_init (GtkShortcutsWindow *self)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
GtkToggleButton *search_button;
GtkBox *menu_box;
GtkBox *box;
GtkArrow *arrow;
GtkWidget *scroller;
GtkWidget *label;
GtkWidget *empty;
PangoAttrList *attributes;
gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (self), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect (self, "key-press-event",
G_CALLBACK (window_key_press_event_cb), NULL);
priv->keywords = g_hash_table_new_full (NULL, NULL, NULL, g_free);
priv->search_items_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
priv->search_text_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->search_image_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->header_bar = g_object_new (GTK_TYPE_HEADER_BAR,
"show-close-button", TRUE,
"visible", TRUE,
NULL);
gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->header_bar));
search_button = g_object_new (GTK_TYPE_TOGGLE_BUTTON,
"child", g_object_new (GTK_TYPE_IMAGE,
"visible", TRUE,
"icon-name", "edit-find-symbolic",
NULL),
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (priv->header_bar), GTK_WIDGET (search_button));
priv->main_box = g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
GTK_CONTAINER_CLASS (gtk_shortcuts_window_parent_class)->add (GTK_CONTAINER (self), GTK_WIDGET (priv->main_box));
priv->search_bar = g_object_new (GTK_TYPE_SEARCH_BAR,
"visible", TRUE,
NULL);
g_object_bind_property (priv->search_bar, "search-mode-enabled",
search_button, "active",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->search_bar));
priv->stack = g_object_new (GTK_TYPE_STACK,
"expand", TRUE,
"homogeneous", TRUE,
"transition-type", GTK_STACK_TRANSITION_TYPE_CROSSFADE,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->stack));
priv->title_stack = g_object_new (GTK_TYPE_STACK,
"visible", TRUE,
NULL);
gtk_header_bar_set_custom_title (priv->header_bar, GTK_WIDGET (priv->title_stack));
label = gtk_label_new (_("Shortcuts"));
gtk_widget_show (label);
gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_TITLE);
gtk_stack_add_named (priv->title_stack, label, "title");
label = gtk_label_new (_("Search Results"));
gtk_widget_show (label);
gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_TITLE);
gtk_stack_add_named (priv->title_stack, label, "search");
priv->menu_button = g_object_new (GTK_TYPE_MENU_BUTTON,
"focus-on-click", FALSE,
"visible", TRUE,
"relief", GTK_RELIEF_NONE,
NULL);
gtk_stack_add_named (priv->title_stack, GTK_WIDGET (priv->menu_button), "sections");
menu_box = g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_HORIZONTAL,
"spacing", 6,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (priv->menu_button), GTK_WIDGET (menu_box));
priv->menu_label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (priv->menu_label));
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
arrow = g_object_new (GTK_TYPE_ARROW,
"arrow-type", GTK_ARROW_DOWN,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (arrow));
G_GNUC_END_IGNORE_DEPRECATIONS;
priv->popover = g_object_new (GTK_TYPE_POPOVER,
"border-width", 6,
"relative-to", priv->menu_button,
"position", GTK_POS_BOTTOM,
NULL);
gtk_menu_button_set_popover (priv->menu_button, GTK_WIDGET (priv->popover));
priv->list_box = g_object_new (GTK_TYPE_LIST_BOX,
"selection-mode", GTK_SELECTION_NONE,
"visible", TRUE,
NULL);
g_signal_connect_object (priv->list_box,
"row-activated",
G_CALLBACK (gtk_shortcuts_window__list_box__row_activated),
self,
G_CONNECT_SWAPPED);
gtk_container_add (GTK_CONTAINER (priv->popover), GTK_WIDGET (priv->list_box));
priv->search_entry = GTK_SEARCH_ENTRY (gtk_search_entry_new ());
gtk_widget_show (GTK_WIDGET (priv->search_entry));
gtk_container_add (GTK_CONTAINER (priv->search_bar), GTK_WIDGET (priv->search_entry));
g_object_set (priv->search_entry,
"placeholder-text", _("Search Shortcuts"),
"width-chars", 40,
NULL);
g_signal_connect_object (priv->search_entry,
"search-changed",
G_CALLBACK (gtk_shortcuts_window__entry__changed),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->search_bar,
"notify::search-mode-enabled",
G_CALLBACK (gtk_shortcuts_window__search_mode__changed),
self,
G_CONNECT_SWAPPED);
scroller = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"visible", TRUE,
NULL);
box = g_object_new (GTK_TYPE_BOX,
"border-width", 24,
"halign", GTK_ALIGN_CENTER,
"spacing", 24,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (box));
gtk_stack_add_named (priv->stack, scroller, "internal-search");
priv->search_shortcuts = g_object_new (GTK_TYPE_BOX,
"halign", GTK_ALIGN_CENTER,
"spacing", 6,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_shortcuts));
priv->search_gestures = g_object_new (GTK_TYPE_BOX,
"halign", GTK_ALIGN_CENTER,
"spacing", 6,
"orientation", GTK_ORIENTATION_VERTICAL,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_gestures));
empty = g_object_new (GTK_TYPE_GRID,
"visible", TRUE,
"row-spacing", 12,
"margin", 12,
"hexpand", TRUE,
"vexpand", TRUE,
"halign", GTK_ALIGN_CENTER,
"valign", GTK_ALIGN_CENTER,
NULL);
gtk_style_context_add_class (gtk_widget_get_style_context (empty), GTK_STYLE_CLASS_DIM_LABEL);
gtk_grid_attach (GTK_GRID (empty),
g_object_new (GTK_TYPE_IMAGE,
"visible", TRUE,
"icon-name", "edit-find-symbolic",
"pixel-size", 72,
NULL),
0, 0, 1, 1);
attributes = pango_attr_list_new ();
pango_attr_list_insert (attributes, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
pango_attr_list_insert (attributes, pango_attr_scale_new (1.44));
label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", _("No Results Found"),
"attributes", attributes,
NULL);
pango_attr_list_unref (attributes);
gtk_grid_attach (GTK_GRID (empty), label, 0, 1, 1, 1);
label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", _("Try a different search"),
NULL);
gtk_grid_attach (GTK_GRID (empty), label, 0, 2, 1, 1);
gtk_stack_add_named (priv->stack, empty, "no-search-results");
g_signal_connect_object (priv->stack, "notify::visible-child",
G_CALLBACK (update_title_stack), self, G_CONNECT_SWAPPED);
}
static void
panel_start_gui(panel *p)
{
ENTER;
// main toplevel window
p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0);
g_signal_connect(G_OBJECT(p->topgwin), "destroy-event",
(GCallback) panel_destroy_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "size-request",
(GCallback) panel_size_req, p);
g_signal_connect(G_OBJECT(p->topgwin), "map-event",
(GCallback) panel_mapped, p);
g_signal_connect(G_OBJECT(p->topgwin), "configure-event",
(GCallback) panel_configure_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "button-press-event",
(GCallback) panel_button_press_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "scroll-event",
(GCallback) panel_scroll_event, p);
gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel");
gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel");
gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE);
gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_accept_focus(GTK_WINDOW(p->topgwin), FALSE);
if (p->setdocktype)
gtk_window_set_type_hint(GTK_WINDOW(p->topgwin),
GDK_WINDOW_TYPE_HINT_DOCK);
if (p->layer == LAYER_ABOVE)
gtk_window_set_keep_above(GTK_WINDOW(p->topgwin), TRUE);
else if (p->layer == LAYER_BELOW)
gtk_window_set_keep_below(GTK_WINDOW(p->topgwin), TRUE);
gtk_window_stick(GTK_WINDOW(p->topgwin));
gtk_widget_realize(p->topgwin);
p->topxwin = GDK_WINDOW_XWINDOW(p->topgwin->window);
DBG("topxwin = %lx\n", p->topxwin);
/* ensure configure event */
XMoveWindow(GDK_DISPLAY(), p->topxwin, 20, 20);
XSync(GDK_DISPLAY(), False);
gtk_widget_set_app_paintable(p->topgwin, TRUE);
calculate_position(p);
gtk_window_move(GTK_WINDOW(p->topgwin), p->ax, p->ay);
gtk_window_resize(GTK_WINDOW(p->topgwin), p->aw, p->ah);
DBG("move-resize x %d y %d w %d h %d\n", p->ax, p->ay, p->aw, p->ah);
//XSync(GDK_DISPLAY(), False);
//gdk_flush();
// background box all over toplevel
p->bbox = gtk_bgbox_new();
gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox);
gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0);
if (p->transparent) {
p->bg = fb_bg_get_for_display();
gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha);
}
// main layout manager as a single child of background widget box
p->lbox = p->my_box_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0);
gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox);
p->box = p->my_box_new(FALSE, p->spacing);
gtk_container_set_border_width(GTK_CONTAINER(p->box), 0);
gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE,
(p->round_corners) ? p->round_corners_radius : 0);
if (p->round_corners) {
make_round_corners(p);
DBG("make_round_corners\n");
}
/* start window creation process */
gtk_widget_show_all(p->topgwin);
/* .. and hide it from user until everything is done */
gtk_widget_hide(p->topgwin);
p->menu = panel_make_menu(p);
if (p->setstrut)
panel_set_wm_strut(p);
XSelectInput(GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask);
gdk_window_add_filter(gdk_get_default_root_window(),
(GdkFilterFunc)panel_event_filter, p);
//XSync(GDK_DISPLAY(), False);
gdk_flush();
RET();
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label1;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *hscale1;
GtkWidget *hbox2;
GtkWidget *drawingarea1;
GtkWidget *vscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Subtitle Size and Position"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->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);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP("Font Size:"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
spinbutton1_adj = gtk_adjustment_new (1, 6, 99, 1, 10, 10);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 2);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (hbox1), spinbutton1, FALSE, FALSE, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 1)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (hbox2), drawingarea1, TRUE, TRUE, 0);
vscale1 = gtk_vscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 100, 1, 1, 1, 1)));
gtk_widget_show (vscale1);
gtk_box_pack_start (GTK_BOX (hbox2), vscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (vscale1), 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->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 (dialog1), 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 (dialog1), 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 (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT (dialog1, vscale1, "vscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
//******************
GtkWidget *create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *hscaleHue;
GtkWidget *hscaleSaturation;
GtkWidget *hscale1;
GtkWidget *drawingarea1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Hue/Saturation"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->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, TRUE, TRUE, 0);
label1 = gtk_label_new (QT_TR_NOOP("<b>Hue:</b>"));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (QT_TR_NOOP("<b>Saturation:</b>"));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
hscaleHue = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -90, 90, 1, 1, 1)));
gtk_widget_show (hscaleHue);
gtk_table_attach (GTK_TABLE (table1), hscaleHue, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -10, 10, 1, 1, 1)));
gtk_widget_show (hscaleSaturation);
gtk_table_attach (GTK_TABLE (table1), hscaleSaturation, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 1)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0);
drawingarea1 = gtk_drawing_area_new ();
gtk_widget_show (drawingarea1);
gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->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 (dialog1), 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 (dialog1), 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 (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, hscaleHue, "hscaleHue");
GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
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;
}
GtkWidget*
create_convpreset_editor (void)
{
GtkWidget *convpreset_editor;
GtkWidget *dialog_vbox7;
GtkWidget *vbox27;
GtkWidget *hbox70;
GtkWidget *label105;
GtkWidget *title;
GtkWidget *hbox96;
GtkWidget *label120;
GtkWidget *ext;
GtkWidget *hbox72;
GtkWidget *label106;
GtkWidget *hbox93;
GtkWidget *encoder;
GtkWidget *custom4;
GtkWidget *label124;
GtkWidget *hbox73;
GtkWidget *label107;
GtkWidget *method;
GtkWidget *frame9;
GtkWidget *alignment21;
GtkWidget *table2;
GtkWidget *apev2;
GtkWidget *id3v1;
GtkWidget *oggvorbis;
GtkWidget *flac;
GtkWidget *hbox104;
GtkWidget *id3v2;
GtkWidget *id3v2_version;
GtkWidget *mp4;
GtkWidget *label125;
GtkWidget *dialog_action_area6;
GtkWidget *convpreset_cancel;
GtkWidget *convpreset_ok;
convpreset_editor = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (convpreset_editor), _("Edit Encoder Preset"));
gtk_window_set_modal (GTK_WINDOW (convpreset_editor), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (convpreset_editor), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox7 = gtk_dialog_get_content_area (GTK_DIALOG (convpreset_editor));
gtk_widget_show (dialog_vbox7);
vbox27 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox27);
gtk_box_pack_start (GTK_BOX (dialog_vbox7), vbox27, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox27), 12);
hbox70 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox70);
gtk_box_pack_start (GTK_BOX (vbox27), hbox70, FALSE, TRUE, 0);
label105 = gtk_label_new (_("Title:"));
gtk_widget_show (label105);
gtk_box_pack_start (GTK_BOX (hbox70), label105, FALSE, FALSE, 0);
title = gtk_entry_new ();
gtk_widget_show (title);
gtk_box_pack_start (GTK_BOX (hbox70), title, TRUE, TRUE, 0);
gtk_entry_set_text (GTK_ENTRY (title), _("Untitled Encoder"));
gtk_entry_set_invisible_char (GTK_ENTRY (title), 9679);
gtk_entry_set_activates_default (GTK_ENTRY (title), TRUE);
hbox96 = gtk_hbox_new (FALSE, 9);
gtk_widget_show (hbox96);
gtk_box_pack_start (GTK_BOX (vbox27), hbox96, FALSE, TRUE, 0);
label120 = gtk_label_new (_("Output file extension:"));
gtk_widget_show (label120);
gtk_box_pack_start (GTK_BOX (hbox96), label120, FALSE, FALSE, 0);
ext = gtk_entry_new ();
gtk_widget_show (ext);
gtk_box_pack_start (GTK_BOX (hbox96), ext, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (ext, _("E.g. mp3"));
gtk_entry_set_invisible_char (GTK_ENTRY (ext), 9679);
gtk_entry_set_activates_default (GTK_ENTRY (ext), TRUE);
hbox72 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox72);
gtk_box_pack_start (GTK_BOX (vbox27), hbox72, FALSE, TRUE, 0);
label106 = gtk_label_new (_("Command line:"));
gtk_widget_show (label106);
gtk_box_pack_start (GTK_BOX (hbox72), label106, FALSE, FALSE, 0);
hbox93 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox93);
gtk_box_pack_start (GTK_BOX (hbox72), hbox93, TRUE, TRUE, 0);
encoder = gtk_entry_new ();
gtk_widget_show (encoder);
gtk_box_pack_start (GTK_BOX (hbox93), encoder, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (encoder, _("Example: lame - %o\n%i for input file, %o for output file, - for stdin"));
gtk_entry_set_invisible_char (GTK_ENTRY (encoder), 9679);
gtk_entry_set_activates_default (GTK_ENTRY (encoder), TRUE);
custom4 = encoder_cmdline_help_link_create ("custom4", "", "", 0, 0);
gtk_widget_show (custom4);
gtk_box_pack_start (GTK_BOX (hbox93), custom4, TRUE, TRUE, 0);
gtk_widget_set_can_focus(custom4, FALSE);
gtk_widget_set_can_default(custom4, FALSE);
label124 = gtk_label_new (_("<small>%o - output file name\n%i - temporary input file name</small>"));
gtk_widget_show (label124);
gtk_box_pack_start (GTK_BOX (vbox27), label124, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label124), TRUE);
hbox73 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox73);
gtk_box_pack_start (GTK_BOX (vbox27), hbox73, FALSE, TRUE, 0);
label107 = gtk_label_new (_("Method:"));
gtk_widget_show (label107);
gtk_box_pack_start (GTK_BOX (hbox73), label107, FALSE, FALSE, 0);
method = gtk_combo_box_text_new ();
gtk_widget_show (method);
gtk_box_pack_start (GTK_BOX (hbox73), method, TRUE, TRUE, 0);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (method), _("Pipe"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (method), _("Temp File"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (method), _("Source File"));
frame9 = gtk_frame_new (NULL);
gtk_widget_show (frame9);
gtk_box_pack_start (GTK_BOX (vbox27), frame9, FALSE, FALSE, 0);
alignment21 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment21);
gtk_container_add (GTK_CONTAINER (frame9), alignment21);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment21), 0, 0, 12, 0);
table2 = gtk_table_new (2, 3, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (alignment21), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 8);
gtk_table_set_col_spacings (GTK_TABLE (table2), 8);
apev2 = gtk_check_button_new_with_mnemonic (_("APEv2"));
gtk_widget_show (apev2);
gtk_table_attach (GTK_TABLE (table2), apev2, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
id3v1 = gtk_check_button_new_with_mnemonic (_("ID3v1"));
gtk_widget_show (id3v1);
gtk_table_attach (GTK_TABLE (table2), id3v1, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
oggvorbis = gtk_check_button_new_with_mnemonic (_("OggVorbis"));
gtk_widget_show (oggvorbis);
gtk_table_attach (GTK_TABLE (table2), oggvorbis, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
flac = gtk_check_button_new_with_mnemonic (_("FLAC"));
gtk_widget_show (flac);
gtk_table_attach (GTK_TABLE (table2), flac, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
hbox104 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox104);
gtk_table_attach (GTK_TABLE (table2), hbox104, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
id3v2 = gtk_check_button_new_with_mnemonic (_("ID3v2"));
gtk_widget_show (id3v2);
gtk_box_pack_start (GTK_BOX (hbox104), id3v2, FALSE, FALSE, 0);
id3v2_version = gtk_combo_box_text_new ();
gtk_widget_show (id3v2_version);
gtk_box_pack_start (GTK_BOX (hbox104), id3v2_version, TRUE, TRUE, 0);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (id3v2_version), "2.3");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (id3v2_version), "2.4");
mp4 = gtk_check_button_new_with_mnemonic (_("MP4"));
gtk_widget_show (mp4);
gtk_table_attach (GTK_TABLE (table2), mp4, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label125 = gtk_label_new (_("<b>Tag writer</b>"));
gtk_widget_show (label125);
gtk_frame_set_label_widget (GTK_FRAME (frame9), label125);
gtk_label_set_use_markup (GTK_LABEL (label125), TRUE);
dialog_action_area6 = gtk_dialog_get_action_area (GTK_DIALOG (convpreset_editor));
gtk_widget_show (dialog_action_area6);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area6), GTK_BUTTONBOX_END);
convpreset_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (convpreset_cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (convpreset_editor), convpreset_cancel, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default(convpreset_cancel, TRUE);
convpreset_ok = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (convpreset_ok);
gtk_dialog_add_action_widget (GTK_DIALOG (convpreset_editor), convpreset_ok, GTK_RESPONSE_OK);
gtk_widget_set_can_default(convpreset_ok, TRUE);
g_signal_connect ((gpointer) encoder, "changed",
G_CALLBACK (on_encoder_changed),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (convpreset_editor, convpreset_editor, "convpreset_editor");
GLADE_HOOKUP_OBJECT_NO_REF (convpreset_editor, dialog_vbox7, "dialog_vbox7");
GLADE_HOOKUP_OBJECT (convpreset_editor, vbox27, "vbox27");
GLADE_HOOKUP_OBJECT (convpreset_editor, hbox70, "hbox70");
GLADE_HOOKUP_OBJECT (convpreset_editor, label105, "label105");
GLADE_HOOKUP_OBJECT (convpreset_editor, title, "title");
GLADE_HOOKUP_OBJECT (convpreset_editor, hbox96, "hbox96");
GLADE_HOOKUP_OBJECT (convpreset_editor, label120, "label120");
GLADE_HOOKUP_OBJECT (convpreset_editor, ext, "ext");
GLADE_HOOKUP_OBJECT (convpreset_editor, hbox72, "hbox72");
GLADE_HOOKUP_OBJECT (convpreset_editor, label106, "label106");
GLADE_HOOKUP_OBJECT (convpreset_editor, hbox93, "hbox93");
GLADE_HOOKUP_OBJECT (convpreset_editor, encoder, "encoder");
GLADE_HOOKUP_OBJECT (convpreset_editor, custom4, "custom4");
GLADE_HOOKUP_OBJECT (convpreset_editor, label124, "label124");
GLADE_HOOKUP_OBJECT (convpreset_editor, hbox73, "hbox73");
GLADE_HOOKUP_OBJECT (convpreset_editor, label107, "label107");
GLADE_HOOKUP_OBJECT (convpreset_editor, method, "method");
GLADE_HOOKUP_OBJECT (convpreset_editor, frame9, "frame9");
GLADE_HOOKUP_OBJECT (convpreset_editor, alignment21, "alignment21");
GLADE_HOOKUP_OBJECT (convpreset_editor, table2, "table2");
GLADE_HOOKUP_OBJECT (convpreset_editor, apev2, "apev2");
GLADE_HOOKUP_OBJECT (convpreset_editor, id3v1, "id3v1");
GLADE_HOOKUP_OBJECT (convpreset_editor, oggvorbis, "oggvorbis");
GLADE_HOOKUP_OBJECT (convpreset_editor, flac, "flac");
GLADE_HOOKUP_OBJECT (convpreset_editor, hbox104, "hbox104");
GLADE_HOOKUP_OBJECT (convpreset_editor, id3v2, "id3v2");
GLADE_HOOKUP_OBJECT (convpreset_editor, id3v2_version, "id3v2_version");
GLADE_HOOKUP_OBJECT (convpreset_editor, mp4, "mp4");
GLADE_HOOKUP_OBJECT (convpreset_editor, label125, "label125");
GLADE_HOOKUP_OBJECT_NO_REF (convpreset_editor, dialog_action_area6, "dialog_action_area6");
GLADE_HOOKUP_OBJECT (convpreset_editor, convpreset_cancel, "convpreset_cancel");
GLADE_HOOKUP_OBJECT (convpreset_editor, convpreset_ok, "convpreset_ok");
return convpreset_editor;
}
GtkWidget*
create_dsppreset_editor (void)
{
GtkWidget *dsppreset_editor;
GtkWidget *dialog_vbox9;
GtkWidget *vbox30;
GtkWidget *hbox81;
GtkWidget *label111;
GtkWidget *title;
GtkWidget *vbox29;
GtkWidget *hbox82;
GtkWidget *add;
GtkWidget *remove;
GtkWidget *configure;
GtkWidget *hbox98;
GtkWidget *scrolledwindow7;
GtkWidget *plugins;
GtkWidget *vbox34;
GtkWidget *up;
GtkWidget *down;
GtkWidget *dialog_action_area8;
GtkWidget *cancelbutton6;
GtkWidget *okbutton6;
dsppreset_editor = gtk_dialog_new ();
gtk_widget_set_size_request (dsppreset_editor, 468, 254);
gtk_window_set_title (GTK_WINDOW (dsppreset_editor), _("DSP Preset Editor"));
gtk_window_set_modal (GTK_WINDOW (dsppreset_editor), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (dsppreset_editor), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox9 = gtk_dialog_get_content_area (GTK_DIALOG (dsppreset_editor));
gtk_widget_show (dialog_vbox9);
vbox30 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox30);
gtk_box_pack_start (GTK_BOX (dialog_vbox9), vbox30, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox30), 12);
hbox81 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox81);
gtk_box_pack_start (GTK_BOX (vbox30), hbox81, FALSE, TRUE, 0);
label111 = gtk_label_new (_("Title"));
gtk_widget_show (label111);
gtk_box_pack_start (GTK_BOX (hbox81), label111, FALSE, FALSE, 0);
title = gtk_entry_new ();
gtk_widget_show (title);
gtk_box_pack_start (GTK_BOX (hbox81), title, TRUE, TRUE, 0);
gtk_entry_set_text (GTK_ENTRY (title), _("Untitled DSP Preset"));
gtk_entry_set_invisible_char (GTK_ENTRY (title), 9679);
gtk_entry_set_activates_default (GTK_ENTRY (title), TRUE);
vbox29 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox29);
gtk_box_pack_start (GTK_BOX (vbox30), vbox29, TRUE, TRUE, 0);
hbox82 = gtk_hbox_new (TRUE, 8);
gtk_widget_show (hbox82);
gtk_box_pack_start (GTK_BOX (vbox29), hbox82, FALSE, TRUE, 0);
add = gtk_button_new_with_mnemonic (_("Add"));
gtk_widget_show (add);
gtk_box_pack_start (GTK_BOX (hbox82), add, TRUE, TRUE, 0);
remove = gtk_button_new_with_mnemonic (_("Remove"));
gtk_widget_show (remove);
gtk_box_pack_start (GTK_BOX (hbox82), remove, TRUE, TRUE, 0);
configure = gtk_button_new_with_mnemonic (_("Configure"));
gtk_widget_show (configure);
gtk_box_pack_start (GTK_BOX (hbox82), configure, TRUE, TRUE, 0);
hbox98 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox98);
gtk_box_pack_start (GTK_BOX (vbox29), hbox98, TRUE, TRUE, 0);
scrolledwindow7 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow7);
gtk_box_pack_start (GTK_BOX (hbox98), scrolledwindow7, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow7), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow7), GTK_SHADOW_IN);
plugins = gtk_tree_view_new ();
gtk_widget_show (plugins);
gtk_container_add (GTK_CONTAINER (scrolledwindow7), plugins);
gtk_widget_set_size_request (plugins, 196, -1);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (plugins), FALSE);
vbox34 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox34);
gtk_box_pack_start (GTK_BOX (hbox98), vbox34, FALSE, FALSE, 0);
up = gtk_button_new_from_stock ("gtk-go-up");
gtk_widget_show (up);
gtk_box_pack_start (GTK_BOX (vbox34), up, FALSE, FALSE, 0);
down = gtk_button_new_from_stock ("gtk-go-down");
gtk_widget_show (down);
gtk_box_pack_start (GTK_BOX (vbox34), down, FALSE, FALSE, 0);
dialog_action_area8 = gtk_dialog_get_action_area (GTK_DIALOG (dsppreset_editor));
gtk_widget_show (dialog_action_area8);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area8), GTK_BUTTONBOX_END);
cancelbutton6 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton6);
gtk_dialog_add_action_widget (GTK_DIALOG (dsppreset_editor), cancelbutton6, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default(cancelbutton6, TRUE);
okbutton6 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton6);
gtk_dialog_add_action_widget (GTK_DIALOG (dsppreset_editor), okbutton6, GTK_RESPONSE_OK);
gtk_widget_set_can_default(okbutton6, TRUE);
g_signal_connect ((gpointer) add, "clicked",
G_CALLBACK (on_dsp_preset_add_plugin_clicked),
NULL);
g_signal_connect ((gpointer) remove, "clicked",
G_CALLBACK (on_dsp_preset_remove_plugin_clicked),
NULL);
g_signal_connect ((gpointer) configure, "clicked",
G_CALLBACK (on_dsp_preset_plugin_configure_clicked),
NULL);
g_signal_connect ((gpointer) up, "clicked",
G_CALLBACK (on_dsp_preset_plugin_up_clicked),
NULL);
g_signal_connect ((gpointer) down, "clicked",
G_CALLBACK (on_dsp_preset_plugin_down_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dsppreset_editor, dsppreset_editor, "dsppreset_editor");
GLADE_HOOKUP_OBJECT_NO_REF (dsppreset_editor, dialog_vbox9, "dialog_vbox9");
GLADE_HOOKUP_OBJECT (dsppreset_editor, vbox30, "vbox30");
GLADE_HOOKUP_OBJECT (dsppreset_editor, hbox81, "hbox81");
GLADE_HOOKUP_OBJECT (dsppreset_editor, label111, "label111");
GLADE_HOOKUP_OBJECT (dsppreset_editor, title, "title");
GLADE_HOOKUP_OBJECT (dsppreset_editor, vbox29, "vbox29");
GLADE_HOOKUP_OBJECT (dsppreset_editor, hbox82, "hbox82");
GLADE_HOOKUP_OBJECT (dsppreset_editor, add, "add");
GLADE_HOOKUP_OBJECT (dsppreset_editor, remove, "remove");
GLADE_HOOKUP_OBJECT (dsppreset_editor, configure, "configure");
GLADE_HOOKUP_OBJECT (dsppreset_editor, hbox98, "hbox98");
GLADE_HOOKUP_OBJECT (dsppreset_editor, scrolledwindow7, "scrolledwindow7");
GLADE_HOOKUP_OBJECT (dsppreset_editor, plugins, "plugins");
GLADE_HOOKUP_OBJECT (dsppreset_editor, vbox34, "vbox34");
GLADE_HOOKUP_OBJECT (dsppreset_editor, up, "up");
GLADE_HOOKUP_OBJECT (dsppreset_editor, down, "down");
GLADE_HOOKUP_OBJECT_NO_REF (dsppreset_editor, dialog_action_area8, "dialog_action_area8");
GLADE_HOOKUP_OBJECT (dsppreset_editor, cancelbutton6, "cancelbutton6");
GLADE_HOOKUP_OBJECT (dsppreset_editor, okbutton6, "okbutton6");
return dsppreset_editor;
}
ConfigDialog *config_dialog_new(void)
{
ConfigDialog *config_win;
GtkTooltips *tooltips;
GtkWidget *window_main;
GtkWidget *vbox_main;
GtkWidget *label_scale_factor;
GtkWidget *hscale_scale_factor;
GtkWidget *frame_general;
GtkWidget *table_general;
GtkWidget *label_effect;
GtkWidget *label_palette;
GtkWidget *label_fps;
GtkWidget *checkbutton_show_title;
GtkWidget *hscale_effect;
GtkWidget *hscale_palette;
GtkObject *spinbutton_fps_adj;
GtkWidget *spinbutton_fps;
GtkWidget *hbuttonbox_main;
GtkWidget *button_ok;
GtkWidget *button_cancel;
GtkWidget *button_apply;
#if ENABLE_NLS
setlocale(LC_MESSAGES, "");
bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
#endif
window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(window_main), "window_main", window_main);
gtk_window_set_title(GTK_WINDOW(window_main), _("Infinity Configuration"));
gtk_window_set_type_hint(GTK_WINDOW(window_main), GDK_WINDOW_TYPE_HINT_DIALOG);
vbox_main = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(vbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "vbox_main", vbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(vbox_main);
gtk_container_add(GTK_CONTAINER(window_main), vbox_main);
gtk_container_set_border_width(GTK_CONTAINER(vbox_main), 2);
frame_general = gtk_frame_new(_("Parameters"));
gtk_widget_ref(frame_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "frame_general", frame_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(frame_general);
gtk_box_pack_start(GTK_BOX(vbox_main), frame_general, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame_general), 2);
table_general = gtk_table_new(5, 3, FALSE);
gtk_widget_ref(table_general);
gtk_object_set_data_full(GTK_OBJECT(window_main), "table_general", table_general,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(table_general);
gtk_container_add(GTK_CONTAINER(frame_general), table_general);
gtk_container_set_border_width(GTK_CONTAINER(table_general), 2);
gtk_table_set_row_spacings(GTK_TABLE(table_general), 2);
gtk_table_set_col_spacings(GTK_TABLE(table_general), 2);
label_effect = gtk_label_new(_("Effect period:"));
gtk_widget_ref(label_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_effect", label_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_effect);
gtk_table_attach(GTK_TABLE(table_general), label_effect, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_effect), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_effect), 1, 0);
label_palette = gtk_label_new(_("Palette period:"));
gtk_widget_ref(label_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_palette", label_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_palette);
gtk_table_attach(GTK_TABLE(table_general), label_palette, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_palette), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_palette), 1, 0);
label_scale_factor = gtk_label_new(_("Scale Factor"));
gtk_widget_ref(label_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_scale_factor", label_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), label_scale_factor, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_scale_factor), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_scale_factor), 1, 0);
label_fps = gtk_label_new(_("Maximum Frames per Second:"));
gtk_widget_ref(label_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "label_fps", label_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(label_fps);
gtk_table_attach(GTK_TABLE(table_general), label_fps, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_fps), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label_fps), 1, 0);
checkbutton_show_title = gtk_check_button_new_with_label(_("Show current play title"));
gtk_widget_ref(checkbutton_show_title);
gtk_object_set_data_full(GTK_OBJECT(window_main), "checkbutton_show_title", checkbutton_show_title,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(checkbutton_show_title);
gtk_table_attach(GTK_TABLE(table_general), checkbutton_show_title, 0, 1, 4, 5,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips, checkbutton_show_title,
_("Check it if you want to see the current play "
"title on the Infinity's title bar"), NULL);
//spinbutton_fps_adj = gtk_adjustment_new (30, 5, 150, 1, 10, 0);
spinbutton_fps_adj = gtk_adjustment_new(config_get_fps(), 5, 150, 1, 10, 0);
spinbutton_fps = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_fps_adj), 1, 0);
gtk_widget_ref(spinbutton_fps);
gtk_object_set_data_full(GTK_OBJECT(window_main), "spinbutton_fps", spinbutton_fps,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(spinbutton_fps);
gtk_table_attach(GTK_TABLE(table_general), spinbutton_fps, 2, 3, 3, 4,
(GtkAttachOptions)(0),
(GtkAttachOptions)(0), 0, 0);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spinbutton_fps), GTK_UPDATE_IF_VALID);
hscale_effect = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_effect);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_effect", hscale_effect,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_effect);
gtk_table_attach(GTK_TABLE(table_general), hscale_effect, 1, 3, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_effect), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_effect), 0);
gtk_tooltips_set_tip(tooltips, hscale_effect,
_("Time to change between an effect and the "
"next one, in milliseconds."), NULL);
hscale_palette = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(100, 50, 400, 0, 0, 0)));
gtk_widget_ref(hscale_palette);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_palette", hscale_palette,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_palette);
gtk_table_attach(GTK_TABLE(table_general), hscale_palette, 1, 3, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_palette), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_palette), 0);
gtk_tooltips_set_tip(tooltips, hscale_palette,
_("Time to change between a color and the "
"next one, in milliseconds."), NULL);
hscale_scale_factor = gtk_hscale_new(GTK_ADJUSTMENT(gtk_adjustment_new(1, 1, 2, 0, 0, 0)));
gtk_widget_ref(hscale_scale_factor);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hscale_scale_factor", hscale_scale_factor,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hscale_scale_factor);
gtk_table_attach(GTK_TABLE(table_general), hscale_scale_factor, 1, 3, 2, 3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(hscale_scale_factor), GTK_POS_LEFT);
gtk_scale_set_digits(GTK_SCALE(hscale_scale_factor), 0);
gtk_tooltips_set_tip(tooltips, hscale_scale_factor,
_("Change only if the system doesn't have "
"enough power to show the screen at "
"a reasonably speed/size relation."), NULL);
hbuttonbox_main = gtk_hbutton_box_new();
gtk_widget_ref(hbuttonbox_main);
gtk_object_set_data_full(GTK_OBJECT(window_main), "hbuttonbox_main", hbuttonbox_main,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(hbuttonbox_main);
gtk_box_pack_start(GTK_BOX(vbox_main), hbuttonbox_main, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbuttonbox_main), 2);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox_main), GTK_BUTTONBOX_END);
button_ok = gtk_button_new_with_label(_("Ok"));
gtk_widget_ref(button_ok);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_ok", button_ok,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_ok);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_ok);
GTK_WIDGET_SET_FLAGS(button_ok, GTK_CAN_DEFAULT);
gtk_tooltips_set_tip(tooltips, button_ok,
_("For to toggle to fullscreen mode, select "
"the Infinity plugin window, and press "
"the Tab key. Pressing Tab again will return "
"to window mode."), NULL);
button_cancel = gtk_button_new_with_label(_("Cancel"));
gtk_widget_ref(button_cancel);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_cancel", button_cancel,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_cancel);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_cancel);
GTK_WIDGET_SET_FLAGS(button_cancel, GTK_CAN_DEFAULT);
button_apply = gtk_button_new_with_label(_("Apply"));
gtk_widget_ref(button_apply);
gtk_object_set_data_full(GTK_OBJECT(window_main), "button_apply", button_apply,
(GtkDestroyNotify)gtk_widget_unref);
gtk_widget_show(button_apply);
gtk_container_add(GTK_CONTAINER(hbuttonbox_main), button_apply);
GTK_WIDGET_SET_FLAGS(button_apply, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button_cancel);
config_win = g_new0(ConfigDialog, 1);
config_win->window_main = window_main;
config_win->hscale_effect = hscale_effect;
config_win->hscale_palette = hscale_palette;
config_win->hscale_scale_factor = hscale_scale_factor;
config_win->spinbutton_fps = spinbutton_fps;
config_win->checkbutton_show_title = checkbutton_show_title;
config_win->button_ok = button_ok;
config_win->button_cancel = button_cancel;
config_win->button_apply = button_apply;
gtk_tooltips_enable(tooltips);
return config_win;
}
GtkWidget*
create_converterdlg (void)
{
GtkWidget *converterdlg;
GtkWidget *dialog_vbox6;
GtkWidget *hbox105;
GtkWidget *vbox26;
GtkWidget *hbox67;
GtkWidget *label103;
GtkWidget *hbox68;
GtkWidget *output_folder;
GtkWidget *converter_output_browse;
GtkWidget *write_to_source_folder;
GtkWidget *preserve_folders;
GtkWidget *bypass_same_format;
GtkWidget *retag_after_copy;
GtkWidget *hbox100;
GtkWidget *label122;
GtkWidget *hbox101;
GtkWidget *output_file;
GtkWidget *custom6;
GtkWidget *hbox69;
GtkWidget *label104;
GtkWidget *hbox90;
GtkWidget *encoder;
GtkWidget *edit_encoder_presets;
GtkWidget *image469;
GtkWidget *hbox86;
GtkWidget *label114;
GtkWidget *hbox91;
GtkWidget *dsp_preset;
GtkWidget *edit_dsp_presets;
GtkWidget *image470;
GtkWidget *hbox88;
GtkWidget *label116;
GObject *numthreads_adj;
GtkWidget *numthreads;
GtkWidget *hbox89;
GtkWidget *label117;
GtkWidget *output_format;
GtkWidget *hbox99;
GtkWidget *label121;
GtkWidget *overwrite_action;
GtkWidget *scrolledwindow9;
GtkWidget *preview_tree;
GtkWidget *dialog_action_area5;
GtkWidget *converter_cancel;
GtkWidget *converter_ok;
converterdlg = gtk_dialog_new ();
gtk_widget_set_size_request (converterdlg, 720, -1);
gtk_window_set_title (GTK_WINDOW (converterdlg), "Converter");
gtk_window_set_position (GTK_WINDOW (converterdlg), GTK_WIN_POS_MOUSE);
gtk_window_set_modal (GTK_WINDOW (converterdlg), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (converterdlg), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (converterdlg), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_dialog_set_has_separator (GTK_DIALOG (converterdlg), FALSE);
dialog_vbox6 = gtk_dialog_get_content_area (GTK_DIALOG (converterdlg));
gtk_widget_show (dialog_vbox6);
hbox105 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox105);
gtk_box_pack_start (GTK_BOX (dialog_vbox6), hbox105, TRUE, TRUE, 0);
vbox26 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox26);
gtk_box_pack_start (GTK_BOX (hbox105), vbox26, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox26), 12);
hbox67 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox67);
gtk_box_pack_start (GTK_BOX (vbox26), hbox67, FALSE, TRUE, 0);
label103 = gtk_label_new (_("Output folder:"));
gtk_widget_show (label103);
gtk_box_pack_start (GTK_BOX (hbox67), label103, FALSE, FALSE, 0);
hbox68 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox68);
gtk_box_pack_start (GTK_BOX (hbox67), hbox68, TRUE, TRUE, 0);
output_folder = gtk_entry_new ();
gtk_widget_show (output_folder);
gtk_box_pack_start (GTK_BOX (hbox68), output_folder, TRUE, TRUE, 0);
gtk_entry_set_invisible_char (GTK_ENTRY (output_folder), 9679);
converter_output_browse = gtk_button_new_with_mnemonic ("...");
gtk_widget_show (converter_output_browse);
gtk_box_pack_start (GTK_BOX (hbox68), converter_output_browse, FALSE, FALSE, 0);
write_to_source_folder = gtk_check_button_new_with_mnemonic (_("Write to source track folder"));
gtk_widget_show (write_to_source_folder);
gtk_box_pack_start (GTK_BOX (vbox26), write_to_source_folder, FALSE, FALSE, 0);
preserve_folders = gtk_check_button_new_with_mnemonic (_("Preserve folder structure"));
gtk_widget_show (preserve_folders);
gtk_box_pack_start (GTK_BOX (vbox26), preserve_folders, FALSE, FALSE, 0);
bypass_same_format = gtk_check_button_new_with_mnemonic (_("Copy if the format is not changing"));
gtk_widget_show (bypass_same_format);
gtk_box_pack_start (GTK_BOX (vbox26), bypass_same_format, FALSE, FALSE, 0);
retag_after_copy = gtk_check_button_new_with_mnemonic (_("Re-tag after copy"));
gtk_widget_show (retag_after_copy);
gtk_box_pack_start (GTK_BOX (vbox26), retag_after_copy, FALSE, FALSE, 0);
hbox100 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox100);
gtk_box_pack_start (GTK_BOX (vbox26), hbox100, FALSE, TRUE, 0);
label122 = gtk_label_new (_("Output file name:"));
gtk_widget_show (label122);
gtk_box_pack_start (GTK_BOX (hbox100), label122, FALSE, FALSE, 0);
hbox101 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox101);
gtk_box_pack_start (GTK_BOX (hbox100), hbox101, TRUE, TRUE, 0);
output_file = gtk_entry_new ();
gtk_widget_show (output_file);
gtk_box_pack_start (GTK_BOX (hbox101), output_file, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text (output_file, _("Extension (e.g. .mp3) will be appended automatically.\nLeave the field empty for default (%artist% - %title%)."));
gtk_entry_set_invisible_char (GTK_ENTRY (output_file), 8226);
custom6 = title_formatting_help_link_create ("custom6", "", "", 0, 0);
gtk_widget_show (custom6);
gtk_box_pack_start (GTK_BOX (hbox101), custom6, TRUE, TRUE, 0);
gtk_widget_set_can_focus(custom6, FALSE);
gtk_widget_set_can_default(custom6, FALSE);
hbox69 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox69);
gtk_box_pack_start (GTK_BOX (vbox26), hbox69, FALSE, TRUE, 0);
label104 = gtk_label_new (_("Encoder:"));
gtk_widget_show (label104);
gtk_box_pack_start (GTK_BOX (hbox69), label104, FALSE, FALSE, 0);
hbox90 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox90);
gtk_box_pack_start (GTK_BOX (hbox69), hbox90, TRUE, TRUE, 0);
encoder = gtk_combo_box_text_new ();
gtk_widget_show (encoder);
gtk_box_pack_start (GTK_BOX (hbox90), encoder, TRUE, TRUE, 0);
edit_encoder_presets = gtk_button_new ();
gtk_widget_show (edit_encoder_presets);
gtk_box_pack_start (GTK_BOX (hbox90), edit_encoder_presets, FALSE, FALSE, 0);
image469 = gtk_image_new_from_stock ("gtk-edit", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image469);
gtk_container_add (GTK_CONTAINER (edit_encoder_presets), image469);
hbox86 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox86);
gtk_box_pack_start (GTK_BOX (vbox26), hbox86, FALSE, TRUE, 0);
label114 = gtk_label_new (_("DSP preset:"));
gtk_widget_show (label114);
gtk_box_pack_start (GTK_BOX (hbox86), label114, FALSE, FALSE, 0);
hbox91 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox91);
gtk_box_pack_start (GTK_BOX (hbox86), hbox91, TRUE, TRUE, 0);
dsp_preset = gtk_combo_box_text_new ();
gtk_widget_show (dsp_preset);
gtk_box_pack_start (GTK_BOX (hbox91), dsp_preset, TRUE, TRUE, 0);
edit_dsp_presets = gtk_button_new ();
gtk_widget_show (edit_dsp_presets);
gtk_box_pack_start (GTK_BOX (hbox91), edit_dsp_presets, FALSE, FALSE, 0);
image470 = gtk_image_new_from_stock ("gtk-edit", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image470);
gtk_container_add (GTK_CONTAINER (edit_dsp_presets), image470);
hbox88 = gtk_hbox_new (FALSE, 8);
gtk_box_pack_start (GTK_BOX (vbox26), hbox88, FALSE, TRUE, 0);
label116 = gtk_label_new (_("Number of threads:"));
gtk_widget_show (label116);
gtk_box_pack_start (GTK_BOX (hbox88), label116, FALSE, FALSE, 0);
numthreads_adj = G_OBJECT(gtk_adjustment_new (1, 0, 100, 1, 10, 0));
numthreads = gtk_spin_button_new (GTK_ADJUSTMENT (numthreads_adj), 1, 0);
gtk_widget_show (numthreads);
gtk_box_pack_start (GTK_BOX (hbox88), numthreads, TRUE, TRUE, 0);
hbox89 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox89);
gtk_box_pack_start (GTK_BOX (vbox26), hbox89, FALSE, TRUE, 0);
label117 = gtk_label_new (_("Output sample format:"));
gtk_widget_show (label117);
gtk_box_pack_start (GTK_BOX (hbox89), label117, FALSE, FALSE, 0);
output_format = gtk_combo_box_text_new ();
gtk_widget_show (output_format);
gtk_box_pack_start (GTK_BOX (hbox89), output_format, TRUE, TRUE, 0);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("Keep source format"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("8 bit signed int"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("16 bit signed int"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("24 bit signed int"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("32 bit signed int"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (output_format), _("32 bit float"));
hbox99 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox99);
gtk_box_pack_start (GTK_BOX (vbox26), hbox99, FALSE, TRUE, 0);
label121 = gtk_label_new (_("When file exists:"));
gtk_widget_show (label121);
gtk_box_pack_start (GTK_BOX (hbox99), label121, FALSE, FALSE, 0);
overwrite_action = gtk_combo_box_text_new ();
gtk_widget_show (overwrite_action);
gtk_box_pack_start (GTK_BOX (hbox99), overwrite_action, TRUE, TRUE, 0);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Skip"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Prompt"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (overwrite_action), _("Overwrite"));
scrolledwindow9 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow9);
gtk_box_pack_start (GTK_BOX (hbox105), scrolledwindow9, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow9), 12);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_SHADOW_IN);
preview_tree = gtk_tree_view_new ();
gtk_widget_show (preview_tree);
gtk_container_add (GTK_CONTAINER (scrolledwindow9), preview_tree);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (preview_tree), TRUE);
dialog_action_area5 = gtk_dialog_get_action_area (GTK_DIALOG (converterdlg));
gtk_widget_show (dialog_action_area5);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area5), GTK_BUTTONBOX_END);
converter_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (converter_cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (converterdlg), converter_cancel, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default(converter_cancel, TRUE);
converter_ok = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (converter_ok);
gtk_dialog_add_action_widget (GTK_DIALOG (converterdlg), converter_ok, GTK_RESPONSE_OK);
gtk_widget_set_can_default(converter_ok, TRUE);
g_signal_connect ((gpointer) output_folder, "changed",
G_CALLBACK (on_output_folder_changed),
NULL);
g_signal_connect ((gpointer) converter_output_browse, "clicked",
G_CALLBACK (on_converter_output_browse_clicked),
NULL);
g_signal_connect ((gpointer) preserve_folders, "toggled",
G_CALLBACK (on_preserve_folders_toggled),
NULL);
g_signal_connect ((gpointer) bypass_same_format, "toggled",
G_CALLBACK (on_bypass_same_format_toggled),
NULL);
g_signal_connect ((gpointer) retag_after_copy, "toggled",
G_CALLBACK (on_retag_after_copy_toggled),
NULL);
g_signal_connect ((gpointer) encoder, "changed",
G_CALLBACK (on_converter_encoder_changed),
NULL);
g_signal_connect ((gpointer) edit_encoder_presets, "clicked",
G_CALLBACK (on_edit_encoder_presets_clicked),
NULL);
g_signal_connect ((gpointer) dsp_preset, "changed",
G_CALLBACK (on_converter_dsp_preset_changed),
NULL);
g_signal_connect ((gpointer) edit_dsp_presets, "clicked",
G_CALLBACK (on_edit_dsp_presets_clicked),
NULL);
g_signal_connect ((gpointer) numthreads, "changed",
G_CALLBACK (on_numthreads_changed),
NULL);
g_signal_connect ((gpointer) output_format, "changed",
G_CALLBACK (on_converter_output_format_changed),
NULL);
g_signal_connect ((gpointer) overwrite_action, "changed",
G_CALLBACK (on_overwrite_action_changed),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, converterdlg, "converterdlg");
GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, dialog_vbox6, "dialog_vbox6");
GLADE_HOOKUP_OBJECT (converterdlg, hbox105, "hbox105");
GLADE_HOOKUP_OBJECT (converterdlg, vbox26, "vbox26");
GLADE_HOOKUP_OBJECT (converterdlg, hbox67, "hbox67");
GLADE_HOOKUP_OBJECT (converterdlg, label103, "label103");
GLADE_HOOKUP_OBJECT (converterdlg, hbox68, "hbox68");
GLADE_HOOKUP_OBJECT (converterdlg, output_folder, "output_folder");
GLADE_HOOKUP_OBJECT (converterdlg, converter_output_browse, "converter_output_browse");
GLADE_HOOKUP_OBJECT (converterdlg, write_to_source_folder, "write_to_source_folder");
GLADE_HOOKUP_OBJECT (converterdlg, preserve_folders, "preserve_folders");
GLADE_HOOKUP_OBJECT (converterdlg, bypass_same_format, "bypass_same_format");
GLADE_HOOKUP_OBJECT (converterdlg, retag_after_copy, "retag_after_copy");
GLADE_HOOKUP_OBJECT (converterdlg, hbox100, "hbox100");
GLADE_HOOKUP_OBJECT (converterdlg, label122, "label122");
GLADE_HOOKUP_OBJECT (converterdlg, hbox101, "hbox101");
GLADE_HOOKUP_OBJECT (converterdlg, output_file, "output_file");
GLADE_HOOKUP_OBJECT (converterdlg, custom6, "custom6");
GLADE_HOOKUP_OBJECT (converterdlg, hbox69, "hbox69");
GLADE_HOOKUP_OBJECT (converterdlg, label104, "label104");
GLADE_HOOKUP_OBJECT (converterdlg, hbox90, "hbox90");
GLADE_HOOKUP_OBJECT (converterdlg, encoder, "encoder");
GLADE_HOOKUP_OBJECT (converterdlg, edit_encoder_presets, "edit_encoder_presets");
GLADE_HOOKUP_OBJECT (converterdlg, image469, "image469");
GLADE_HOOKUP_OBJECT (converterdlg, hbox86, "hbox86");
GLADE_HOOKUP_OBJECT (converterdlg, label114, "label114");
GLADE_HOOKUP_OBJECT (converterdlg, hbox91, "hbox91");
GLADE_HOOKUP_OBJECT (converterdlg, dsp_preset, "dsp_preset");
GLADE_HOOKUP_OBJECT (converterdlg, edit_dsp_presets, "edit_dsp_presets");
GLADE_HOOKUP_OBJECT (converterdlg, image470, "image470");
GLADE_HOOKUP_OBJECT (converterdlg, hbox88, "hbox88");
GLADE_HOOKUP_OBJECT (converterdlg, label116, "label116");
GLADE_HOOKUP_OBJECT (converterdlg, numthreads, "numthreads");
GLADE_HOOKUP_OBJECT (converterdlg, hbox89, "hbox89");
GLADE_HOOKUP_OBJECT (converterdlg, label117, "label117");
GLADE_HOOKUP_OBJECT (converterdlg, output_format, "output_format");
GLADE_HOOKUP_OBJECT (converterdlg, hbox99, "hbox99");
GLADE_HOOKUP_OBJECT (converterdlg, label121, "label121");
GLADE_HOOKUP_OBJECT (converterdlg, overwrite_action, "overwrite_action");
GLADE_HOOKUP_OBJECT (converterdlg, scrolledwindow9, "scrolledwindow9");
GLADE_HOOKUP_OBJECT (converterdlg, preview_tree, "preview_tree");
GLADE_HOOKUP_OBJECT_NO_REF (converterdlg, dialog_action_area5, "dialog_action_area5");
GLADE_HOOKUP_OBJECT (converterdlg, converter_cancel, "converter_cancel");
GLADE_HOOKUP_OBJECT (converterdlg, converter_ok, "converter_ok");
return converterdlg;
}
EXPORT void audgui_playlist_manager (void)
{
GtkWidget * playman_vbox;
GtkWidget * playman_pl_lv, * playman_pl_lv_sw;
GtkWidget * playman_button_hbox;
GtkWidget * new_button, * delete_button, * rename_button, * play_button;
GtkWidget * hbox, * check_button;
GdkGeometry playman_win_hints;
if (playman_win)
{
gtk_window_present ((GtkWindow *) playman_win);
return;
}
playman_win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint ((GtkWindow *) playman_win, GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title ((GtkWindow *) playman_win, _("Playlist Manager"));
gtk_container_set_border_width ((GtkContainer *) playman_win, 6);
playman_win_hints.min_width = 400;
playman_win_hints.min_height = 250;
gtk_window_set_geometry_hints ((GtkWindow *) playman_win, playman_win,
&playman_win_hints , GDK_HINT_MIN_SIZE);
int x = aud_get_int ("audgui", "playlist_manager_x");
int y = aud_get_int ("audgui", "playlist_manager_y");
int w = aud_get_int ("audgui", "playlist_manager_w");
int h = aud_get_int ("audgui", "playlist_manager_h");
if (w && h)
{
gtk_window_move ((GtkWindow *) playman_win, x, y);
gtk_window_set_default_size ((GtkWindow *) playman_win, w, h);
}
g_signal_connect (playman_win, "delete-event", (GCallback) hide_cb, NULL);
audgui_hide_on_escape (playman_win);
playman_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add ((GtkContainer *) playman_win, playman_vbox);
/* ListView */
playman_pl_lv = audgui_list_new (& callbacks, NULL, aud_playlist_count ());
audgui_list_add_column (playman_pl_lv, _("Title"), 0, G_TYPE_STRING, -1);
audgui_list_add_column (playman_pl_lv, _("Entries"), 1, G_TYPE_INT, 7);
audgui_list_set_highlight (playman_pl_lv, aud_playlist_get_playing ());
gtk_tree_view_set_search_equal_func ((GtkTreeView *) playman_pl_lv,
search_cb, NULL, NULL);
hook_associate ("playlist update", update_hook, playman_pl_lv);
hook_associate ("playlist activate", activate_hook, playman_pl_lv);
hook_associate ("playlist set playing", position_hook, playman_pl_lv);
playman_pl_lv_sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) playman_pl_lv_sw,
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) playman_pl_lv_sw,
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add ((GtkContainer *) playman_pl_lv_sw, playman_pl_lv);
gtk_box_pack_start ((GtkBox *) playman_vbox, playman_pl_lv_sw, TRUE, TRUE, 0);
/* ButtonBox */
playman_button_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
new_button = gtk_button_new_from_stock (GTK_STOCK_NEW);
delete_button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
rename_button = gtk_button_new_with_mnemonic (_("_Rename"));
gtk_button_set_image ((GtkButton *) rename_button, gtk_image_new_from_stock
(GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON));
play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
gtk_container_add ((GtkContainer *) playman_button_hbox, new_button);
gtk_container_add ((GtkContainer *) playman_button_hbox, delete_button);
gtk_box_pack_end ((GtkBox *) playman_button_hbox, play_button, FALSE, FALSE, 0);
gtk_box_pack_end ((GtkBox *) playman_button_hbox, rename_button, FALSE, FALSE, 0);
gtk_container_add ((GtkContainer *) playman_vbox, playman_button_hbox);
g_signal_connect (new_button, "clicked", (GCallback) new_cb, NULL);
g_signal_connect (delete_button, "clicked", (GCallback) delete_cb, NULL);
g_signal_connect (rename_button, "clicked", (GCallback) rename_cb, NULL);
g_signal_connect (play_button, "clicked", (GCallback) play_cb, NULL);
/* CheckButton */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start ((GtkBox *) playman_vbox, hbox, FALSE, FALSE, 0);
check_button = gtk_check_button_new_with_mnemonic
(_("_Close dialog on activating playlist"));
gtk_box_pack_start ((GtkBox *) hbox, check_button, FALSE, FALSE, 0);
gtk_toggle_button_set_active ((GtkToggleButton *) check_button, aud_get_bool
("audgui", "playlist_manager_close_on_activate"));
g_signal_connect (check_button, "toggled", (GCallback) close_on_activate_cb, NULL);
gtk_widget_show_all (playman_win);
hook_associate ("config save", save_config_cb, playman_win);
}
void configure_program_dialog(GtkWidget *widget, gpointer user_data) {
/** Program configuration dailog window. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *configure_dialog = gtk_dialog_new() ;
gtk_window_set_icon_from_file(GTK_WINDOW(configure_dialog), PATH_TO_PRG_WIN_ICON, NULL) ;
gtk_window_set_title(GTK_WINDOW(configure_dialog), "Configure program") ;
gtk_window_set_position(GTK_WINDOW(configure_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_window_set_resizable(GTK_WINDOW(configure_dialog), FALSE);
gtk_widget_set_size_request(configure_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(configure_dialog), FALSE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(configure_dialog), TRUE) ;
gtk_window_set_decorated(GTK_WINDOW(configure_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(configure_dialog), GDK_WINDOW_TYPE_HINT_NORMAL) ;
gtk_window_set_transient_for(GTK_WINDOW(configure_dialog), GTK_WINDOW(gui->window)) ;
gtk_container_set_border_width(GTK_CONTAINER(configure_dialog), 12) ;
#define DIALOG_DEFAULT_SPACE 12
/** ***** [START] Icon set choice [START] ***** **/
GtkWidget *icon_set_choice_frame = gtk_frame_new(" Icon set ") ;
GtkWidget *icon_set_choice_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_box_set_spacing(GTK_BOX(icon_set_choice_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_box_set_homogeneous(GTK_BOX(icon_set_choice_hbox), TRUE) ;
GtkWidget *radiobutton_icons_high_contrast = gtk_radio_button_new_with_label(NULL, " HighContrast") ;
GtkWidget *image_icons_high_contrast ;
GtkWidget *radiobutton_icons_oxygen = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_icons_high_contrast)), " Oxygen") ;
GtkWidget *image_icons_oxygen ;
gtk_widget_set_tooltip_markup(radiobutton_icons_high_contrast, "Set the <b>HighContrast</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(radiobutton_icons_oxygen, "Set the <b>Oxygen</b> theme icon set.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), FALSE) ;
if (settings.icon_set_oxygen) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_oxygen), TRUE) ;
image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-angry.png") ;
image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-smile-big.png") ;
}
else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_icons_high_contrast), TRUE) ;
image_icons_high_contrast = gtk_image_new_from_file( PATH_TO_HIGH_CONTRAST_BUTTON_ICONS "face-smile-big.png") ;
image_icons_oxygen = gtk_image_new_from_file( PATH_TO_OXYGEN_BUTTON_ICONS "face-angry.png") ;
}
gtk_button_set_image(GTK_BUTTON(radiobutton_icons_high_contrast), image_icons_high_contrast) ;
gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_high_contrast), TRUE) ;
gtk_button_set_image(GTK_BUTTON(radiobutton_icons_oxygen), image_icons_oxygen) ;
gtk_button_set_always_show_image(GTK_BUTTON(radiobutton_icons_oxygen), TRUE) ;
gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_high_contrast, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(icon_set_choice_hbox), radiobutton_icons_oxygen, TRUE, TRUE, 0) ;
gtk_container_add(GTK_CONTAINER(icon_set_choice_frame), icon_set_choice_hbox) ;
/** ***** [END] Icon set choice [END] ***** **/
/** ***** [START] Playing settings [START] ***** **/
GtkWidget *playing_settings_frame = gtk_frame_new(" Player settings ") ;
GtkWidget *playing_settings_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(playing_settings_vbox), DIALOG_DEFAULT_SPACE) ;
GtkWidget *playing_settings_repeat_all = gtk_check_button_new_with_label(" Repeat all mode. ") ;
gtk_widget_set_tooltip_markup(playing_settings_repeat_all, "Enable the <b>repeat all</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all), is_repeat_all) ;
GtkWidget *playing_settings_shuffle = gtk_check_button_new_with_label(" Shuffle mode. ") ;
gtk_widget_set_tooltip_markup(playing_settings_shuffle, "Enable the <b>shuffle</b> feature.\nThis will update the player settings.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle), is_shuffle ) ;
GtkWidget *playing_settings_volume_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
GtkWidget *playing_settings_volume_label_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
GtkWidget *playing_settings_volume_image = gtk_image_new_from_file( (settings.path_to_button_icons + "audio-volume-medium.png").c_str() ) ;
GtkWidget *playing_settings_volume_label = gtk_label_new(" Default Volume:") ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_image, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_label_hbox), playing_settings_volume_label, FALSE, FALSE, 0) ;
GtkWidget *playing_settings_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0.0, 100.0, 1.0) ;
gtk_widget_set_tooltip_markup(playing_settings_volume_scale, "Set the <b>default player volume</b> at start.\nThis will <b>not</b> update the player settings.\nYou must press the <b>Apply</b> button to store your configuration.") ;
gtk_range_set_value(GTK_RANGE(playing_settings_volume_scale), settings.volume) ;
gtk_scale_set_draw_value(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
gtk_scale_set_has_origin(GTK_SCALE(playing_settings_volume_scale), TRUE) ;
gtk_scale_set_value_pos(GTK_SCALE(playing_settings_volume_scale), GTK_POS_TOP) ;
gtk_scale_add_mark(GTK_SCALE(playing_settings_volume_scale), 50.0, GTK_POS_TOP, NULL) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_label_hbox, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_volume_hbox), playing_settings_volume_scale, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_repeat_all, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_shuffle, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(playing_settings_vbox), playing_settings_volume_hbox, FALSE, FALSE, 0) ;
gtk_container_add(GTK_CONTAINER(playing_settings_frame), playing_settings_vbox) ;
/** ***** [END] Playing settings [END] ***** **/
/** ***** [START] Interface size setting [START] ***** **/
GtkWidget *interface_size_frame = gtk_frame_new(" Interface size ") ;
GtkWidget *interface_size_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;
GtkWidget *interface_size_radiobutton_little = gtk_radio_button_new_with_label(NULL, " Little") ;
GtkWidget *interface_size_radiobutton_middle = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Medium") ;
GtkWidget *interface_size_radiobutton_big = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(interface_size_radiobutton_little)), " Big ") ;
GtkWidget *interface_size_little_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-little.png").c_str() ) ;
GtkWidget *interface_size_middle_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-middle.png").c_str() ) ;
GtkWidget *interface_size_big_image = gtk_image_new_from_file((settings.path_to_button_icons + "interface-big.png").c_str() ) ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_little, "Set the <b>interface size</b> on <b>little</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_middle, "Set the <b>interface size</b> on <b>middle</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_widget_set_tooltip_markup(interface_size_radiobutton_big, "Set the <b>interface size</b> on <b>big</b>.\nThis will update the interface.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_little), interface_size_little_image) ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_middle), interface_size_middle_image) ;
gtk_button_set_image(GTK_BUTTON(interface_size_radiobutton_big), interface_size_big_image ) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_little), TRUE) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_middle), TRUE) ;
gtk_button_set_always_show_image(GTK_BUTTON(interface_size_radiobutton_big), TRUE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), FALSE) ;
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), FALSE) ;
switch (settings.image_resized_size) {
case IMAGE_RESIZED_SIZE_LITTLE :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_little), TRUE) ;
break ;
case IMAGE_RESIZED_SIZE_MIDDLE :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_middle), TRUE) ;
break ;
case IMAGE_RESIZED_SIZE_BIG :
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(interface_size_radiobutton_big), TRUE) ;
break ;
default :
break ;
}
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_little, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_middle, TRUE, TRUE, 0) ;
gtk_box_pack_start(GTK_BOX(interface_size_hbox), interface_size_radiobutton_big, TRUE, TRUE, 0) ;
gtk_box_set_homogeneous(GTK_BOX(interface_size_hbox), TRUE) ;
gtk_box_set_spacing(GTK_BOX(interface_size_hbox), DIALOG_DEFAULT_SPACE) ;
gtk_container_add(GTK_CONTAINER(interface_size_frame), interface_size_hbox) ;
/** ***** [END] Interface size setting [END] ***** **/
/** ***** [START] Music folder setting [START] ***** **/
GtkWidget *folder_selecting_frame = gtk_frame_new(" Music folder ") ;
GtkWidget *folder_selecting_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0) ;
gtk_container_set_border_width(GTK_CONTAINER(folder_selecting_box), DIALOG_DEFAULT_SPACE) ;
GtkWidget *folder_selecting_button = gtk_file_chooser_button_new("Set the Music folder to open per default.", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ;
gtk_widget_set_tooltip_markup(folder_selecting_button, "Set the folder to open per default: your <b>default music folder</b>.\n<i>The default folder from the folder selector</i>.\nSet it simply to your <b>Music folder</b>.\nChanges are immediatly applied.\nBut you must press the <b>Apply</b> button to store your configuration.") ;
gtk_file_chooser_button_set_title(GTK_FILE_CHOOSER_BUTTON(folder_selecting_button), "Set the Music folder to open per default.") ;
const char *user_music_folder = g_get_user_special_dir(G_USER_DIRECTORY_MUSIC) ;
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_selecting_button), (g_file_test(settings.path_to_music_folder.c_str(), G_FILE_TEST_IS_DIR)) ? settings.path_to_music_folder.c_str() : (user_music_folder != NULL) ? user_music_folder : g_get_home_dir() ) ;
gtk_box_pack_start(GTK_BOX(folder_selecting_box), folder_selecting_button, TRUE, TRUE, 0) ;
gtk_container_add(GTK_CONTAINER(folder_selecting_frame), folder_selecting_box) ;
/** ***** [END] Music folder setting [END] ***** **/
/** ***** [START] Dialog main content box [START] ***** **/
GtkWidget *content_area = gtk_dialog_get_content_area( GTK_DIALOG(configure_dialog) ) ;
gtk_box_pack_start(GTK_BOX(content_area), icon_set_choice_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), playing_settings_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), interface_size_frame, FALSE, FALSE, 0) ;
gtk_box_pack_start(GTK_BOX(content_area), folder_selecting_frame, FALSE, FALSE, 0) ;
gtk_box_set_spacing(GTK_BOX(content_area), DIALOG_DEFAULT_SPACE) ;
/** ***** [END] Dialog main content box [END] ***** **/
/** ***** [START] Dialog action buttons [START] ***** **/
GtkWidget *button_close = gtk_button_new_with_label("Close") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Cancel", GTK_RESPONSE_CANCEL) ;
GtkWidget *image_close = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-close.png").c_str()) ;
gtk_widget_set_tooltip_markup(button_close, "<b>Close</b> the configuration window and don't store any setting.") ;
gtk_button_set_image(GTK_BUTTON(button_close), image_close) ;
gtk_button_set_always_show_image(GTK_BUTTON(button_close), TRUE) ;
GtkWidget *button_ok = gtk_button_new_with_label("Apply") ; // gtk_dialog_add_button(GTK_DIALOG(configure_dialog), "Apply", GTK_RESPONSE_APPLY) ;
GtkWidget *image_ok = gtk_image_new_from_file((settings.path_to_button_icons + "dialog-ok.png").c_str()) ;
gtk_widget_set_tooltip_markup(button_ok, "<b>Register</b> all the settings as <i>your default configuration</i> at start.") ;
gtk_button_set_image(GTK_BUTTON(button_ok), image_ok) ;
gtk_button_set_always_show_image(GTK_BUTTON(button_ok), TRUE) ;
gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_close, GTK_RESPONSE_CLOSE) ;
gtk_dialog_add_action_widget(GTK_DIALOG(configure_dialog), button_ok, GTK_RESPONSE_APPLY) ;
GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(configure_dialog)) ;
gtk_container_set_border_width(GTK_CONTAINER(action_area), 0) ;
gtk_button_box_set_layout(GTK_BUTTON_BOX(action_area), GTK_BUTTONBOX_EDGE) ;
/** ***** [END] Dialog action buttons [END] ***** **/
Radio_Config high_contrast_radiobutton ;
high_contrast_radiobutton.button = radiobutton_icons_high_contrast ;
high_contrast_radiobutton.image = image_icons_high_contrast ;
high_contrast_radiobutton.volume = playing_settings_volume_image ;
high_contrast_radiobutton.cancel = image_close ;
high_contrast_radiobutton.apply = image_ok ;
high_contrast_radiobutton.little = interface_size_little_image ;
high_contrast_radiobutton.middle = interface_size_middle_image ;
high_contrast_radiobutton.big = interface_size_big_image ;
Radio_Config oxygen_radiobutton ;
oxygen_radiobutton.button = radiobutton_icons_oxygen ;
oxygen_radiobutton.image = image_icons_oxygen ;
oxygen_radiobutton.volume = playing_settings_volume_image ;
oxygen_radiobutton.cancel = image_close ;
oxygen_radiobutton.apply = image_ok ;
oxygen_radiobutton.little = interface_size_little_image ;
oxygen_radiobutton.middle = interface_size_middle_image ;
oxygen_radiobutton.big = interface_size_big_image ;
g_signal_connect(G_OBJECT(radiobutton_icons_high_contrast), "clicked", G_CALLBACK(configure_high_contrast_radiobutton), &high_contrast_radiobutton) ;
g_signal_connect(G_OBJECT(radiobutton_icons_oxygen), "clicked", G_CALLBACK(configure_oxygen_radiobutton), &oxygen_radiobutton ) ;
int little = -1 ;
int middle = 0 ;
int big = 1 ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_little), "clicked", G_CALLBACK(reconfigure_interface_size), &little) ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_middle), "clicked", G_CALLBACK(reconfigure_interface_size), &middle) ;
g_signal_connect(G_OBJECT(interface_size_radiobutton_big), "clicked", G_CALLBACK(reconfigure_interface_size), &big) ;
g_signal_connect(G_OBJECT(playing_settings_repeat_all), "toggled", G_CALLBACK(repeat_all_feature_set), NULL) ;
g_signal_connect(G_OBJECT(playing_settings_shuffle), "toggled", G_CALLBACK(shuffle_feature_set), NULL) ;
g_signal_connect(G_OBJECT(playing_settings_volume_scale), "value-changed", G_CALLBACK(get_volume), NULL) ;
g_signal_connect(G_OBJECT(folder_selecting_button), "file-set", G_CALLBACK(set_default_folder), NULL) ;
gtk_widget_show_all(configure_dialog) ;
int response = gtk_dialog_run(GTK_DIALOG(configure_dialog)) ;
switch (response) {
case GTK_RESPONSE_APPLY :
{
GKeyFile *conf_file = g_key_file_new() ;
GError *error = NULL ;
settings.is_repeat_all = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_repeat_all)) ;
settings.is_shuffle = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(playing_settings_shuffle)) ;
// Set configuration settings to configuration file buffer.
g_key_file_set_string(conf_file, "Config", "Buttons_Icons_Path", settings.path_to_button_icons.c_str()) ;
g_key_file_set_string(conf_file, "Config", "Menu_Icons_Path", settings.path_to_menu_icons.c_str()) ;
g_key_file_set_string(conf_file, "Config", "Music_Folder", settings.path_to_music_folder.c_str()) ;
g_key_file_set_boolean(conf_file, "Config", "Is_Oxygen", settings.icon_set_oxygen) ;
g_key_file_set_boolean(conf_file, "Config", "Repeat_all", settings.is_repeat_all) ;
g_key_file_set_boolean(conf_file, "Config", "Shuffle", settings.is_shuffle) ;
g_key_file_set_double(conf_file, "Config", "Volume", settings.volume) ;
g_key_file_set_uint64(conf_file, "Config", "Buttons_space", settings.space_buttons) ;
g_key_file_set_uint64(conf_file, "Config", "Display_Size", settings.display_size) ;
g_key_file_set_uint64(conf_file, "Config", "Image_Resizing", settings.image_resized_size) ;
g_key_file_set_string(conf_file, "Config", "Sized_Default_Image", settings.path_to_default_image.c_str()) ;
// Write to configuration file
g_key_file_save_to_file(conf_file, PATH_TO_CONF_FILE, &error);
// Setting global variables.
cover_image = settings.path_to_default_image ;
current_folder = settings.path_to_music_folder ;
if ( error != NULL ) {
display_message_dialog("Error store configuration !", "Cannot store the configuration.") ;
#ifdef DEBUG
fprintf(stdout,"\n%s: Error store configuratiom settings.\n", prgname.c_str() ) ; fflush(stdout) ;
#endif
}
else { // Success
#ifdef DEBUG
fprintf(stdout,"\n%s: Success store configuratiom settings.\n", prgname.c_str() ) ;
#endif
}
}
break ;
case GTK_RESPONSE_CLOSE :
// Do nothing.
break ;
}
gtk_widget_destroy(configure_dialog) ;
return ;
}
void get_files_to_play(GtkWidget *widget, gpointer user_data) {
/** User single file selection. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *file_chooser_dialog = gtk_file_chooser_dialog_new("Choose music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser_dialog), current_folder.c_str() ) ;
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ;
gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ;
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ;
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ;
GtkFileFilter *file_filter = gtk_file_filter_new() ;
for (int c=0 ; c < static_cast<int>(extension_list.size()) ; c++) {
gtk_file_filter_add_pattern(GTK_FILE_FILTER(file_filter), extension_list.at(c).c_str()) ;
}
gtk_file_filter_set_name(GTK_FILE_FILTER(file_filter), "Supported music filetypes") ;
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser_dialog), GTK_FILE_FILTER(file_filter)) ;
gtk_window_set_position(GTK_WINDOW(file_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_widget_set_size_request(file_chooser_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(file_chooser_dialog), TRUE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(file_chooser_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(file_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
gtk_window_set_transient_for(GTK_WINDOW(file_chooser_dialog), GTK_WINDOW(gui->window)) ;
GSList *filepath_list = NULL ;
gint result = gtk_dialog_run (GTK_DIALOG (file_chooser_dialog));
switch (result) {
case GTK_RESPONSE_CANCEL :
gtk_widget_destroy(file_chooser_dialog);
return ;
case GTK_RESPONSE_ACCEPT :
filepath_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser_dialog)) ;
gtk_widget_destroy(file_chooser_dialog) ;
break ;
}
if (filepath_list != NULL) {
gchar *file_dirname = g_path_get_dirname((const gchar *) g_slist_nth_data(filepath_list, 0)) ;
check_files(filepath_list) ;
current_folder = file_dirname ;
g_free(file_dirname) ;
#ifdef DEBUG
fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
#endif
g_slist_free(filepath_list) ;
}
}
void
create_driverchooser (HWND hwnd, TDRIVERCHOOSER *choose_t)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GtkWidget *driverchooser;
GtkWidget *dialog_vbox2;
GtkWidget *hbox25;
GtkWidget *frame37;
GtkWidget *alignment29;
GtkWidget *pixmap1;
GtkWidget *frame36;
GtkWidget *alignment28;
GtkWidget *scrolledwindow10;
GtkWidget *clist1;
GtkWidget *l_name;
GtkWidget *l_file;
GtkWidget *l_date;
GtkWidget *l_size;
GtkWidget *l_diz;
GtkWidget *dialog_action_area2;
GtkWidget *b_finish;
GtkWidget *b_cancel;
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return;
driverchooser = gtk_dialog_new ();
gtk_widget_set_name (driverchooser, "driverchooser");
gtk_widget_set_size_request (driverchooser, 515, 335);
gtk_window_set_title (GTK_WINDOW (driverchooser), _("Choose an ODBC Driver"));
gtk_window_set_position (GTK_WINDOW (driverchooser), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (driverchooser), TRUE);
gtk_window_set_default_size (GTK_WINDOW (driverchooser), 600, 450);
gtk_window_set_type_hint (GTK_WINDOW (driverchooser), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (driverchooser);
#endif
dialog_vbox2 = GTK_DIALOG (driverchooser)->vbox;
gtk_widget_set_name (dialog_vbox2, "dialog_vbox2");
gtk_widget_show (dialog_vbox2);
hbox25 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox25, "hbox25");
gtk_widget_show (hbox25);
gtk_box_pack_start (GTK_BOX (dialog_vbox2), hbox25, TRUE, TRUE, 0);
frame37 = gtk_frame_new (NULL);
gtk_widget_set_name (frame37, "frame37");
gtk_widget_show (frame37);
gtk_box_pack_start (GTK_BOX (hbox25), frame37, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame37), 10);
gtk_frame_set_shadow_type (GTK_FRAME (frame37), GTK_SHADOW_NONE);
alignment29 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment29, "alignment29");
gtk_widget_show (alignment29);
gtk_container_add (GTK_CONTAINER (frame37), alignment29);
gtk_widget_set_size_request (alignment29, 140, -1);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (driverchooser);
pixmap =
gdk_pixmap_create_from_xpm_d (driverchooser->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#else
style = gtk_widget_get_style (GTK_WIDGET (hwnd));
pixmap =
gdk_pixmap_create_from_xpm_d (GTK_WIDGET (hwnd)->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#endif
pixmap1 = gtk_pixmap_new (pixmap, mask);
gtk_widget_set_name (pixmap1, "pixmap1");
gtk_widget_show (pixmap1);
gtk_container_add (GTK_CONTAINER (alignment29), pixmap1);
frame36 = gtk_frame_new (NULL);
gtk_widget_set_name (frame36, "frame36");
gtk_widget_show (frame36);
gtk_box_pack_start (GTK_BOX (hbox25), frame36, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame36), GTK_SHADOW_NONE);
alignment28 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment28, "alignment28");
gtk_widget_show (alignment28);
gtk_container_add (GTK_CONTAINER (frame36), alignment28);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment28), 0, 10, 0, 0);
scrolledwindow10 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_name (scrolledwindow10, "scrolledwindow10");
gtk_widget_show (scrolledwindow10);
gtk_container_add (GTK_CONTAINER (alignment28), scrolledwindow10);
clist1 = gtk_clist_new (4);
gtk_widget_set_name (clist1, "clist1");
gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow10), clist1);
gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 165);
gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 118);
gtk_clist_set_column_width (GTK_CLIST (clist1), 2, 80);
gtk_clist_set_column_width (GTK_CLIST (clist1), 3, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist1));
l_name = gtk_label_new (_("Name"));
gtk_widget_set_name (l_name, "l_name");
gtk_widget_show (l_name);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, l_name);
gtk_widget_set_size_request (l_name, 165, -1);
l_file = gtk_label_new (_("File"));
gtk_widget_set_name (l_file, "l_file");
gtk_widget_show (l_file);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, l_file);
gtk_widget_set_size_request (l_file, 118, -1);
l_date = gtk_label_new (_("Date"));
gtk_widget_set_name (l_date, "l_date");
gtk_widget_show (l_date);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 2, l_date);
gtk_widget_set_size_request (l_date, 80, -1);
l_size = gtk_label_new (_("Size"));
gtk_widget_set_name (l_size, "l_size");
gtk_widget_show (l_size);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 3, l_size);
gtk_widget_set_size_request (l_size, 80, -1);
l_diz = gtk_label_new (_("Select a driver for which you want to setup a data source"));
gtk_widget_set_name (l_diz, "l_diz");
gtk_widget_show (l_diz);
gtk_frame_set_label_widget (GTK_FRAME (frame36), l_diz);
gtk_label_set_use_markup (GTK_LABEL (l_diz), TRUE);
dialog_action_area2 = GTK_DIALOG (driverchooser)->action_area;
gtk_widget_set_name (dialog_action_area2, "dialog_action_area2");
gtk_widget_show (dialog_action_area2);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area2), GTK_BUTTONBOX_END);
b_finish = gtk_button_new_with_mnemonic (_("_Finish"));
gtk_widget_set_name (b_finish, "b_finish");
gtk_widget_show (b_finish);
gtk_dialog_add_action_widget (GTK_DIALOG (driverchooser), b_finish, 0);
GTK_WIDGET_SET_FLAGS (b_finish, GTK_CAN_DEFAULT);
b_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (b_cancel, "b_cancel");
gtk_widget_show (b_cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (driverchooser), b_cancel, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (driverchooser, driverchooser, "driverchooser");
GLADE_HOOKUP_OBJECT_NO_REF (driverchooser, dialog_vbox2, "dialog_vbox2");
GLADE_HOOKUP_OBJECT (driverchooser, hbox25, "hbox25");
GLADE_HOOKUP_OBJECT (driverchooser, frame37, "frame37");
GLADE_HOOKUP_OBJECT (driverchooser, alignment29, "alignment29");
GLADE_HOOKUP_OBJECT (driverchooser, pixmap1, "pixmap1");
GLADE_HOOKUP_OBJECT (driverchooser, frame36, "frame36");
GLADE_HOOKUP_OBJECT (driverchooser, alignment28, "alignment28");
GLADE_HOOKUP_OBJECT (driverchooser, scrolledwindow10, "scrolledwindow10");
GLADE_HOOKUP_OBJECT (driverchooser, clist1, "clist1");
GLADE_HOOKUP_OBJECT (driverchooser, l_name, "l_name");
GLADE_HOOKUP_OBJECT (driverchooser, l_file, "l_file");
GLADE_HOOKUP_OBJECT (driverchooser, l_date, "l_date");
GLADE_HOOKUP_OBJECT (driverchooser, l_size, "l_size");
GLADE_HOOKUP_OBJECT (driverchooser, l_diz, "l_diz");
GLADE_HOOKUP_OBJECT_NO_REF (driverchooser, dialog_action_area2, "dialog_action_area2");
GLADE_HOOKUP_OBJECT (driverchooser, b_finish, "b_finish");
GLADE_HOOKUP_OBJECT (driverchooser, b_cancel, "b_cancel");
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_finish), "clicked",
GTK_SIGNAL_FUNC (driverchooser_ok_clicked), choose_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (driverchooser_cancel_clicked), choose_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (driverchooser), "delete_event",
GTK_SIGNAL_FUNC (delete_event), choose_t);
gtk_signal_connect (GTK_OBJECT (driverchooser), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* Driver list events */
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (driver_list_select), choose_t);
adddrivers_to_list (clist1, driverchooser);
choose_t->driverlist = clist1;
choose_t->driver = NULL;
choose_t->mainwnd = driverchooser;
choose_t->b_finish = b_finish;
gtk_widget_show_all (driverchooser);
gtk_main ();
}
GtkWidget*
create_select_dsp_plugin (void)
{
GtkWidget *select_dsp_plugin;
GtkWidget *dialog_vbox10;
GtkWidget *vbox31;
GtkWidget *hbox85;
GtkWidget *label113;
GtkWidget *plugin;
GtkWidget *dialog_action_area9;
GtkWidget *cancelbutton7;
GtkWidget *okbutton7;
select_dsp_plugin = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (select_dsp_plugin), _("Select DSP Plugin"));
gtk_window_set_modal (GTK_WINDOW (select_dsp_plugin), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (select_dsp_plugin), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox10 = gtk_dialog_get_content_area (GTK_DIALOG (select_dsp_plugin));
gtk_widget_show (dialog_vbox10);
vbox31 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox31);
gtk_box_pack_start (GTK_BOX (dialog_vbox10), vbox31, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox31), 12);
hbox85 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox85);
gtk_box_pack_start (GTK_BOX (vbox31), hbox85, FALSE, FALSE, 0);
label113 = gtk_label_new (_("Plugin"));
gtk_widget_show (label113);
gtk_box_pack_start (GTK_BOX (hbox85), label113, FALSE, FALSE, 0);
plugin = gtk_combo_box_text_new ();
gtk_widget_show (plugin);
gtk_box_pack_start (GTK_BOX (hbox85), plugin, TRUE, TRUE, 0);
gtk_widget_set_size_request (plugin, 232, -1);
dialog_action_area9 = gtk_dialog_get_action_area (GTK_DIALOG (select_dsp_plugin));
gtk_widget_show (dialog_action_area9);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area9), GTK_BUTTONBOX_END);
cancelbutton7 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton7);
gtk_dialog_add_action_widget (GTK_DIALOG (select_dsp_plugin), cancelbutton7, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default(cancelbutton7, TRUE);
okbutton7 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton7);
gtk_dialog_add_action_widget (GTK_DIALOG (select_dsp_plugin), okbutton7, GTK_RESPONSE_OK);
gtk_widget_set_can_default(okbutton7, TRUE);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (select_dsp_plugin, select_dsp_plugin, "select_dsp_plugin");
GLADE_HOOKUP_OBJECT_NO_REF (select_dsp_plugin, dialog_vbox10, "dialog_vbox10");
GLADE_HOOKUP_OBJECT (select_dsp_plugin, vbox31, "vbox31");
GLADE_HOOKUP_OBJECT (select_dsp_plugin, hbox85, "hbox85");
GLADE_HOOKUP_OBJECT (select_dsp_plugin, label113, "label113");
GLADE_HOOKUP_OBJECT (select_dsp_plugin, plugin, "plugin");
GLADE_HOOKUP_OBJECT_NO_REF (select_dsp_plugin, dialog_action_area9, "dialog_action_area9");
GLADE_HOOKUP_OBJECT (select_dsp_plugin, cancelbutton7, "cancelbutton7");
GLADE_HOOKUP_OBJECT (select_dsp_plugin, okbutton7, "okbutton7");
return select_dsp_plugin;
}
//??DONE
void
create_fdriverchooser (HWND hwnd, TFDRIVERCHOOSER *choose_t)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GtkWidget *fdriverchooser;
GtkWidget *dialog_vbox3;
GtkWidget *notebook2;
GtkWidget *hbox26;
GtkWidget *frame38;
GtkWidget *alignment30;
GtkWidget *pixmap1;
GtkWidget *vbox21;
GtkWidget *frame39;
GtkWidget *alignment31;
GtkWidget *scrolledwindow11;
GtkWidget *clist2;
GtkWidget *l_name;
GtkWidget *l_file;
GtkWidget *l_date;
GtkWidget *l_size;
GtkWidget *label70;
GtkWidget *hbox27;
GtkWidget *frame40;
GtkWidget *alignment32;
GtkWidget *b_advanced;
GtkWidget *label67;
GtkWidget *hbox28;
GtkWidget *frame41;
GtkWidget *alignment33;
GtkWidget *pixmap2;
GtkWidget *vbox22;
GtkWidget *frame42;
GtkWidget *alignment34;
GtkWidget *label79;
GtkWidget *frame43;
GtkWidget *alignment35;
GtkWidget *hbox30;
GtkWidget *fdsn_entry;
GtkWidget *b_browse;
GtkWidget *frame47;
GtkWidget *alignment39;
GtkWidget *label68;
GtkWidget *hbox29;
GtkWidget *frame44;
GtkWidget *alignment36;
GtkWidget *pixmap3;
GtkWidget *vbox23;
GtkWidget *frame45;
GtkWidget *alignment37;
GtkWidget *label80;
GtkWidget *frame46;
GtkWidget *alignment38;
GtkWidget *scrolledwindow13;
GtkWidget *result_text;
GtkWidget *label69;
GtkWidget *dialog_action_area3;
GtkWidget *b_cancel;
GtkWidget *b_back;
GtkWidget *b_continue;
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return;
fdriverchooser = gtk_dialog_new ();
gtk_widget_set_name (fdriverchooser, "fdriverchooser");
gtk_widget_set_size_request (fdriverchooser, 512, 384);
gtk_window_set_title (GTK_WINDOW (fdriverchooser), _("Create New File Data Source"));
gtk_window_set_modal (GTK_WINDOW (fdriverchooser), TRUE);
gtk_window_set_default_size (GTK_WINDOW (fdriverchooser), 600, 450);
gtk_window_set_position (GTK_WINDOW (fdriverchooser), GTK_WIN_POS_CENTER);
gtk_window_set_type_hint (GTK_WINDOW (fdriverchooser), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (fdriverchooser);
#endif
dialog_vbox3 = GTK_DIALOG (fdriverchooser)->vbox;
gtk_widget_set_name (dialog_vbox3, "dialog_vbox3");
gtk_widget_show (dialog_vbox3);
notebook2 = gtk_notebook_new ();
gtk_widget_set_name (notebook2, "notebook2");
gtk_widget_show (notebook2);
gtk_box_pack_start (GTK_BOX (dialog_vbox3), notebook2, TRUE, TRUE, 0);
hbox26 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox26, "hbox26");
gtk_widget_show (hbox26);
gtk_container_add (GTK_CONTAINER (notebook2), hbox26);
frame38 = gtk_frame_new (NULL);
gtk_widget_set_name (frame38, "frame38");
gtk_widget_show (frame38);
gtk_box_pack_start (GTK_BOX (hbox26), frame38, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame38), 10);
gtk_frame_set_shadow_type (GTK_FRAME (frame38), GTK_SHADOW_NONE);
alignment30 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment30, "alignment30");
gtk_widget_show (alignment30);
gtk_container_add (GTK_CONTAINER (frame38), alignment30);
gtk_widget_set_size_request (alignment30, 140, -1);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (fdriverchooser);
pixmap =
gdk_pixmap_create_from_xpm_d (fdriverchooser->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#else
style = gtk_widget_get_style (GTK_WIDGET (hwnd));
pixmap =
gdk_pixmap_create_from_xpm_d (GTK_WIDGET (hwnd)->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#endif
pixmap1 = gtk_pixmap_new (pixmap, mask);
gtk_widget_set_name (pixmap1, "pixmap1");
gtk_widget_show (pixmap1);
gtk_container_add (GTK_CONTAINER (alignment30), pixmap1);
vbox21 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox21, "vbox21");
gtk_widget_show (vbox21);
gtk_box_pack_start (GTK_BOX (hbox26), vbox21, TRUE, TRUE, 0);
frame39 = gtk_frame_new (NULL);
gtk_widget_set_name (frame39, "frame39");
gtk_widget_show (frame39);
gtk_box_pack_start (GTK_BOX (vbox21), frame39, TRUE, TRUE, 0);
gtk_widget_set_size_request (frame39, -1, 270);
gtk_frame_set_shadow_type (GTK_FRAME (frame39), GTK_SHADOW_NONE);
alignment31 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment31, "alignment31");
gtk_widget_show (alignment31);
gtk_container_add (GTK_CONTAINER (frame39), alignment31);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment31), 0, 0, 4, 0);
scrolledwindow11 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_name (scrolledwindow11, "scrolledwindow11");
gtk_widget_show (scrolledwindow11);
gtk_container_add (GTK_CONTAINER (alignment31), scrolledwindow11);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow11), GTK_SHADOW_IN);
clist2 = gtk_clist_new (4);
gtk_widget_set_name (clist2, "clist2");
gtk_widget_show (clist2);
gtk_container_add (GTK_CONTAINER (scrolledwindow11), clist2);
gtk_clist_set_column_width (GTK_CLIST (clist2), 0, 165);
gtk_clist_set_column_width (GTK_CLIST (clist2), 1, 118);
gtk_clist_set_column_width (GTK_CLIST (clist2), 2, 80);
gtk_clist_set_column_width (GTK_CLIST (clist2), 3, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist2));
l_name = gtk_label_new (_("Name"));
gtk_widget_set_name (l_name, "l_name");
gtk_widget_show (l_name);
gtk_clist_set_column_widget (GTK_CLIST (clist2), 0, l_name);
gtk_widget_set_size_request (l_name, 165, -1);
l_file = gtk_label_new (_("File"));
gtk_widget_set_name (l_file, "l_file");
gtk_widget_show (l_file);
gtk_clist_set_column_widget (GTK_CLIST (clist2), 1, l_file);
gtk_widget_set_size_request (l_file, 118, -1);
l_date = gtk_label_new (_("Date"));
gtk_widget_set_name (l_date, "l_date");
gtk_widget_show (l_date);
gtk_clist_set_column_widget (GTK_CLIST (clist2), 2, l_date);
gtk_widget_set_size_request (l_date, 80, -1);
l_size = gtk_label_new (_("Size"));
gtk_widget_set_name (l_size, "l_size");
gtk_widget_show (l_size);
gtk_clist_set_column_widget (GTK_CLIST (clist2), 3, l_size);
gtk_widget_set_size_request (l_size, 80, -1);
label70 = gtk_label_new (_("Select a driver for which you want to setup a data source"));
gtk_widget_set_name (label70, "label70");
gtk_widget_show (label70);
gtk_frame_set_label_widget (GTK_FRAME (frame39), label70);
gtk_label_set_use_markup (GTK_LABEL (label70), TRUE);
hbox27 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox27, "hbox27");
gtk_widget_show (hbox27);
gtk_box_pack_start (GTK_BOX (vbox21), hbox27, FALSE, TRUE, 0);
frame40 = gtk_frame_new (NULL);
gtk_widget_set_name (frame40, "frame40");
gtk_widget_show (frame40);
gtk_box_pack_start (GTK_BOX (hbox27), frame40, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame40), GTK_SHADOW_NONE);
alignment32 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment32, "alignment32");
gtk_widget_show (alignment32);
gtk_container_add (GTK_CONTAINER (frame40), alignment32);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment32), 0, 10, 0, 0);
b_advanced = gtk_button_new_with_mnemonic (_("_Advanced..."));
gtk_widget_set_name (b_advanced, "b_advanced");
gtk_widget_show (b_advanced);
gtk_box_pack_start (GTK_BOX (hbox27), b_advanced, FALSE, TRUE, 0);
gtk_widget_set_size_request (b_advanced, -1, 45);
gtk_container_set_border_width (GTK_CONTAINER (b_advanced), 8);
label67 = gtk_label_new (_(" Drivers "));
gtk_widget_set_name (label67, "label67");
gtk_widget_show (label67);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook2), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook2), 0), label67);
hbox28 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox28, "hbox28");
gtk_widget_show (hbox28);
gtk_container_add (GTK_CONTAINER (notebook2), hbox28);
frame41 = gtk_frame_new (NULL);
gtk_widget_set_name (frame41, "frame41");
gtk_widget_show (frame41);
gtk_box_pack_start (GTK_BOX (hbox28), frame41, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame41), 10);
gtk_frame_set_shadow_type (GTK_FRAME (frame41), GTK_SHADOW_NONE);
alignment33 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment33, "alignment33");
gtk_widget_show (alignment33);
gtk_container_add (GTK_CONTAINER (frame41), alignment33);
gtk_widget_set_size_request (alignment33, 140, -1);
pixmap2 = gtk_pixmap_new (pixmap, mask);
gtk_widget_set_name (pixmap2, "pixmap2");
gtk_widget_show (pixmap2);
gtk_container_add (GTK_CONTAINER (alignment33), pixmap2);
vbox22 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox22, "vbox22");
gtk_widget_show (vbox22);
gtk_box_pack_start (GTK_BOX (hbox28), vbox22, TRUE, TRUE, 0);
frame42 = gtk_frame_new (NULL);
gtk_widget_set_name (frame42, "frame42");
gtk_widget_show (frame42);
gtk_box_pack_start (GTK_BOX (vbox22), frame42, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame42), GTK_SHADOW_NONE);
alignment34 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment34, "alignment34");
gtk_widget_show (alignment34);
gtk_container_add (GTK_CONTAINER (frame42), alignment34);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment34), 0, 0, 4, 0);
label79 = gtk_label_new (_("Type the name of the data source you want to\nsave this connection to. Or, find the location to\nsave to by clicking Browse."));
gtk_widget_set_name (label79, "label79");
gtk_widget_show (label79);
gtk_container_add (GTK_CONTAINER (alignment34), label79);
frame43 = gtk_frame_new (NULL);
gtk_widget_set_name (frame43, "frame43");
gtk_widget_show (frame43);
gtk_box_pack_start (GTK_BOX (vbox22), frame43, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame43), GTK_SHADOW_NONE);
alignment35 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment35, "alignment35");
gtk_widget_show (alignment35);
gtk_container_add (GTK_CONTAINER (frame43), alignment35);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment35), 0, 0, 12, 0);
hbox30 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox30, "hbox30");
gtk_widget_show (hbox30);
gtk_container_add (GTK_CONTAINER (alignment35), hbox30);
fdsn_entry = gtk_entry_new ();
gtk_widget_set_name (fdsn_entry, "fdsn_entry");
gtk_widget_show (fdsn_entry);
gtk_box_pack_start (GTK_BOX (hbox30), fdsn_entry, TRUE, TRUE, 0);
b_browse = gtk_button_new_with_mnemonic (_(" Browse "));
gtk_widget_set_name (b_browse, "b_browse");
gtk_widget_show (b_browse);
gtk_box_pack_start (GTK_BOX (hbox30), b_browse, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (b_browse), 10);
frame47 = gtk_frame_new (NULL);
gtk_widget_set_name (frame47, "frame47");
gtk_widget_show (frame47);
gtk_box_pack_start (GTK_BOX (vbox22), frame47, TRUE, TRUE, 0);
gtk_widget_set_size_request (frame47, -1, 200);
gtk_frame_set_shadow_type (GTK_FRAME (frame47), GTK_SHADOW_NONE);
alignment39 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment39, "alignment39");
gtk_widget_show (alignment39);
gtk_container_add (GTK_CONTAINER (frame47), alignment39);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment39), 0, 0, 12, 0);
label68 = gtk_label_new (_(" FileDSN Name "));
gtk_widget_set_name (label68, "label68");
gtk_widget_show (label68);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook2), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook2), 1), label68);
hbox29 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox29, "hbox29");
gtk_widget_show (hbox29);
gtk_container_add (GTK_CONTAINER (notebook2), hbox29);
frame44 = gtk_frame_new (NULL);
gtk_widget_set_name (frame44, "frame44");
gtk_widget_show (frame44);
gtk_box_pack_start (GTK_BOX (hbox29), frame44, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame44), 10);
gtk_frame_set_shadow_type (GTK_FRAME (frame44), GTK_SHADOW_NONE);
alignment36 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment36, "alignment36");
gtk_widget_show (alignment36);
gtk_container_add (GTK_CONTAINER (frame44), alignment36);
gtk_widget_set_size_request (alignment36, 140, -1);
pixmap3 = gtk_pixmap_new (pixmap, mask);
gtk_widget_set_name (pixmap3, "pixmap3");
gtk_widget_show (pixmap3);
gtk_container_add (GTK_CONTAINER (alignment36), pixmap3);
vbox23 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox23, "vbox23");
gtk_widget_show (vbox23);
gtk_box_pack_start (GTK_BOX (hbox29), vbox23, TRUE, TRUE, 0);
frame45 = gtk_frame_new (NULL);
gtk_widget_set_name (frame45, "frame45");
gtk_widget_show (frame45);
gtk_box_pack_start (GTK_BOX (vbox23), frame45, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame45), GTK_SHADOW_NONE);
alignment37 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment37, "alignment37");
gtk_widget_show (alignment37);
gtk_container_add (GTK_CONTAINER (frame45), alignment37);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment37), 0, 0, 4, 0);
label80 = gtk_label_new (_("When you click Finish, you will create the data\nsource which you have just configured. The driver\nmay prompt you more information."));
gtk_widget_set_name (label80, "label80");
gtk_widget_show (label80);
gtk_container_add (GTK_CONTAINER (alignment37), label80);
frame46 = gtk_frame_new (NULL);
gtk_widget_set_name (frame46, "frame46");
gtk_widget_show (frame46);
gtk_box_pack_start (GTK_BOX (vbox23), frame46, TRUE, TRUE, 0);
gtk_widget_set_size_request (frame46, -1, 250);
gtk_frame_set_shadow_type (GTK_FRAME (frame46), GTK_SHADOW_NONE);
alignment38 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment38, "alignment38");
gtk_widget_show (alignment38);
gtk_container_add (GTK_CONTAINER (frame46), alignment38);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment38), 0, 10, 0, 0);
scrolledwindow13 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_name (scrolledwindow13, "scrolledwindow13");
gtk_widget_show (scrolledwindow13);
gtk_container_add (GTK_CONTAINER (alignment38), scrolledwindow13);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow13), GTK_SHADOW_IN);
#if GTK_CHECK_VERSION(2,0,0)
result_text = gtk_text_view_new ();
#else
result_text = gtk_text_new (NULL, NULL);
#endif
gtk_widget_set_name (result_text, "result_text");
gtk_widget_show (result_text);
gtk_container_add (GTK_CONTAINER (scrolledwindow13), result_text);
gtk_text_view_set_editable (GTK_TEXT_VIEW (result_text), FALSE);
gtk_text_view_set_overwrite (GTK_TEXT_VIEW (result_text), TRUE);
label69 = gtk_label_new (_(" Results "));
gtk_widget_set_name (label69, "label69");
gtk_widget_show (label69);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook2), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook2), 2), label69);
dialog_action_area3 = GTK_DIALOG (fdriverchooser)->action_area;
gtk_widget_set_name (dialog_action_area3, "dialog_action_area3");
gtk_widget_show (dialog_action_area3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area3), GTK_BUTTONBOX_END);
b_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (b_cancel, "b_cancel");
gtk_widget_show (b_cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (fdriverchooser), b_cancel, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
b_back = gtk_button_new_from_stock ("gtk-go-back");
gtk_widget_set_name (b_back, "b_back");
gtk_widget_show (b_back);
gtk_dialog_add_action_widget (GTK_DIALOG (fdriverchooser), b_back, 0);
gtk_widget_set_sensitive (b_back, FALSE);
GTK_WIDGET_SET_FLAGS (b_back, GTK_CAN_DEFAULT);
b_continue = gtk_button_new_with_mnemonic (_("Co_ntinue"));
gtk_widget_set_name (b_continue, "b_continue");
gtk_widget_show (b_continue);
gtk_dialog_add_action_widget (GTK_DIALOG (fdriverchooser), b_continue, 0);
GTK_WIDGET_SET_FLAGS (b_continue, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (fdriverchooser, fdriverchooser, "fdriverchooser");
GLADE_HOOKUP_OBJECT_NO_REF (fdriverchooser, dialog_vbox3, "dialog_vbox3");
GLADE_HOOKUP_OBJECT (fdriverchooser, notebook2, "notebook2");
GLADE_HOOKUP_OBJECT (fdriverchooser, hbox26, "hbox26");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame38, "frame38");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment30, "alignment30");
GLADE_HOOKUP_OBJECT (fdriverchooser, pixmap1, "pixmap1");
GLADE_HOOKUP_OBJECT (fdriverchooser, vbox21, "vbox21");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame39, "frame39");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment31, "alignment31");
GLADE_HOOKUP_OBJECT (fdriverchooser, scrolledwindow11, "scrolledwindow11");
GLADE_HOOKUP_OBJECT (fdriverchooser, clist2, "clist2");
GLADE_HOOKUP_OBJECT (fdriverchooser, l_name, "l_name");
GLADE_HOOKUP_OBJECT (fdriverchooser, l_file, "l_file");
GLADE_HOOKUP_OBJECT (fdriverchooser, l_date, "l_date");
GLADE_HOOKUP_OBJECT (fdriverchooser, l_size, "l_size");
GLADE_HOOKUP_OBJECT (fdriverchooser, label70, "label70");
GLADE_HOOKUP_OBJECT (fdriverchooser, hbox27, "hbox27");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame40, "frame40");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment32, "alignment32");
GLADE_HOOKUP_OBJECT (fdriverchooser, b_advanced, "b_advanced");
GLADE_HOOKUP_OBJECT (fdriverchooser, label67, "label67");
GLADE_HOOKUP_OBJECT (fdriverchooser, hbox28, "hbox28");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame41, "frame41");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment33, "alignment33");
GLADE_HOOKUP_OBJECT (fdriverchooser, pixmap2, "pixmap2");
GLADE_HOOKUP_OBJECT (fdriverchooser, vbox22, "vbox22");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame42, "frame42");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment34, "alignment34");
GLADE_HOOKUP_OBJECT (fdriverchooser, label79, "label79");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame43, "frame43");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment35, "alignment35");
GLADE_HOOKUP_OBJECT (fdriverchooser, hbox30, "hbox30");
GLADE_HOOKUP_OBJECT (fdriverchooser, fdsn_entry, "fdsn_entry");
GLADE_HOOKUP_OBJECT (fdriverchooser, b_browse, "b_browse");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame47, "frame47");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment39, "alignment39");
GLADE_HOOKUP_OBJECT (fdriverchooser, label68, "label68");
GLADE_HOOKUP_OBJECT (fdriverchooser, hbox29, "hbox29");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame44, "frame44");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment36, "alignment36");
GLADE_HOOKUP_OBJECT (fdriverchooser, pixmap3, "pixmap3");
GLADE_HOOKUP_OBJECT (fdriverchooser, vbox23, "vbox23");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame45, "frame45");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment37, "alignment37");
GLADE_HOOKUP_OBJECT (fdriverchooser, label80, "label80");
GLADE_HOOKUP_OBJECT (fdriverchooser, frame46, "frame46");
GLADE_HOOKUP_OBJECT (fdriverchooser, alignment38, "alignment38");
GLADE_HOOKUP_OBJECT (fdriverchooser, scrolledwindow13, "scrolledwindow13");
GLADE_HOOKUP_OBJECT (fdriverchooser, result_text, "result_text");
GLADE_HOOKUP_OBJECT (fdriverchooser, label69, "label69");
GLADE_HOOKUP_OBJECT_NO_REF (fdriverchooser, dialog_action_area3, "dialog_action_area3");
GLADE_HOOKUP_OBJECT (fdriverchooser, b_cancel, "b_cancel");
GLADE_HOOKUP_OBJECT (fdriverchooser, b_back, "b_back");
GLADE_HOOKUP_OBJECT (fdriverchooser, b_continue, "b_continue");
/* Notebook events */
gtk_signal_connect_after (GTK_OBJECT (notebook2), "switch_page",
GTK_SIGNAL_FUNC (fdriverchooser_switch_page), choose_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (fdriverchooser_cancel_clicked), choose_t);
/* Continue button events */
gtk_signal_connect (GTK_OBJECT (b_continue), "clicked",
GTK_SIGNAL_FUNC (fdriverchooser_next_clicked), choose_t);
/* Back button events */
gtk_signal_connect (GTK_OBJECT (b_back), "clicked",
GTK_SIGNAL_FUNC (fdriverchooser_prev_clicked), choose_t);
/* Browse button events */
gtk_signal_connect (GTK_OBJECT (b_browse), "clicked",
GTK_SIGNAL_FUNC (fdriverchooser_browse_clicked), choose_t);
/* Advanced button events */
gtk_signal_connect (GTK_OBJECT (b_advanced), "clicked",
GTK_SIGNAL_FUNC (fdriverchooser_advanced_clicked), choose_t);
/* Driver list events */
gtk_signal_connect (GTK_OBJECT (clist2), "select_row",
GTK_SIGNAL_FUNC (fdriver_list_select), choose_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (fdriverchooser), "delete_event",
GTK_SIGNAL_FUNC (fdelete_event), choose_t);
gtk_signal_connect (GTK_OBJECT (fdriverchooser), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_widget_grab_default (b_continue);
adddrivers_to_list (clist2, fdriverchooser);
choose_t->driverlist = clist2;
choose_t->driver = NULL;
choose_t->mainwnd = fdriverchooser;
choose_t->b_continue = b_continue;
choose_t->b_back = b_back;
choose_t->tab_panel = notebook2;
choose_t->dsn_entry = fdsn_entry;
choose_t->mess_entry = result_text;
gtk_widget_show_all (fdriverchooser);
gtk_main ();
}
GtkWidget*
create_preset_list (void)
{
GtkWidget *preset_list;
GtkWidget *dialog_vbox11;
GtkWidget *vbox33;
GtkWidget *hbox94;
GtkWidget *add;
GtkWidget *copy;
GtkWidget *remove;
GtkWidget *edit;
GtkWidget *scrolledwindow8;
GtkWidget *presets;
GtkWidget *dialog_action_area10;
GtkWidget *okbutton8;
preset_list = gtk_dialog_new ();
gtk_widget_set_size_request (preset_list, 450, 254);
gtk_window_set_title (GTK_WINDOW (preset_list), _("Presets"));
gtk_window_set_modal (GTK_WINDOW (preset_list), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (preset_list), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox11 = gtk_dialog_get_content_area (GTK_DIALOG (preset_list));
gtk_widget_show (dialog_vbox11);
vbox33 = gtk_vbox_new (FALSE, 8);
gtk_widget_show (vbox33);
gtk_box_pack_start (GTK_BOX (dialog_vbox11), vbox33, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox33), 12);
hbox94 = gtk_hbox_new (TRUE, 8);
gtk_widget_show (hbox94);
gtk_box_pack_start (GTK_BOX (vbox33), hbox94, FALSE, TRUE, 0);
add = gtk_button_new_from_stock ("gtk-add");
gtk_widget_show (add);
gtk_box_pack_start (GTK_BOX (hbox94), add, FALSE, TRUE, 0);
copy = gtk_button_new_from_stock ("gtk-copy");
gtk_widget_show (copy);
gtk_box_pack_start (GTK_BOX (hbox94), copy, FALSE, TRUE, 0);
remove = gtk_button_new_from_stock ("gtk-remove");
gtk_widget_show (remove);
gtk_box_pack_start (GTK_BOX (hbox94), remove, FALSE, TRUE, 0);
edit = gtk_button_new_from_stock ("gtk-edit");
gtk_widget_show (edit);
gtk_box_pack_start (GTK_BOX (hbox94), edit, FALSE, TRUE, 0);
scrolledwindow8 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow8);
gtk_box_pack_start (GTK_BOX (vbox33), scrolledwindow8, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow8), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow8), GTK_SHADOW_IN);
presets = gtk_tree_view_new ();
gtk_widget_show (presets);
gtk_container_add (GTK_CONTAINER (scrolledwindow8), presets);
gtk_widget_set_size_request (presets, 400, 160);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (presets), FALSE);
dialog_action_area10 = gtk_dialog_get_action_area (GTK_DIALOG (preset_list));
gtk_widget_show (dialog_action_area10);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area10), GTK_BUTTONBOX_END);
okbutton8 = gtk_button_new_from_stock ("gtk-close");
gtk_widget_show (okbutton8);
gtk_dialog_add_action_widget (GTK_DIALOG (preset_list), okbutton8, GTK_RESPONSE_CLOSE);
gtk_widget_set_can_default(okbutton8, TRUE);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (preset_list, preset_list, "preset_list");
GLADE_HOOKUP_OBJECT_NO_REF (preset_list, dialog_vbox11, "dialog_vbox11");
GLADE_HOOKUP_OBJECT (preset_list, vbox33, "vbox33");
GLADE_HOOKUP_OBJECT (preset_list, hbox94, "hbox94");
GLADE_HOOKUP_OBJECT (preset_list, add, "add");
GLADE_HOOKUP_OBJECT (preset_list, copy, "copy");
GLADE_HOOKUP_OBJECT (preset_list, remove, "remove");
GLADE_HOOKUP_OBJECT (preset_list, edit, "edit");
GLADE_HOOKUP_OBJECT (preset_list, scrolledwindow8, "scrolledwindow8");
GLADE_HOOKUP_OBJECT (preset_list, presets, "presets");
GLADE_HOOKUP_OBJECT_NO_REF (preset_list, dialog_action_area10, "dialog_action_area10");
GLADE_HOOKUP_OBJECT (preset_list, okbutton8, "okbutton8");
return preset_list;
}
void create_gtab_conf_window()
{
if (hime_gtab_conf_window) {
gtk_window_present(GTK_WINDOW(hime_gtab_conf_window));
return;
}
load_settings();
hime_gtab_conf_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (hime_setup_window_type_utility)
gtk_window_set_type_hint(GTK_WINDOW(hime_gtab_conf_window), GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_window_set_position(GTK_WINDOW(hime_gtab_conf_window), GTK_WIN_POS_MOUSE);
gtk_window_set_has_resize_grip(GTK_WINDOW(hime_gtab_conf_window), FALSE);
g_signal_connect (G_OBJECT (hime_gtab_conf_window), "delete_event",
G_CALLBACK (close_gtab_conf_window),
NULL);
gtk_window_set_title (GTK_WINDOW (hime_gtab_conf_window), _("倉頡/行列/大易設定"));
gtk_container_set_border_width (GTK_CONTAINER (hime_gtab_conf_window), 3);
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 10);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (hime_gtab_conf_window), vbox_top);
GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, FALSE, FALSE, 0);
GtkWidget *frame_gtab_l = gtk_frame_new(_("外觀"));
gtk_container_set_border_width (GTK_CONTAINER (frame_gtab_l), 5);
gtk_box_pack_start (GTK_BOX (hbox_lr), frame_gtab_l, TRUE, TRUE, 0);
GtkWidget *vbox_gtab_l = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_gtab_l), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_gtab_l), vbox_gtab_l);
gtk_container_set_border_width (GTK_CONTAINER (vbox_gtab_l), 10);
GtkWidget *frame_gtab_r = gtk_frame_new(_("行為"));
gtk_container_set_border_width (GTK_CONTAINER (frame_gtab_r), 5);
gtk_box_pack_start (GTK_BOX (hbox_lr), frame_gtab_r, TRUE, TRUE, 0);
GtkWidget *vbox_gtab_r = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_gtab_r), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_gtab_r), vbox_gtab_r);
gtk_container_set_border_width (GTK_CONTAINER (vbox_gtab_r), 10);
#define SPC 1
GtkWidget *hbox_gtab_pre_select = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_pre_select, FALSE, FALSE, 0);
opt_gtab_pre_select = gtk_label_new (_("預覽/預選 字"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_pre_select),opt_gtab_pre_select, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox_gtab_pre_select), create_auto_select_by_phrase_opts(&opt_gtab_pre_select, gtab_pre_select), FALSE, FALSE, 0);
GtkWidget *hbox_gtab_disp_partial_match = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_disp_partial_match, FALSE, FALSE, 0);
opt_gtab_disp_partial_match = gtk_label_new (_("預選列中顯示部份符合的字"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_partial_match), opt_gtab_disp_partial_match, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_partial_match), create_auto_select_by_phrase_opts(&opt_gtab_disp_partial_match, gtab_disp_partial_match), FALSE, FALSE, 0);
GtkWidget *hbox_gtab_disp_key_codes = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_disp_key_codes, FALSE, FALSE, 0);
check_button_gtab_disp_key_codes = gtk_check_button_new_with_label (_("顯示字根"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_key_codes), check_button_gtab_disp_key_codes, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_disp_key_codes),
gtab_disp_key_codes);
GtkWidget *hbox_gtab_disp_im_name = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_disp_im_name, FALSE, FALSE, 0);
check_button_gtab_disp_im_name = gtk_check_button_new_with_label (_("顯示輸入法名稱"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_disp_im_name), check_button_gtab_disp_im_name, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_disp_im_name),
gtab_disp_im_name);
GtkWidget *hbox_gtab_hide_row2 = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_hide_row2, FALSE, FALSE, 0);
check_button_gtab_hide_row2 = gtk_check_button_new_with_label (_("隱藏第二列 (輸入鍵…)"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_hide_row2), check_button_gtab_hide_row2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_hide_row2),
gtab_hide_row2);
GtkWidget *hbox_gtab_in_row1 = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_in_row1, FALSE, FALSE, 0);
check_button_gtab_in_row1 = gtk_check_button_new_with_label (_("將字根移至第一列"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_in_row1), check_button_gtab_in_row1, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_in_row1),
gtab_in_row1);
GtkWidget *hbox_gtab_vertical_select = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_l), hbox_gtab_vertical_select, FALSE, FALSE, 0);
GtkWidget *label_gtab_vertical_select = gtk_label_new (_("垂直選擇"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_vertical_select), label_gtab_vertical_select, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox_gtab_vertical_select), create_auto_select_by_phrase_opts(&opt_gtab_vertical_select, gtab_vertical_select), FALSE, FALSE, 0);
GtkWidget *hbox_gtab_press_full_auto_send = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_press_full_auto_send, FALSE, FALSE, 0);
GtkWidget *label_gtab_gtab_press_full_auto_send = gtk_label_new(_("按滿字根自動送字"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_press_full_auto_send), label_gtab_gtab_press_full_auto_send, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox_gtab_press_full_auto_send), create_auto_select_by_phrase_opts(&opt_gtab_press_full_auto_send, gtab_press_full_auto_send), FALSE, FALSE, 0);
GtkWidget *hbox_gtab_auto_select_by_phrase = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_auto_select_by_phrase, FALSE, FALSE, 0);
GtkWidget *label_gtab_auto_select = gtk_label_new(_("由詞庫自動選字"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_auto_select_by_phrase), label_gtab_auto_select, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox_gtab_auto_select_by_phrase), create_auto_select_by_phrase_opts(&opt_auto_select_by_phrase, gtab_auto_select_by_phrase), FALSE, FALSE, 0);
check_button_gtab_phrase_pre_select = gtk_check_button_new_with_label (_("使用預選詞"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_auto_select_by_phrase), check_button_gtab_phrase_pre_select, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_phrase_pre_select), gtab_phrase_pre_select);
GtkWidget *hbox_gtab_dup_select_bell = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_dup_select_bell, FALSE, FALSE, 0);
check_button_gtab_dup_select_bell = gtk_check_button_new_with_label (_("有重複字時，發出嗶聲"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_dup_select_bell),check_button_gtab_dup_select_bell, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_dup_select_bell),
gtab_dup_select_bell);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), create_spc_opts(), FALSE, FALSE, 0);
GtkWidget *hbox_gtab_invalid_key_in = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_invalid_key_in, FALSE, FALSE, 0);
check_button_gtab_invalid_key_in = gtk_check_button_new_with_label (_("可鍵入錯誤字根 (傳統)"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_invalid_key_in), check_button_gtab_invalid_key_in, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_invalid_key_in),
gtab_invalid_key_in);
GtkWidget *hbox_gtab_shift_phrase_key = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_shift_phrase_key, FALSE, FALSE, 0);
check_button_gtab_shift_phrase_key = gtk_check_button_new_with_label (_("可用 Shift 輸入片語 (預設為 Alt-Shift)"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_shift_phrase_key), check_button_gtab_shift_phrase_key, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_shift_phrase_key),
gtab_shift_phrase_key);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), create_en_pho_key_sel(_("切換[中/英]輸入")), FALSE, FALSE, 0);
#if 0
GtkWidget *hbox_hime_capslock_lower = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_hime_capslock_lower, FALSE, FALSE, 0);
check_button_hime_capslock_lower = gtk_check_button_new_with_label (_("\t用小寫字母"));
gtk_box_pack_start (GTK_BOX (hbox_hime_capslock_lower), check_button_hime_capslock_lower, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_hime_capslock_lower),
hime_capslock_lower);
#endif
GtkWidget *hbox_gtab_unique_auto_send = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_unique_auto_send, FALSE, FALSE, 0);
GtkWidget *label_gtab_unique_auto_send = gtk_label_new (_("唯一選擇時自動送出"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_unique_auto_send), label_gtab_unique_auto_send, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox_gtab_unique_auto_send), create_auto_select_by_phrase_opts(&opt_gtab_unique_auto_send, gtab_unique_auto_send), FALSE, FALSE, 0);
GtkWidget *hbox_gtab_que_wild_card = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_que_wild_card, FALSE, FALSE, 0);
check_button_gtab_que_wild_card = gtk_check_button_new_with_label (_("使用？萬用字元"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_que_wild_card), check_button_gtab_que_wild_card, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_que_wild_card),
gtab_que_wild_card);
GtkWidget *hbox_gtab_que_wild_card_asterisk = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_que_wild_card_asterisk, FALSE, FALSE, 0);
check_button_gtab_que_wild_card_asterisk = gtk_check_button_new_with_label (_("使用＊萬用字元"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_que_wild_card_asterisk), check_button_gtab_que_wild_card_asterisk, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_que_wild_card_asterisk),
gtab_que_wild_card_asterisk);
GtkWidget *hbox_gtab_pho_query = gtk_hbox_new (FALSE, SPC);
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), hbox_gtab_pho_query, FALSE, FALSE, 0);
check_button_gtab_pho_query = gtk_check_button_new_with_label (_("使用` 查詢同音字"));
gtk_box_pack_start (GTK_BOX (hbox_gtab_pho_query), check_button_gtab_pho_query, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button_gtab_pho_query),
gtab_pho_query);
GtkWidget *button_edit_append = gtk_button_new_with_label(_("編輯預設輸入法的使用者外加字詞"));
gtk_box_pack_start (GTK_BOX (vbox_gtab_r), button_edit_append, FALSE, FALSE, 0);
g_signal_connect_swapped (G_OBJECT (button_edit_append), "clicked",
G_CALLBACK (cb_gtab_edit_append), NULL);
GtkWidget *hbox_cancel_ok = gtk_hbox_new (FALSE, 10);
gtk_grid_set_column_homogeneous(GTK_GRID(hbox_cancel_ok), TRUE);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok, FALSE, FALSE, 0);
GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button_cancel), "clicked",
G_CALLBACK (close_gtab_conf_window),
G_OBJECT (hime_gtab_conf_window));
GtkWidget *button_ok = gtk_button_new_from_stock (GTK_STOCK_OK);
#if !GTK_CHECK_VERSION(2,91,2)
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 0);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 0);
#else
if (button_order)
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1);
else
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1);
#endif
g_signal_connect_swapped (G_OBJECT (button_ok), "clicked",
G_CALLBACK (cb_gtab_conf_ok),
G_OBJECT (hime_gtab_conf_window));
GTK_WIDGET_SET_FLAGS (button_ok, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button_ok);
gtk_widget_show_all (hime_gtab_conf_window);
return;
}
PrintProjectDialog::PrintProjectDialog(int dummy)
{
extern Settings *settings;
Shortcuts shortcuts(0);
printprojectdialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(printprojectdialog), _("Print project"));
gtk_window_set_position(GTK_WINDOW(printprojectdialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(printprojectdialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(printprojectdialog), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(printprojectdialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG(printprojectdialog));
gtk_widget_show(dialog_vbox1);
vbox1 = gtk_vbox_new(FALSE, 2);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new(FALSE, 4);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0);
label1 = gtk_label_new(_("Portion:"));
gtk_widget_show(label1);
gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0);
label_portion = gtk_label_new("");
gtk_widget_show(label_portion);
gtk_box_pack_start(GTK_BOX(hbox1), label_portion, FALSE, FALSE, 0);
button_portion = gtk_button_new();
gtk_widget_show(button_portion);
gtk_box_pack_start(GTK_BOX(hbox1), button_portion, FALSE, FALSE, 0);
alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_widget_show(alignment1);
gtk_container_add(GTK_CONTAINER(button_portion), alignment1);
hbox2 = gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbox2);
gtk_container_add(GTK_CONTAINER(alignment1), hbox2);
image1 = gtk_image_new_from_stock("gtk-properties", GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image1);
gtk_box_pack_start(GTK_BOX(hbox2), image1, FALSE, FALSE, 0);
label5 = gtk_label_new_with_mnemonic(_("Change"));
gtk_widget_show(label5);
gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0);
shortcuts.label(label5);
bool expand = false;
if (settings->session.print_references_in_notes_in_full) {
expand = true;
}
expander1 = gtk_expander_new(NULL);
gtk_widget_show(expander1);
gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0);
gtk_expander_set_expanded(GTK_EXPANDER(expander1), expand);
vbox_expander = gtk_vbox_new(FALSE, 5);
gtk_widget_show(vbox_expander);
gtk_container_add(GTK_CONTAINER(expander1), vbox_expander);
checkbutton_full_references = gtk_check_button_new_with_mnemonic(_("Write the references in the notes in full"));
gtk_widget_show(checkbutton_full_references);
gtk_box_pack_start(GTK_BOX(vbox_expander), checkbutton_full_references, FALSE, FALSE, 0);
// TO DO: Add options for 1 column, double spaced here
shortcuts.button(checkbutton_full_references);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_full_references), settings->session.print_references_in_notes_in_full);
label_expander = gtk_label_new(_("Options"));
gtk_widget_show(label_expander);
gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label_expander);
shortcuts.label(label_expander);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(printprojectdialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(printprojectdialog, NULL, &shortcuts, "file/print/project");
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(printprojectdialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
okbutton1 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(printprojectdialog), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);
shortcuts.stockbutton(cancelbutton1);
shortcuts.stockbutton(okbutton1);
shortcuts.process();
g_signal_connect((gpointer) button_portion, "clicked", G_CALLBACK(on_button_portion_clicked), gpointer(this));
g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this));
gtk_widget_grab_focus(okbutton1);
gtk_widget_grab_default(okbutton1);
// Set gui.
gui_reorder_include();
}
/*--------------------------------------------------------------------------*
* Create the main window *
*--------------------------------------------------------------------------*/
static void create_dialog () {
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *message_list_view;
GtkWidget *vbox, *vpane, *hbox, *config_vbox;
GtkWidget *sw, *imhtml, *msg_window, *button;
imhtml = gtk_imhtml_new (NULL, NULL);
/* Create main display window */
dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title (GTK_WINDOW(dialog), _("AutoProfile Summary"));
gtk_widget_realize (dialog);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (dialog), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
/* Set up progress bar container */
progress_create (AP_UPDATE_PROFILE, vbox);
progress_create (AP_UPDATE_STATUS, vbox);
/* Set up list of past away messages */
vpane = gtk_vpaned_new ();
gtk_box_pack_start (GTK_BOX(vbox), vpane, TRUE, TRUE, 0);
message_list = gtk_list_store_new (4,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
message_list_view = gtk_tree_view_new_with_model (
GTK_TREE_MODEL (message_list));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (
_("Time"), renderer, "markup", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (message_list_view), column);
gtk_tree_view_column_set_sort_column_id (column, 0);
column = gtk_tree_view_column_new_with_attributes (
_("Type"), renderer, "markup", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (message_list_view), column);
gtk_tree_view_column_set_sort_column_id (column, 1);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (
_("Text"), renderer, "markup", 2, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (message_list_view), column);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (sw), message_list_view);
gtk_paned_add1 (GTK_PANED(vpane), sw);
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (message_list_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (display_diff_msg), imhtml);
/* Set up the window to display away message in */
msg_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(msg_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(msg_window),
GTK_SHADOW_IN);
gtk_paned_add2 (GTK_PANED(vpane), msg_window);
gtk_container_add (GTK_CONTAINER(msg_window), imhtml);
pidgin_setup_imhtml (imhtml);
/* Bottom area */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
config_vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX(hbox), config_vbox, TRUE, TRUE, 0);
pidgin_prefs_checkbox (
_("Queue new messages while away"),
"/plugins/gtk/autoprofile/queue_messages_when_away",
config_vbox);
button = pidgin_prefs_checkbox (
_("Play sounds while away"),
"/purple/sound/while_away",
config_vbox);
sound_pref_cb = purple_prefs_connect_callback (ap_get_plugin_handle (),
"/purple/sound/while_away", sound_cb, button);
gtk_box_pack_start (GTK_BOX(hbox), gtk_vseparator_new (), FALSE, FALSE, 0);
config_vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX(hbox), config_vbox, TRUE, TRUE, 0);
ap_gtk_prefs_add_summary_option (config_vbox);
button = gtk_button_new_with_label (_("Hide summary now"));
gtk_box_pack_start (GTK_BOX(config_vbox), button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hide_cb), NULL);
/* Finish up */
g_signal_connect (G_OBJECT(dialog), "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
gtk_paned_set_position (GTK_PANED(vpane), 250);
gtk_window_set_default_size (GTK_WINDOW(dialog), 430, 430);
}
int main( int argc, char *argv[] )
{
GtkWidget *vbox;
gtk_init( &argc, &argv );
if( client_open( NULL ) )
exit( 1 );
atexit( client_close );
window = argc == 2 ?
gtk_plug_new( strtol( argv[1], NULL, 10 )) :
gtk_window_new( GTK_WINDOW_TOPLEVEL );
vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
drawing_area = gtk_drawing_area_new();
/* Get the dimensions and colors of the pager and viewport and focus */
parse_stdin();
update_rect.x = update_rect.y = 0;
gtk_drawing_area_size( GTK_DRAWING_AREA( drawing_area ), width, height );
gtk_box_pack_start( GTK_BOX( vbox ), drawing_area, FALSE, FALSE, 0 );
/* Signals to quit */
g_signal_connect( GTK_OBJECT( window ), "delete_event",
G_CALLBACK( delete_event ), NULL );
g_signal_connect( GTK_OBJECT( window ), "destroy",
G_CALLBACK( destroy_event ), NULL );
/* Wait for input from standard input */
gdk_input_add( 0, GDK_INPUT_READ,
&wait_stdin,
drawing_area );
/* Change the viewport when a button is pressed */
g_signal_connect( GTK_OBJECT( drawing_area ), "motion_notify_event",
(GCallback) motion_notify_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "button_press_event",
(GCallback) button_press_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "button_release_event",
(GCallback) button_release_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "leave_notify_event",
(GCallback) leave_notify_event, NULL );
g_signal_connect ( GTK_OBJECT( drawing_area), "scroll_event",
(GCallback) scroll_event, NULL );
gtk_widget_set_events( drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_SCROLL_MASK );
/* Initialize and draw the pixmap */
g_signal_connect( GTK_OBJECT( drawing_area ), "expose_event",
(GCallback) expose_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "configure_event",
(GCallback) configure_event, NULL );
gtk_widget_show( drawing_area );
gtk_widget_show( vbox );
wmspec_change_state(TRUE, window->window,
gdk_atom_intern( "_NET_WM_STATE_SKIP_PAGER", FALSE ),
gdk_atom_intern( "_NET_WM_STATE_SKIP_TASKBAR", FALSE ));
gtk_window_set_type_hint( GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_show( window );
gtk_main();
return 0;
}
static void budgie_panel_init(BudgiePanel *self)
{
GtkWidget *tasklist;
GtkWidget *layout;
GtkWidget *widgets;
GdkScreen *screen;
GdkDisplay *display;
GdkVisual *visual;
GtkWidget *power;
GtkWidget *clock;
GtkWidget *sound;
GtkWidget *menu;
int width;
GSettings *gsettings;
GtkStyleContext *style;
init_styles(self);
/* Controlled by GSettings */
self->position = PANEL_BOTTOM;
gsettings = g_settings_new(BUDGIE_SCHEMA);
self->settings = gsettings;
settings_cb(gsettings, BUDGIE_PANEL_LOCATION, self);
g_signal_connect(gsettings, "changed", G_CALLBACK(settings_cb), self);
/* Sort ourselves out visually */
style = gtk_widget_get_style_context(GTK_WIDGET(self));
gtk_style_context_add_class(style, BUDGIE_STYLE_PANEL);
gtk_style_context_remove_class(style, "background");
gtk_widget_set_app_paintable(GTK_WIDGET(self), TRUE);
g_signal_connect(self, "draw", G_CALLBACK(budgie_panel_draw), self);
/* Not resizable.. */
gtk_window_set_resizable(GTK_WINDOW(self), FALSE);
gtk_window_set_has_resize_grip(GTK_WINDOW(self), FALSE);
/* Decide if we're using X11 or Wayland */
display = gdk_display_get_default();
if (GDK_IS_X11_DISPLAY(display)) {
self->x11 = TRUE;
} else {
self->x11 = FALSE;
}
/* Our main layout is a horizontal box */
layout = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_valign(layout, GTK_ALIGN_START);
gtk_container_add(GTK_CONTAINER(self), layout);
/* Add a menu button */
menu = menu_applet_new();
self->menu = menu;
gtk_box_pack_start(GTK_BOX(layout), menu, FALSE, FALSE, 0);
g_object_set(menu, "margin-left", 4, NULL);
/* Add a tasklist to the panel on x11 */
if (self->x11) {
tasklist = windowlist_applet_new();
self->tasklist = tasklist;
gtk_box_pack_start(GTK_BOX(layout), tasklist, FALSE, FALSE, 0);
}
/* Group widgets under one area */
widgets = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
/* Now have it themed by eventbox */
g_signal_connect(widgets, "draw", G_CALLBACK(budgie_panel_draw), self);
gtk_widget_set_valign(widgets, GTK_ALIGN_FILL);
g_object_set(widgets, "margin", 5, NULL);
style = gtk_widget_get_style_context(widgets);
gtk_style_context_add_class(style, BUDGIE_STYLE_MESSAGE_AREA);
gtk_box_pack_end(GTK_BOX(layout), widgets, FALSE, FALSE, 0);
/* Add the power applet */
power = power_applet_new();
self->power = power;
gtk_box_pack_start(GTK_BOX(widgets), power, FALSE, FALSE, 0);
g_object_set(power, "margin-left", 3, NULL);
/* And now the sound */
sound = sound_applet_new();
self->sound = sound;
gtk_box_pack_start(GTK_BOX(widgets), sound, FALSE, FALSE, 0);
g_object_set(sound, "margin-right", 3, NULL);
/* Add a clock at the end */
clock = clock_applet_new();
self->clock = clock;
g_object_set(clock, "margin-right", 1, NULL);
gtk_box_pack_end(GTK_BOX(widgets), clock, FALSE, FALSE, 0);
gtk_widget_set_valign(GTK_WIDGET(widgets), GTK_ALIGN_FILL);
/* Ensure we close when destroyed */
g_signal_connect(self, "destroy", G_CALLBACK(gtk_main_quit), NULL);
/* Ensure we move to the right location when anything internally
* changes size */
g_signal_connect(self, "size-allocate", G_CALLBACK(resized_cb), self);
/* Set ourselves up to be the correct size and position */
screen = gdk_display_get_default_screen(display);
visual = gdk_screen_get_rgba_visual(screen);
if (visual) {
gtk_widget_set_visual(GTK_WIDGET(self), visual);
}
width = gdk_screen_get_width(screen);
gtk_widget_set_size_request(GTK_WIDGET(self), width, PANEL_HEIGHT);
g_signal_connect(self, "realize", G_CALLBACK(realized_cb),
self);
/* On X11 use dock hint */
if (self->x11) {
gtk_window_set_type_hint(GTK_WINDOW(self),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_stick(GTK_WINDOW(self));
} else {
gtk_window_set_decorated(GTK_WINDOW(self), FALSE);
}
/* And now show ourselves */
gtk_widget_show_all(GTK_WIDGET(self));
}
int
main(int argc, char **argv) {
GtkWidget *vbox;
int options;
options = get_options(argc, argv);
if(options != 0)
return options;
gtk_init(&argc, &argv);
lightpad = g_slice_new0(Window);
lightpad->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size((GtkWindow*)lightpad->window, 800, 400);
gtk_window_set_title(GTK_WINDOW(lightpad->window), "Lightpad");
gtk_window_set_default_icon_name("accessories-text-editor");
gtk_container_set_border_width(GTK_CONTAINER(lightpad->window), 0);
{
lightpad->popup = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_can_focus(lightpad->popup, TRUE);
gtk_window_set_decorated(GTK_WINDOW(lightpad->popup), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(lightpad->popup), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
gtk_window_set_transient_for(GTK_WINDOW(lightpad->popup), lightpad->window);
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
lightpad->popupBox = vbox;
gtk_container_add(GTK_CONTAINER(lightpad->popup), vbox);
}
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(lightpad->window), vbox);
lightpad->tabs = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(lightpad->tabs), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), lightpad->tabs, TRUE, TRUE, 0);
g_signal_connect(lightpad->window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(lightpad->window, "delete-event", G_CALLBACK(on_delete_window), NULL);
g_signal_connect(lightpad->window, "key-press-event", G_CALLBACK(on_keypress_window), NULL);
g_signal_connect(lightpad->tabs, "page-added", G_CALLBACK(on_page_added), NULL);
if(init_config() < 0)
return -1;
if(remaining) {
for (int i = 0; remaining[i]; i++)
new_view(remaining[i]);
g_strfreev(remaining);
} else
new_view(NULL);
gtk_widget_show_all(lightpad->window);
gtk_main();
/* This will destroy all the children, who in turn
* will destroy their own children et cetera.
* Thus, there is no need to explicitly destroy
* all the GtkScrolledWindow objects
*/
gtk_widget_destroy(lightpad->window);
g_slice_free(Window, lightpad);
g_free((gpointer)settings->font);
g_free((gpointer)settings->scheme);
g_slice_free(Settings, settings);
return 0;
}
GtkWidget * create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *hbox1;
GtkWidget *entrySub;
GtkWidget *button1;
GtkObject *spinbuttonScale_adj;
GtkWidget *spinbuttonScale;
GtkObject *spinbuttonSpacing_adj;
GtkWidget *spinbuttonSpacing;
GtkObject *spinbuttonTop_adj;
GtkWidget *spinbuttonTop;
GtkObject *spinbuttonBottom_adj;
GtkWidget *spinbuttonBottom;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("ASS/SSA Subtitle"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
table1 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0);
label1 = gtk_label_new (_("Subtitle file (ass/ssa) :"));
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 (_("Font scale :"));
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);
label3 = gtk_label_new (_("Line spacing"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label4 = gtk_label_new (_("Top margin"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new (_("Bottom margin"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (table1), hbox1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
entrySub = gtk_entry_new ();
gtk_widget_show (entrySub);
gtk_box_pack_start (GTK_BOX (hbox1), entrySub, TRUE, TRUE, 0);
button1 = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (button1);
gtk_box_pack_start (GTK_BOX (hbox1), button1, FALSE, FALSE, 0);
spinbuttonScale_adj = gtk_adjustment_new (1, 0.10000000149, 10, 1, 1, 1);
spinbuttonScale = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonScale_adj), 1, 2);
gtk_widget_show (spinbuttonScale);
gtk_table_attach (GTK_TABLE (table1), spinbuttonScale, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonScale), TRUE);
spinbuttonSpacing_adj = gtk_adjustment_new (1, 0.10000000149, 10, 1, 1, 1);
spinbuttonSpacing = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonSpacing_adj), 1, 2);
gtk_widget_show (spinbuttonSpacing);
gtk_table_attach (GTK_TABLE (table1), spinbuttonSpacing, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonSpacing), TRUE);
spinbuttonTop_adj = gtk_adjustment_new (0, 0, 200, 1, 10, 10);
spinbuttonTop = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonTop_adj), 1, 0);
gtk_widget_show (spinbuttonTop);
gtk_table_attach (GTK_TABLE (table1), spinbuttonTop, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonTop), TRUE);
spinbuttonBottom_adj = gtk_adjustment_new (0, 0, 200, 1, 10, 10);
spinbuttonBottom = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonBottom_adj), 1, 0);
gtk_widget_show (spinbuttonBottom);
gtk_table_attach (GTK_TABLE (table1), spinbuttonBottom, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonBottom), TRUE);
dialog_action_area1 = GTK_DIALOG (dialog1)->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 (dialog1), 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 (dialog1), 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 (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, entrySub, "entrySub");
GLADE_HOOKUP_OBJECT (dialog1, button1, "button1");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonScale, "spinbuttonScale");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonSpacing, "spinbuttonSpacing");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonTop, "spinbuttonTop");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonBottom, "spinbuttonBottom");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
static void create_file_save_as_dialog(const gchar *extension, ExportFunc func,
gboolean show_zoom_level_checkbox)
{
GtkWidget *dialog, *vbox;
GeanyDocument *doc;
ExportInfo *exi;
g_return_if_fail(extension != NULL);
doc = document_get_current();
g_return_if_fail(doc != NULL);
exi = g_new(ExportInfo, 1);
exi->doc = doc;
exi->export_func = func;
exi->have_zoom_level_checkbox = FALSE;
dialog = gtk_file_chooser_dialog_new(_("Export File"), GTK_WINDOW(geany->main_widgets->window),
GTK_FILE_CHOOSER_ACTION_SAVE, NULL, NULL);
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_widget_set_name(dialog, "GeanyExportDialog");
gtk_dialog_add_buttons(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
/* file chooser extra widget */
vbox = gtk_vbox_new(FALSE, 0);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), vbox);
{
GtkWidget *check_line_numbers;
check_line_numbers = gtk_check_button_new_with_mnemonic(_("_Insert line numbers"));
gtk_widget_set_tooltip_text(check_line_numbers,
_("Insert line numbers before each line in the exported document"));
gtk_box_pack_start(GTK_BOX(vbox), check_line_numbers, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
ui_hookup_widget(dialog, check_line_numbers, "check_line_numbers");
}
if (show_zoom_level_checkbox)
{
GtkWidget *check_zoom_level;
check_zoom_level = gtk_check_button_new_with_mnemonic(_("_Use current zoom level"));
gtk_widget_set_tooltip_text(check_zoom_level,
_("Renders the font size of the document together with the current zoom level"));
gtk_box_pack_start(GTK_BOX(vbox), check_zoom_level, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
ui_hookup_widget(dialog, check_zoom_level, "check_zoom_level");
exi->have_zoom_level_checkbox = TRUE;
}
g_signal_connect(dialog, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
g_signal_connect(dialog, "response", G_CALLBACK(on_file_save_dialog_response), exi);
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(geany->main_widgets->window));
/* if the current document has a filename we use it as the default. */
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(dialog));
if (doc->file_name != NULL)
{
gchar *base_name = g_path_get_basename(doc->file_name);
gchar *file_name;
gchar *locale_filename;
gchar *locale_dirname;
const gchar *suffix = "";
if (g_str_has_suffix(doc->file_name, extension))
suffix = "_export";
file_name = g_strconcat(base_name, suffix, extension, NULL);
locale_filename = utils_get_locale_from_utf8(doc->file_name);
locale_dirname = g_path_get_dirname(locale_filename);
/* set the current name to base_name.html which probably doesn't exist yet so
* gtk_file_chooser_set_filename() can't be used and we need
* gtk_file_chooser_set_current_folder() additionally */
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dirname);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), file_name);
g_free(locale_dirname);
g_free(locale_filename);
g_free(file_name);
g_free(base_name);
}
else
{
const gchar *default_open_path = geany->prefs->default_open_path;
gchar *fname = g_strconcat(GEANY_STRING_UNTITLED, extension, NULL);
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(dialog));
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fname);
/* use default startup directory(if set) if no files are open */
if (!EMPTY(default_open_path) && g_path_is_absolute(default_open_path))
{
gchar *locale_path = utils_get_locale_from_utf8(default_open_path);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
g_free(locale_path);
}
g_free(fname);
}
gtk_dialog_run(GTK_DIALOG(dialog));
}
void jack_configure(void)
{
if (configure_win != NULL) {
gtk_window_present(GTK_WINDOW(configure_win));
return;
}
configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint ( GTK_WINDOW(configure_win), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_signal_connect(GTK_OBJECT(configure_win), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &configure_win);
gtk_window_set_title(GTK_WINDOW(configure_win), _("jack Plugin configuration"));
gtk_window_set_policy(GTK_WINDOW(configure_win), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE);
gtk_container_border_width(GTK_CONTAINER(configure_win), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(configure_win), vbox);
/* add a frame for other plugin options */
option_frame = gtk_frame_new(_("Options:"));
gtk_box_pack_start(GTK_BOX(vbox), option_frame, FALSE, FALSE, 0);
/* add a hbox that will contain a label for a dropdown and the dropdown itself */
port_connection_mode_box = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(port_connection_mode_box), 5);
gtk_container_add(GTK_CONTAINER(option_frame), port_connection_mode_box);
/* add the label */
gtk_box_pack_start(GTK_BOX(port_connection_mode_box),
gtk_label_new(_("Connection mode:")),
FALSE, FALSE, 0);
/* add the dropdown */
port_connection_mode_combo = gtk_combo_new();
get_port_connection_modes(GTK_COMBO(port_connection_mode_combo));
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(port_connection_mode_combo)->entry),
jack_cfg.port_connection_mode);
gtk_box_pack_start(GTK_BOX(port_connection_mode_box), port_connection_mode_combo,
TRUE, TRUE, 0);
/* create a check_button for debug output */
GTK_isTraceEnabled = gtk_check_button_new_with_label(_("Enable debug printing"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_isTraceEnabled, FALSE, FALSE, 0);
gtk_widget_show(GTK_isTraceEnabled);
/* set the state of the check_button based upon
* the value of isTracingEnabled
*/
GTK_CHECK_BUTTON(GTK_isTraceEnabled)->toggle_button.active = jack_cfg.isTraceEnabled;
/* add the box for the ok/canceled buttons at the bottom */
bbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("Ok"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(configure_win_ok_cb), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_show(ok);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(configure_win));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show(cancel);
gtk_widget_show_all(configure_win);
}
static void
joind_show_dialog (server *serv)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *image1;
GtkWidget *vbox2;
GtkWidget *label;
GtkWidget *radiobutton1;
GtkWidget *radiobutton2;
GtkWidget *radiobutton3;
GSList *radiobutton1_group;
GtkWidget *hbox2;
GtkWidget *entry1;
GtkWidget *checkbutton1;
GtkWidget *dialog_action_area1;
GtkWidget *okbutton1;
char buf[256];
char buf2[256];
serv->gui->joind_win = dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("XChat: Connection Complete"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_position (GTK_WINDOW (dialog1), GTK_WIN_POS_MOUSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->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);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
image1 = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_DIALOG);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 24);
gtk_misc_set_alignment (GTK_MISC (image1), 0.5, 0.06);
vbox2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 6);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);
snprintf (buf2, sizeof (buf2), _("Connection to %s complete."),
server_get_network (serv, TRUE));
snprintf (buf, sizeof (buf), "\n<b>%s</b>", buf2);
label = gtk_label_new (buf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
label = gtk_label_new (_("In the Server-List window, no channel (chat room) has been entered to be automatically joined for this network."));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
GTK_LABEL (label)->wrap = TRUE;
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
label = gtk_label_new (_("What would you like to do next?"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
serv->gui->joind_radio1 = radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, _("_Nothing, I'll join a channel later."));
gtk_widget_show (radiobutton1);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton1, FALSE, FALSE, 0);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1));
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
serv->gui->joind_radio2 = radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, _("_Join this channel:"));
gtk_widget_show (radiobutton2);
gtk_box_pack_start (GTK_BOX (hbox2), radiobutton2, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2));
serv->gui->joind_entry = entry1 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry1), "#");
gtk_widget_show (entry1);
gtk_box_pack_start (GTK_BOX (hbox2), entry1, TRUE, TRUE, 8);
snprintf (buf, sizeof (buf), "<small> %s</small>",
_("If you know the name of the channel you want to join, enter it here."));
label = gtk_label_new (buf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
radiobutton3 = gtk_radio_button_new_with_mnemonic (NULL, _("O_pen the Channel-List window."));
gtk_widget_show (radiobutton3);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton3, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton3), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton3));
snprintf (buf, sizeof (buf), "<small> %s</small>",
_("Retrieving the Channel-List may take a minute or two."));
label = gtk_label_new (buf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
serv->gui->joind_check = checkbutton1 = gtk_check_button_new_with_mnemonic (_("_Always show this dialog after connecting."));
if (prefs.gui_join_dialog)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), TRUE);
gtk_widget_show (checkbutton1);
gtk_box_pack_start (GTK_BOX (vbox1), checkbutton1, FALSE, FALSE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog1)->action_area), okbutton1, FALSE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
g_signal_connect (G_OBJECT (dialog1), "destroy",
G_CALLBACK (joind_destroy_cb), serv);
g_signal_connect (G_OBJECT (entry1), "focus_in_event",
G_CALLBACK (joind_entryfocus_cb), serv);
g_signal_connect (G_OBJECT (entry1), "activate",
G_CALLBACK (joind_entryenter_cb), okbutton1);
g_signal_connect (G_OBJECT (radiobutton2), "toggled",
G_CALLBACK (joind_radio2_cb), serv);
g_signal_connect (G_OBJECT (okbutton1), "clicked",
G_CALLBACK (joind_ok_cb), serv);
gtk_widget_grab_focus (okbutton1);
gtk_widget_show_all (dialog1);
}
static gboolean _lib_tagging_tag_show(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval,
GdkModifierType modifier, dt_lib_module_t *self)
{
int mouse_over_id = -1;
int zoom = dt_conf_get_int("plugins/lighttable/images_in_row");
// the order is:
// if(zoom == 1) => currently shown image
// else if(selection not empty) => selected images
// else if(cursor over image) => hovered image
// else => return
if(zoom == 1 || dt_collection_get_selected_count(darktable.collection) == 0)
{
mouse_over_id = dt_control_get_mouse_over_id();
if(mouse_over_id < 0) return TRUE;
}
dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
d->floating_tag_imgid = mouse_over_id;
gint x, y;
gint px, py, w, h;
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkWidget *center = dt_ui_center(darktable.gui->ui);
gdk_window_get_origin(gtk_widget_get_window(center), &px, &py);
w = gdk_window_get_width(gtk_widget_get_window(center));
h = gdk_window_get_height(gtk_widget_get_window(center));
x = px + 0.5 * (w - FLOATING_ENTRY_WIDTH);
y = py + h - 50;
/* put the floating box at the mouse pointer */
// gint pointerx, pointery;
// GdkDevice *device =
// gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget)));
// gdk_window_get_device_position (gtk_widget_get_window (widget), device, &pointerx, &pointery, NULL);
// x = px + pointerx + 1;
// y = py + pointery + 1;
d->floating_tag_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* stackoverflow.com/questions/1925568/how-to-give-keyboard-focus-to-a-pop-up-gtk-window */
gtk_widget_set_can_focus(d->floating_tag_window, TRUE);
gtk_window_set_decorated(GTK_WINDOW(d->floating_tag_window), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(d->floating_tag_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
gtk_window_set_transient_for(GTK_WINDOW(d->floating_tag_window), GTK_WINDOW(window));
gtk_widget_set_opacity(d->floating_tag_window, 0.8);
gtk_window_move(GTK_WINDOW(d->floating_tag_window), x, y);
GtkWidget *entry = gtk_entry_new();
gtk_widget_set_size_request(entry, FLOATING_ENTRY_WIDTH, -1);
gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK);
GtkEntryCompletion *completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_completion_set_popup_set_width(completion, FALSE);
gtk_entry_set_completion(GTK_ENTRY(entry), completion);
gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
gtk_container_add(GTK_CONTAINER(d->floating_tag_window), entry);
g_signal_connect_swapped(entry, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_tag_window);
g_signal_connect(entry, "key-press-event", G_CALLBACK(_lib_tagging_tag_key_press), self);
gtk_widget_show_all(d->floating_tag_window);
gtk_widget_grab_focus(entry);
gtk_window_present(GTK_WINDOW(d->floating_tag_window));
return TRUE;
}
void create_startwin(void)
{
GtkWidget *banner, *label, *content, *scroll;
GtkWidget *hbox1, *fixed1;
GdkPixbuf *startbanner_pixbuf;
startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (startwin), apptitle);
gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (startwin), hbox1);
startbanner_pixbuf = gdk_pixbuf_from_pixdata(&startbanner_pixdata, FALSE, NULL);
banner = gtk_image_new_from_pixbuf(startbanner_pixbuf);
g_object_unref((gpointer)startbanner_pixbuf);
gtk_widget_show (banner);
gtk_box_pack_start (GTK_BOX (hbox1), banner, FALSE, FALSE, 0);
fixed1 = gtk_fixed_new ();
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (hbox1), fixed1, TRUE, TRUE, 0);
gtk_widget_set_size_request (fixed1, 390, -1);
label = gtk_label_new (startwin_labeltext);
gtk_widget_show (label);
gtk_fixed_put (GTK_FIXED (fixed1), label, 6, 6);
gtk_widget_set_size_request (label, 378, 16);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scroll);
gtk_fixed_put (GTK_FIXED (fixed1), scroll, 6, 28);
gtk_widget_set_size_request (scroll, 378, 248);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
content = gtk_text_view_new ();
gtk_widget_show (content);
gtk_container_add (GTK_CONTAINER(scroll), content);
//gtk_fixed_put (GTK_FIXED (fixed1), content, 6, 28);
gtk_widget_set_size_request (content, 378, 248);
gtk_text_view_set_editable (GTK_TEXT_VIEW (content), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (content), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (content), FALSE);
g_signal_connect ((gpointer) startwin, "delete_event",
G_CALLBACK (on_startwin_delete_event),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin");
GLADE_HOOKUP_OBJECT (startwin, banner, "banner");
GLADE_HOOKUP_OBJECT (startwin, label, "label");
GLADE_HOOKUP_OBJECT (startwin, scroll, "scroll");
GLADE_HOOKUP_OBJECT (startwin, content, "content");
g_signal_connect((gpointer)startwin, "destroy", G_CALLBACK(gtk_widget_destroyed), (gpointer)&startwin);
gtk_widget_show (startwin);
gtk_main_iteration_do (FALSE);
}
