static void
create_popup_menu (ViewerCbInfo * info)
{
GtkWidget *popup_menu;
GtkWidget *menu_item;
GtkWidget *stock;
popup_menu = gtk_menu_new ();
gtk_menu_set_accel_group (GTK_MENU (popup_menu), info->accel_group);
if (info->base_uri) {
menu_item = gtk_image_menu_item_new_with_label (_("Copy SVG location"));
stock = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
gtk_widget_show (stock);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
g_signal_connect (menu_item, "activate", G_CALLBACK (copy_svg_location), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_C,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
}
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (save_svg), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_item = gtk_image_menu_item_new_with_label (_("Save as PNG"));
stock = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
gtk_widget_show (stock);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
g_signal_connect (menu_item, "activate", G_CALLBACK (save_pixbuf), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S,
GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
#if GTK_CHECK_VERSION(2,10,0)
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (print_pixbuf), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
#endif
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_in), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_plus,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_out), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_minus,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
info->popup_menu = popup_menu;
}
void create_vector_table_options_dialog (vector_table_options_D *dialog)
{
GtkWidget *tbl = NULL, *toolbar = NULL, *btn = NULL, *btnBaseRadioSource = NULL ;
GtkAccelGroup *accel_group = NULL ;
GtkTreeViewColumn *col = NULL ;
GtkCellRenderer *cr = NULL ;
accel_group = gtk_accel_group_new () ;
dialog->dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE);
gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Vector Table Setup"));
gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ;
g_object_set_data (G_OBJECT (dialog->dialog), "dialog", dialog) ;
tbl = gtk_table_new (2, 1, FALSE) ;
gtk_widget_show (tbl) ;
gtk_container_add (GTK_CONTAINER (dialog->dialog), tbl) ;
toolbar = gtk_toolbar_new () ;
gtk_widget_show (toolbar) ;
gtk_table_attach (GTK_TABLE (tbl), toolbar, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_FILL), 0, 0) ;
gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL) ;
gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ;
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH) ;
g_object_set_data (G_OBJECT (btn = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Close"),
_("Close Window"),
_("Close vector table editor."),
gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnClose_clicked,
NULL)),
"dialog", dialog) ;
gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_w, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ;
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ;
#ifdef STDIO_FILEIO
dialog->btnOpen =
btn = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
_("Open Vector Table"),
_("Open and display another vector table."),
gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnOpen_clicked,
dialog) ;
gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ;
dialog->btnSave =
btn = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
_("Save Vector Table"),
_("Save the displayed vector table."),
gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnSave_clicked,
dialog->dialog) ;
gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ;
#endif /* def STDIO_FILEIO */
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ;
g_object_set_data (G_OBJECT (
dialog->tbtnExhaustive =
btnBaseRadioSource = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
NULL,
_("Exhaustive"),
_("Exhaustive Verification"),
_("Attempt all possible inputs."),
gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnSimType_clicked,
dialog)),
"sim_type", (gpointer)EXHAUSTIVE_VERIFICATION) ;
g_object_set_data (G_OBJECT (
dialog->tbtnVT =
gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
btnBaseRadioSource,
_("Vector Table"),
_("Vector Table Simulation"),
_("Create a sequence of inputs."),
gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnSimType_clicked,
dialog)),
"sim_type", (gpointer)VECTOR_TABLE) ;
dialog->tblVT = gtk_table_new (1, 2, FALSE) ;
gtk_widget_show (dialog->tblVT) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->tblVT, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ;
toolbar = gtk_toolbar_new () ;
gtk_widget_show (toolbar) ;
gtk_table_attach (GTK_TABLE (dialog->tblVT), toolbar, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ;
gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_VERTICAL) ;
gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ;
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS) ;
dialog->btnAdd =
btn = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Add"),
_("Add Vector"),
_("Apend a vector to the end of the table."),
gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnAdd_clicked,
dialog->dialog) ;
dialog->btnInsert =
btn = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Insert Before"),
_("Insert Vector Before"),
_("Insert vector before the selected one."),
gtk_image_new_from_stock (QCAD_STOCK_INSERT_COL_BEFORE, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnAdd_clicked,
dialog->dialog) ;
dialog->btnDelete =
btn = gtk_toolbar_append_element (
GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Delete Vector"),
_("Delete Vector"),
_("Insert the selected vector."),
gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_LARGE_TOOLBAR),
(GCallback)vector_table_options_dialog_btnDelete_clicked,
dialog->dialog) ;
dialog->sw = qcad_tree_view_container_new () ;
gtk_widget_show (dialog->sw) ;
gtk_table_attach (GTK_TABLE (dialog->tblVT), dialog->sw, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ;
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ;
dialog->tv = create_bus_layout_tree_view (TRUE, _("Inputs"), GTK_SELECTION_SINGLE) ;
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new ()) ;
gtk_tree_view_column_set_title (col, _("Active")) ;
gtk_tree_view_column_pack_start (col, cr = dialog->crActive = gtk_cell_renderer_toggle_new (), TRUE) ;
gtk_tree_view_column_add_attribute (col, cr, "active", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ;
g_object_set (G_OBJECT (cr), "activatable", TRUE, NULL) ;
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cr), TRUE) ;
gtk_widget_show (dialog->tv) ;
gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tv) ;
qcad_tree_view_container_freeze_columns (QCAD_TREE_VIEW_CONTAINER (dialog->sw), 2) ;
g_signal_connect (G_OBJECT (dialog->tv), "style-set", (GCallback)tree_view_style_set, NULL) ;
g_signal_connect (G_OBJECT (cr), "toggled", (GCallback)vt_model_active_toggled, dialog->tv) ;
g_signal_connect (G_OBJECT (dialog->dialog), "delete-event", (GCallback)vector_table_options_dialog_btnClose_clicked, NULL) ;
gtk_window_add_accel_group (GTK_WINDOW (dialog->dialog), accel_group) ;
}
XttGeGtk::XttGeGtk(GtkWidget* xg_parent_wid, void* xg_parent_ctx,
const char* xg_name, const char* xg_filename, int xg_scrollbar, int xg_menu,
int xg_navigator, int xg_width, int xg_height, int x, int y,
double scan_time, const char* object_name, int use_default_access,
unsigned int access, unsigned int options, void* basewidget,
double* borders, int color_theme,
int (*xg_command_cb)(void*, char*, char*, void*),
int (*xg_get_current_objects_cb)(void*, pwr_sAttrRef**, int**),
int (*xg_is_authorized_cb)(void*, unsigned int),
void (*xg_keyboard_cb)(void*, void*, int, int))
: XttGe(xg_parent_ctx, xg_name, xg_filename, xg_scrollbar, xg_menu,
xg_navigator, xg_width, xg_height, x, y, scan_time, object_name,
use_default_access, access, options, color_theme, xg_command_cb,
xg_get_current_objects_cb, xg_is_authorized_cb, xg_keyboard_cb),
parent_wid(xg_parent_wid), nav_shell(0), value_dialog(0),
confirm_widget(0), message_dia_widget(0)
{
int window_width = 600;
int window_height = 500;
GdkGeometry geometry;
pwr_tStatus sts;
GtkMenuBar* menu_bar = NULL;
char title[300];
if (xg_width != 0 && xg_height != 0) {
window_width = xg_width;
window_height = xg_height;
} else {
sts = Graph::get_dimension(
filename, "pwrp_exe:", &window_width, &window_height);
if (EVEN(sts)) {
window_width = 600;
window_height = 500;
}
}
str_StrncpyCutOff(title, name, sizeof(title), 1);
char* titleutf8
= g_convert(title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
// Gtk
if (!(options & ge_mOptions_Embedded)) {
toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height",
window_height, "default-width", window_width, "title", titleutf8, NULL);
g_free(titleutf8);
float rd = 0.05;
if (window_width < 300 || window_height < 300)
rd = 0.2;
geometry.min_aspect = gdouble(window_width) / window_height * (1.0 - rd);
geometry.max_aspect = gdouble(window_width) / window_height * (1.0 + rd);
gtk_window_set_geometry_hints(
GTK_WINDOW(toplevel), GTK_WIDGET(toplevel), &geometry, GDK_HINT_ASPECT);
if (options & ge_mOptions_HideDecorations)
gtk_window_set_decorated(GTK_WINDOW(toplevel), FALSE);
if (options & ge_mOptions_Dialog) {
gtk_window_set_type_hint(
GTK_WINDOW(toplevel), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_widget_set_size_request(
GTK_WIDGET(toplevel), window_width, window_height);
gtk_window_set_resizable(GTK_WINDOW(toplevel), FALSE);
}
g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect(
toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon(toplevel);
if (basewidget) {
gtk_window_set_transient_for(
GTK_WINDOW(toplevel), GTK_WINDOW(basewidget));
}
if (options & ge_mOptions_IsMain)
CoWow::SetTransient(toplevel);
} else {
toplevel = parent_wid;
}
if (xg_menu) {
GtkAccelGroup* accel_g
= (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget* file_close
= gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget* file
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// View menu
GtkWidget* view_zoom_in
= gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect(
view_zoom_in, "activate", G_CALLBACK(activate_zoom_in), this);
gtk_widget_add_accelerator(view_zoom_in, "activate", accel_g, 'i',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* view_zoom_out
= gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect(
view_zoom_out, "activate", G_CALLBACK(activate_zoom_out), this);
gtk_widget_add_accelerator(view_zoom_out, "activate", accel_g, 'o',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* view_zoom_reset
= gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect(
view_zoom_reset, "activate", G_CALLBACK(activate_zoom_reset), this);
GtkMenu* view_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
GtkWidget* view
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget* help_help
= gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget* help
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
}
graph_form = gtk_vbox_new(FALSE, 0);
graph = new GraphGtk(this, graph_form, "Plant", &grow_widget, &sts,
"pwrp_exe:", graph_eMode_Runtime, scrollbar, 1, object_name,
use_default_access, access, 0, color_theme, ge_keyboard_cb);
// graph->set_scantime( scan_time);
graph->message_cb = &message_cb;
graph->close_cb = &graph_close_cb;
graph->init_cb = &graph_init_cb;
graph->change_value_cb = &ge_change_value_cb;
graph->confirm_cb = &confirm_cb;
graph->message_dialog_cb = &message_dialog_cb;
graph->command_cb = &ge_command_cb;
graph->display_in_xnav_cb = &ge_display_in_xnav_cb;
graph->is_authorized_cb = &ge_is_authorized_cb;
graph->get_current_objects_cb = &ge_get_current_objects_cb;
graph->popup_menu_cb = &ge_popup_menu_cb;
graph->call_method_cb = &ge_call_method_cb;
graph->sound_cb = &ge_sound_cb;
graph->eventlog_cb = &ge_eventlog_cb;
// g_signal_connect( graph_form, "check_resize", G_CALLBACK(action_resize),
// this);
g_signal_connect(((GraphGtk*)graph)->grow_widget, "size_allocate",
G_CALLBACK(action_resize), this);
if (xg_menu)
gtk_box_pack_start(
GTK_BOX(graph_form), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start(
GTK_BOX(graph_form), GTK_WIDGET(grow_widget), TRUE, TRUE, 0);
if (!(options & ge_mOptions_Embedded)) {
gtk_container_add(GTK_CONTAINER(toplevel), graph_form);
gtk_widget_show_all(toplevel);
if (navigator) {
// Create navigator popup
nav_shell = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height",
200, "default-width", 200, "title", "Navigator", NULL);
g_signal_connect(
nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
((GraphGtk*)graph)->create_navigator(nav_shell);
gtk_container_add(
GTK_CONTAINER(nav_shell), ((GraphGtk*)graph)->nav_widget);
gtk_widget_show_all(nav_shell);
((Graph*)graph)->set_nav_background_color();
}
if (!(x == 0 && y == 0)) {
// Set position
gtk_window_move(GTK_WINDOW(toplevel), x, y);
}
if (options & ge_mOptions_FullScreen)
gtk_window_fullscreen(GTK_WINDOW(toplevel));
else if (options & ge_mOptions_Maximize)
gtk_window_maximize(GTK_WINDOW(toplevel)); // TODO
else if (options & ge_mOptions_FullMaximize)
gtk_window_maximize(GTK_WINDOW(toplevel));
else if (options & ge_mOptions_Iconify)
gtk_window_iconify(GTK_WINDOW(toplevel));
else if (options & ge_mOptions_Invisible)
g_object_set(toplevel, "visible", FALSE, NULL);
} else {
gtk_widget_set_size_request(graph_form, window_width, window_height);
}
if (borders)
((Graph*)graph)->set_borders(borders);
if (streq(filename, "_none_") && xg_width == 0 && xg_height == 0) {
// Set size from current layout
double x0, y0, x1, y1, zoom;
float rd = 0.05;
grow_GetLayout(graph->grow->ctx, &x0, &y0, &x1, &y1);
grow_GetZoom(graph->grow->ctx, &zoom);
window_width = zoom * (x1 - x0);
window_height = zoom * (y1 - y0);
if (window_width < 300 || window_height < 300)
rd = 0.2;
geometry.min_aspect = gdouble(window_width) / window_height * (1.0 - rd);
geometry.max_aspect = gdouble(window_width) / window_height * (1.0 + rd);
gtk_window_set_geometry_hints(
GTK_WINDOW(toplevel), GTK_WIDGET(toplevel), &geometry, GDK_HINT_ASPECT);
gtk_widget_set_size_request(toplevel, window_width, window_height);
}
}
void
create_translatorchooser (HWND hwnd, TTRANSLATORCHOOSER *choose_t)
{
GtkWidget *translatorchooser, *dialog_vbox1, *fixed1, *l_diz,
*scrolledwindow1;
GtkWidget *clist1, *l_name, *l_file, *l_date, *l_size, *dialog_action_area1;
GtkWidget *hbuttonbox1, *b_finish, *b_cancel, *pixmap1;
guint b_finish_key, b_cancel_key;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GtkAccelGroup *accel_group;
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return;
accel_group = gtk_accel_group_new ();
translatorchooser = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (translatorchooser), "translatorchooser",
translatorchooser);
gtk_window_set_title (GTK_WINDOW (translatorchooser),
"Choose a Translator");
gtk_window_set_position (GTK_WINDOW (translatorchooser),
GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (translatorchooser), TRUE);
gtk_window_set_policy (GTK_WINDOW (translatorchooser), FALSE, FALSE, FALSE);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (translatorchooser);
#endif
dialog_vbox1 = GTK_DIALOG (translatorchooser)->vbox;
gtk_object_set_data (GTK_OBJECT (translatorchooser), "dialog_vbox1",
dialog_vbox1);
gtk_widget_show (dialog_vbox1);
fixed1 = gtk_fixed_new ();
gtk_widget_ref (fixed1);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "fixed1", fixed1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), fixed1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (fixed1), 6);
l_diz = gtk_label_new ("Select which ODBC Translator you want to use.");
gtk_widget_ref (l_diz);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "l_diz", l_diz,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_diz);
gtk_fixed_put (GTK_FIXED (fixed1), l_diz, 168, 16);
gtk_widget_set_uposition (l_diz, 168, 16);
gtk_widget_set_usize (l_diz, 325, 16);
gtk_label_set_justify (GTK_LABEL (l_diz), GTK_JUSTIFY_LEFT);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "scrolledwindow1",
scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_fixed_put (GTK_FIXED (fixed1), scrolledwindow1, 168, 32);
gtk_widget_set_uposition (scrolledwindow1, 168, 32);
gtk_widget_set_usize (scrolledwindow1, 320, 248);
clist1 = gtk_clist_new (4);
gtk_widget_ref (clist1);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "clist1", clist1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clist1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), 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 (szDriverColumnNames[0]);
gtk_widget_ref (l_name);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "l_name", l_name,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_name);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, l_name);
l_file = gtk_label_new (szDriverColumnNames[1]);
gtk_widget_ref (l_file);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "l_file", l_file,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_file);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, l_file);
l_date = gtk_label_new (szDriverColumnNames[2]);
gtk_widget_ref (l_date);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "l_date", l_date,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_date);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 2, l_date);
l_size = gtk_label_new (szDriverColumnNames[3]);
gtk_widget_ref (l_size);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "l_size", l_size,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_size);
gtk_clist_set_column_widget (GTK_CLIST (clist1), 3, l_size);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (translatorchooser);
pixmap =
gdk_pixmap_create_from_xpm_d (translatorchooser->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_ref (pixmap1);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "pixmap1",
pixmap1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap1);
gtk_fixed_put (GTK_FIXED (fixed1), pixmap1, 16, 16);
gtk_widget_set_uposition (pixmap1, 16, 16);
gtk_widget_set_usize (pixmap1, 136, 264);
dialog_action_area1 = GTK_DIALOG (translatorchooser)->action_area;
gtk_object_set_data (GTK_OBJECT (translatorchooser), "dialog_action_area1",
dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "hbuttonbox1",
hbuttonbox1, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE,
0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
b_finish = gtk_button_new_with_label ("");
b_finish_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_finish)->child),
"_Finish");
gtk_widget_add_accelerator (b_finish, "clicked", accel_group,
b_finish_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_finish);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "b_finish",
b_finish, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_finish);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_finish);
GTK_WIDGET_SET_FLAGS (b_finish, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_finish, "clicked", accel_group,
'F', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
b_cancel = gtk_button_new_with_label ("");
b_cancel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_cancel)->child),
"_Cancel");
gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
b_cancel_key, GDK_MOD1_MASK, 0);
gtk_widget_ref (b_cancel);
gtk_object_set_data_full (GTK_OBJECT (translatorchooser), "b_cancel",
b_cancel, (GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_cancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_cancel);
GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (b_cancel, "clicked", accel_group,
'C', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
/* Ok button events */
gtk_signal_connect (GTK_OBJECT (b_finish), "clicked",
GTK_SIGNAL_FUNC (translatorchooser_ok_clicked), choose_t);
/* Cancel button events */
gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
GTK_SIGNAL_FUNC (translatorchooser_cancel_clicked), choose_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (translatorchooser), "delete_event",
GTK_SIGNAL_FUNC (delete_event), choose_t);
gtk_signal_connect (GTK_OBJECT (translatorchooser), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
/* Translator list events */
gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
GTK_SIGNAL_FUNC (translator_list_select), choose_t);
gtk_window_add_accel_group (GTK_WINDOW (translatorchooser), accel_group);
addtranslators_to_list (clist1, translatorchooser);
choose_t->translatorlist = clist1;
choose_t->translator = NULL;
choose_t->mainwnd = translatorchooser;
choose_t->b_finish = b_finish;
gtk_widget_show_all (translatorchooser);
gtk_main ();
}
GtkWidget*
create_sheets_main_dialog (void)
{
GtkWidget *sheets_main_dialog;
GtkWidget *dialog_vbox1;
GtkWidget *table_sheets;
GtkWidget *vbuttonbox;
GtkWidget *button_copy;
GtkWidget *button_copy_all;
GtkWidget *button_move;
GtkWidget *button_move_all;
GtkWidget *optionmenu_right;
GtkWidget *optionmenu_right_menu;
GtkWidget *optionmenu_left;
GtkWidget *optionmenu_left_menu;
GtkWidget *glade_menuitem;
GtkWidget *scrolledwindow_left;
GtkWidget *scrolledwindow_right;
GtkWidget *dialog_action_area1;
GtkWidget *hbox1;
GtkWidget *button_new;
GtkWidget *button_move_up;
GtkWidget *button_move_down;
GtkWidget *button_edit;
GtkWidget *button_remove;
GtkWidget *button_apply;
GtkWidget *button_revert;
GtkWidget *button_close;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
sheets_main_dialog = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (sheets_main_dialog), "sheets_main_dialog", sheets_main_dialog);
gtk_window_set_title (GTK_WINDOW (sheets_main_dialog), _("Sheets and Objects"));
gtk_window_set_role(GTK_WINDOW(sheets_main_dialog), "sheets_main_dialog");
gtk_window_set_default_size (GTK_WINDOW (sheets_main_dialog), 506, 261);
gtk_window_set_resizable (GTK_WINDOW (sheets_main_dialog), TRUE);
dialog_vbox1 = GTK_DIALOG (sheets_main_dialog)->vbox;
gtk_object_set_data (GTK_OBJECT (sheets_main_dialog), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
table_sheets = gtk_table_new (2, 3, FALSE);
gtk_widget_ref (table_sheets);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "table_sheets", table_sheets,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table_sheets);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), table_sheets, TRUE, TRUE, 0);
vbuttonbox = gtk_vbutton_box_new ();
gtk_widget_ref (vbuttonbox);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "vbuttonbox", vbuttonbox,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbuttonbox);
gtk_table_attach (GTK_TABLE (table_sheets), vbuttonbox, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 17, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox), GTK_BUTTONBOX_SPREAD);
button_copy = gtk_button_new_with_label (_("<- Copy"));
gtk_widget_ref (button_copy);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_copy", button_copy,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_copy);
gtk_container_add (GTK_CONTAINER (vbuttonbox), button_copy);
gtk_widget_add_accelerator (button_copy, "clicked", accel_group,
GDK_c, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_copy_all = gtk_button_new_with_label (_("<- Copy All"));
gtk_widget_ref (button_copy_all);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_copy_all", button_copy_all,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_copy_all);
gtk_container_add (GTK_CONTAINER (vbuttonbox), button_copy_all);
button_move = gtk_button_new_with_label (_("<- Move"));
gtk_widget_ref (button_move);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move", button_move,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_move);
gtk_container_add (GTK_CONTAINER (vbuttonbox), button_move);
gtk_widget_add_accelerator (button_move, "clicked", accel_group,
GDK_m, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_move_all = gtk_button_new_with_label (_("<- Move All"));
gtk_widget_ref (button_move_all);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move_all", button_move_all,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_move_all);
gtk_container_add (GTK_CONTAINER (vbuttonbox), button_move_all);
optionmenu_right = gtk_option_menu_new ();
gtk_widget_ref (optionmenu_right);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "optionmenu_right", optionmenu_right,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (optionmenu_right);
gtk_table_attach (GTK_TABLE (table_sheets), optionmenu_right, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
optionmenu_right_menu = gtk_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_right), optionmenu_right_menu);
optionmenu_left = gtk_option_menu_new ();
gtk_widget_ref (optionmenu_left);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "optionmenu_left", optionmenu_left,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (optionmenu_left);
gtk_table_attach (GTK_TABLE (table_sheets), optionmenu_left, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
optionmenu_left_menu = gtk_menu_new ();
glade_menuitem = gtk_menu_item_new_with_label ("");
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu_left_menu), glade_menuitem);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_left), optionmenu_left_menu);
scrolledwindow_left = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow_left);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "scrolledwindow_left", scrolledwindow_left,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow_left);
gtk_table_attach (GTK_TABLE (table_sheets), scrolledwindow_left, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_left), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
scrolledwindow_right = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow_right);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "scrolledwindow_right", scrolledwindow_right,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow_right);
gtk_table_attach (GTK_TABLE (table_sheets), scrolledwindow_right, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow_right), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
dialog_action_area1 = GTK_DIALOG (sheets_main_dialog)->action_area;
gtk_object_set_data (GTK_OBJECT (sheets_main_dialog), "dialog_action_area1", dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
hbox1 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbox1, TRUE, TRUE, 0);
button_new = gtk_button_new_from_stock(GTK_STOCK_NEW);
gtk_widget_ref (button_new);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_new", button_new,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_new);
gtk_box_pack_start (GTK_BOX (hbox1), button_new, FALSE, TRUE, 0);
gtk_widget_add_accelerator (button_new, "clicked", accel_group,
GDK_n, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_move_up = gtk_button_new_from_stock (GTK_STOCK_GO_UP);
gtk_widget_ref (button_move_up);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move_up", button_move_up,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_move_up);
gtk_box_pack_start (GTK_BOX (hbox1), button_move_up, FALSE, TRUE, 0);
gtk_widget_add_accelerator (button_move_up, "clicked", accel_group,
GDK_u, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_move_down = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN);
gtk_widget_ref (button_move_down);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_move_down", button_move_down,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_move_down);
gtk_box_pack_start (GTK_BOX (hbox1), button_move_down, FALSE, TRUE, 0);
gtk_widget_add_accelerator (button_move_down, "clicked", accel_group,
GDK_d, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_edit = gtk_button_new(); /* _with_label (_("Edit")); */
{
GtkWidget *label;
label = gtk_label_new(_("Edit"));
gtk_widget_ref(label);
gtk_label_parse_uline(GTK_LABEL(label), _("_Edit"));
gtk_container_add(GTK_CONTAINER(button_edit), label);
gtk_widget_show(label);
}
gtk_widget_ref (button_edit);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_edit", button_edit,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_edit);
gtk_box_pack_start (GTK_BOX (hbox1), button_edit, FALSE, TRUE, 0);
gtk_widget_add_accelerator (button_edit, "clicked", accel_group,
GDK_e, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_remove = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_widget_ref (button_remove);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_remove", button_remove,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_remove);
gtk_box_pack_start (GTK_BOX (hbox1), button_remove, FALSE, TRUE, 0);
gtk_widget_add_accelerator (button_remove, "clicked", accel_group,
GDK_r, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
button_apply = gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_widget_ref (button_apply);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_apply", button_apply,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_apply);
gtk_box_pack_start (GTK_BOX (hbox1), button_apply, FALSE, TRUE, 0);
gtk_widget_set_sensitive (button_apply, FALSE);
button_revert = gtk_button_new_with_label(_("Revert"));
gtk_widget_ref (button_revert);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_revert", button_revert,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_revert);
gtk_box_pack_start (GTK_BOX (hbox1), button_revert, FALSE, TRUE, 0);
gtk_widget_set_sensitive (button_revert, FALSE);
button_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_widget_ref (button_close);
gtk_object_set_data_full (GTK_OBJECT (sheets_main_dialog), "button_close", button_close,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_close);
gtk_box_pack_start (GTK_BOX (hbox1), button_close, FALSE, TRUE, 0);
g_signal_connect (GTK_OBJECT (sheets_main_dialog), "delete_event",
G_CALLBACK (on_sheets_main_dialog_delete_event),
NULL);
g_signal_connect (GTK_OBJECT (button_copy), "clicked",
G_CALLBACK (on_sheets_dialog_button_copy_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_copy_all), "clicked",
G_CALLBACK (on_sheets_dialog_button_copy_all_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_move), "clicked",
G_CALLBACK (on_sheets_dialog_button_move_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_move_all), "clicked",
G_CALLBACK (on_sheets_dialog_button_move_all_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_new), "clicked",
G_CALLBACK (on_sheets_dialog_button_new_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_move_up), "clicked",
G_CALLBACK (on_sheets_dialog_button_move_up_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_move_down), "clicked",
G_CALLBACK (on_sheets_dialog_button_move_down_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_edit), "clicked",
G_CALLBACK (on_sheets_dialog_button_edit_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_remove), "clicked",
G_CALLBACK (on_sheets_dialog_button_remove_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_apply), "clicked",
G_CALLBACK (on_sheets_dialog_button_apply_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_revert), "clicked",
G_CALLBACK (on_sheets_dialog_button_revert_clicked),
NULL);
g_signal_connect (GTK_OBJECT (button_close), "clicked",
G_CALLBACK (on_sheets_dialog_button_close_clicked),
NULL);
gtk_window_add_accel_group (GTK_WINDOW (sheets_main_dialog), accel_group);
persistence_register_window(GTK_WINDOW(sheets_main_dialog));
return sheets_main_dialog;
}
GtkWidget * create_MessageBox( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * hbuttonbox1;
GtkWidget * Ok;
GtkAccelGroup * accel_group;
GtkStyle * pixmapstyle;
GdkPixmap * pixmapwid;
GdkBitmap * mask;
accel_group=gtk_accel_group_new();
MessageBox=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( MessageBox,"MessageBox" );
gtk_object_set_data( GTK_OBJECT( MessageBox ),"MessageBox",MessageBox );
gtk_widget_set_events( MessageBox,GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_VISIBILITY_NOTIFY_MASK );
gtk_window_set_title( GTK_WINDOW( MessageBox ),"MPlayer ..." );
gtk_window_set_position( GTK_WINDOW( MessageBox ),GTK_WIN_POS_CENTER );
gtk_window_set_modal( GTK_WINDOW( MessageBox ),TRUE );
gtk_window_set_policy( GTK_WINDOW( MessageBox ),TRUE,TRUE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( MessageBox ),"Message","MPlayer" );
gtk_widget_realize( MessageBox );
gtkAddIcon( MessageBox );
vbox1=AddVBox( AddDialogFrame( MessageBox ),0 );
hbox1=AddHBox( vbox1,1 );
pixmapstyle=gtk_widget_get_style( MessageBox );
pixmapwid=gdk_pixmap_colormap_create_from_xpm_d( MessageBox->window,gdk_colormap_get_system(),&mask,&pixmapstyle->bg[GTK_STATE_NORMAL],(gchar ** )warning_xpm );
WarningPixmap=gtk_pixmap_new( pixmapwid,mask );
pixmapwid=gdk_pixmap_colormap_create_from_xpm_d( MessageBox->window,gdk_colormap_get_system(),&mask,&pixmapstyle->bg[GTK_STATE_NORMAL],(gchar ** )error_xpm );
ErrorPixmap=gtk_pixmap_new( pixmapwid,mask );
gtk_widget_set_name( WarningPixmap,"pixmap1" );
gtk_widget_hide( WarningPixmap );
gtk_box_pack_start( GTK_BOX( hbox1 ),WarningPixmap,FALSE,FALSE,0 );
gtk_widget_set_usize( WarningPixmap,55,-2 );
gtk_widget_set_name( ErrorPixmap,"pixmap1" );
gtk_widget_hide( ErrorPixmap );
gtk_box_pack_start( GTK_BOX( hbox1 ),ErrorPixmap,FALSE,FALSE,0 );
gtk_widget_set_usize( ErrorPixmap,55,-2 );
gtkMessageBoxText=gtk_label_new( "Text jol. Ha ezt megerted,akkor neked nagyon jo a magyar tudasod,te." );
gtk_widget_set_name( gtkMessageBoxText,"gtkMessageBoxText" );
gtk_widget_show( gtkMessageBoxText );
gtk_box_pack_start( GTK_BOX( hbox1 ),gtkMessageBoxText,TRUE,TRUE,0 );
// gtk_label_set_justify( GTK_LABEL( gtkMessageBoxText ),GTK_JUSTIFY_FILL );
gtk_label_set_justify( GTK_LABEL( gtkMessageBoxText ),GTK_JUSTIFY_CENTER );
gtk_label_set_line_wrap( GTK_LABEL( gtkMessageBoxText ),FALSE );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( MessageBox ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&MessageBox );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( on_Ok_released ),NULL );
gtk_window_add_accel_group( GTK_WINDOW( MessageBox ),accel_group );
return MessageBox;
}
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
{
GtkWidget *menuItem;
wxString text;
GtkLabel* label = NULL;
if ( mitem->IsSeparator() )
{
// TODO
menuItem = gtk_menu_item_new();
}
else if (mitem->GetBitmap().IsOk())
{
text = mitem->wxMenuItemBase::GetItemLabel();
const wxBitmap *bitmap = &mitem->GetBitmap();
// TODO
wxUnusedVar(bitmap);
menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );
label = GTK_LABEL( GTK_BIN(menuItem)->child );
m_prevRadio = NULL;
}
else // a normal item
{
// text has "_" instead of "&" after mitem->SetItemLabel() so don't use it
text = mitem->wxMenuItemBase::GetItemLabel() ;
switch ( mitem->GetKind() )
{
case wxITEM_CHECK:
{
menuItem = gtk_check_menu_item_new_with_label( wxGTK_CONV( text ) );
label = GTK_LABEL( GTK_BIN(menuItem)->child );
// set new text
gtk_label_set_text( label, wxGTK_CONV( text ) );
m_prevRadio = NULL;
break;
}
case wxITEM_RADIO:
{
GSList *group = NULL;
if ( m_prevRadio == NULL )
{
// start of a new radio group
m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );
label = GTK_LABEL( GTK_BIN(menuItem)->child );
// set new text
gtk_label_set_text( label, wxGTK_CONV( text ) );
}
else // continue the radio group
{
group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (m_prevRadio));
m_prevRadio = menuItem = gtk_radio_menu_item_new_with_label( group, wxGTK_CONV( text ) );
label = GTK_LABEL( GTK_BIN(menuItem)->child );
}
break;
}
default:
wxFAIL_MSG( wxT("unexpected menu item kind") );
// fall through
case wxITEM_NORMAL:
{
menuItem = gtk_menu_item_new_with_label( wxGTK_CONV( text ) );
label = GTK_LABEL( GTK_BIN(menuItem)->child );
m_prevRadio = NULL;
break;
}
}
}
guint accel_key;
GdkModifierType accel_mods;
wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*mitem) );
// wxPrintf( wxT("item: %s hotkey %s\n"), mitem->GetItemLabel().c_str(), GetGtkHotKey(*mitem).c_str() );
gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
if (accel_key != 0)
{
gtk_widget_add_accelerator (GTK_WIDGET(menuItem),
"activate",
m_accel,
accel_key,
accel_mods,
GTK_ACCEL_VISIBLE);
}
if (pos == -1)
gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), menuItem);
else
gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
gtk_widget_show( menuItem );
if ( !mitem->IsSeparator() )
{
wxASSERT_MSG( menuItem, wxT("invalid menuitem") );
gtk_signal_connect( GTK_OBJECT(menuItem), "select",
GTK_SIGNAL_FUNC(gtk_menu_hilight_callback),
(gpointer)this );
gtk_signal_connect( GTK_OBJECT(menuItem), "deselect",
GTK_SIGNAL_FUNC(gtk_menu_nolight_callback),
(gpointer)this );
if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
{
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
gtk_widget_show( mitem->GetSubMenu()->m_menu );
}
else
{
gtk_signal_connect( GTK_OBJECT(menuItem), "activate",
GTK_SIGNAL_FUNC(gtk_menu_clicked_callback),
(gpointer)this );
}
guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( text ) );
if (accel_key != GDK_VoidSymbol)
{
gtk_widget_add_accelerator (menuItem,
"activate_item",
gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menu)),
accel_key,
GDK_MOD1_MASK,
GTK_ACCEL_LOCKED);
}
}
mitem->SetMenuItem(menuItem);
if (ms_locked)
{
// This doesn't even exist!
// gtk_widget_lock_accelerators(mitem->GetMenuItem());
}
return true;
}
WCrrGtk::WCrrGtk(
GtkWidget *xa_parent_wid,
void *xa_parent_ctx,
ldh_tSesContext xa_ldhses,
pwr_sAttrRef *xa_objar,
int xa_advanced_user,
int *xa_sts) :
WCrr( xa_parent_ctx, xa_objar, xa_advanced_user, xa_sts),
parent_wid(xa_parent_wid)
{
int sts;
char *namep;
int size;
pwr_tAName title;
*xa_sts = ldh_AttrRefToName( xa_ldhses, &objar, cdh_mNName, &namep, &size);
if ( EVEN(*xa_sts)) return;
strncpy( title, namep, sizeof(title));
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 420,
"default-width", 600,
"title", CoWowGtk::convert_utf8(title),
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget *functions_open_plc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open _Program"));
g_signal_connect( functions_open_plc, "activate",
G_CALLBACK(activate_openplc), this);
gtk_widget_add_accelerator( functions_open_plc, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// Help entry
GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
xcrrnav = new WAttNavGtk( (void *)this, wattnav_eType_CrossRef, vbox, "Plant", xa_ldhses,
objar, 0, xa_advanced_user, 1, wb_eUtility_AttributeEditor, &brow_widget,
&sts);
// xcrrnav->popup_menu_cb = &xcrr_popup_menu_cb;
// xcrrnav->start_trace_cb = &xcrr_start_trace_cb;
// xcrrnav->close_cb = &xcrr_close_cb;
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
*xa_sts = XATT__SUCCESS;
}
WbExpWGtk::WbExpWGtk (
void *expw_parent_ctx,
GtkWidget *expw_parent_wid,
ldh_tSession expw_ldhses,
const char *expw_name,
int l_type,
int l_editmode,
pwr_tStatus *status) :
WbExpW( expw_parent_ctx, expw_ldhses, expw_name, l_type, l_editmode, status), parent_wid(expw_parent_wid)
{
const int window_width = 1100;
const int window_height = 600;
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", expw_name,
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(WbExpWGtk::action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(WbExpWGtk::activate_exit), this);
file_export = gtk_menu_item_new_with_mnemonic( btext);
g_signal_connect(file_export, "activate", G_CALLBACK(WbExpWGtk::activate_export), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_export);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Edit menu
GtkWidget *edit_update = gtk_menu_item_new_with_mnemonic( "_Update");
g_signal_connect(edit_update, "activate", G_CALLBACK(WbExpWGtk::activate_update), this);
gtk_widget_add_accelerator( edit_update, "activate", accel_g,
'u', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
edit_check_all = gtk_menu_item_new_with_mnemonic( "_Check all");
g_signal_connect(edit_check_all, "activate", G_CALLBACK(WbExpWGtk::activate_check_all), this);
edit_check_clear = gtk_menu_item_new_with_mnemonic( "C_heck clear");
g_signal_connect(edit_check_clear, "activate", G_CALLBACK(WbExpWGtk::activate_check_clear), this);
edit_check_reset = gtk_menu_item_new_with_mnemonic( "Check _reset");
g_signal_connect(edit_check_reset, "activate", G_CALLBACK(WbExpWGtk::activate_check_reset), this);
edit_show_all = gtk_check_menu_item_new_with_mnemonic( "_Show all");
g_signal_connect( edit_show_all, "activate",
G_CALLBACK(activate_show_all), this);
gtk_widget_add_accelerator( edit_show_all, "activate", accel_g,
'a', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkMenu *edit_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_update);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_all);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_clear);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_check_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_show_all);
GtkWidget *edit = gtk_menu_item_new_with_mnemonic("_Edit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), GTK_WIDGET(edit_menu));
// View menu
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(WbExpWGtk::activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(WbExpWGtk::activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(WbExpWGtk::activate_zoom_reset), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
GtkWidget *view = gtk_menu_item_new_with_mnemonic("_View");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Help Entry
GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(WbExpWGtk::activate_help), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
pwr_tFileName fname;
GtkWidget *tools_export = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/wb_export.png");
gtk_container_add( GTK_CONTAINER(tools_export),
gtk_image_new_from_file( fname));
g_signal_connect(tools_export, "clicked", G_CALLBACK(activate_export), this);
g_object_set( tools_export, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_export, action, "");
GtkWidget *tools_update = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_update.png");
gtk_container_add( GTK_CONTAINER(tools_update),
gtk_image_new_from_file( fname));
g_signal_connect(tools_update, "clicked", G_CALLBACK(activate_update), this);
g_object_set( tools_update, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_update, "Update", "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
form = gtk_vbox_new( FALSE, 0);
// Create expwnav
expwnav = new WbExpWNavGtk( this, form, expw_ldhses, l_type, l_editmode, &nav_widget);
gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(form), GTK_WIDGET(nav_widget), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), form);
gtk_widget_show_all( toplevel);
wow = new CoWowGtk( toplevel);
show();
// expwnav->check_all();
}
GtkWidget * create_EquConfig( void )
{
GtkWidget * vbox1;
GtkWidget * table1;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
accel_group=gtk_accel_group_new();
EquConfig=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( EquConfig,"EquConfig" );
gtk_object_set_data( GTK_OBJECT( EquConfig ),"EquConfig",EquConfig );
gtk_widget_set_usize( EquConfig,350,260 );
GTK_WIDGET_SET_FLAGS( EquConfig,GTK_CAN_DEFAULT );
gtk_window_set_title( GTK_WINDOW( EquConfig ),MSGTR_ConfigureEqualizer );
gtk_window_set_position( GTK_WINDOW( EquConfig ),GTK_WIN_POS_CENTER );
// gtk_window_set_modal( GTK_WINDOW( EquConfig ),TRUE );
gtk_window_set_policy( GTK_WINDOW( EquConfig ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( EquConfig ),"EquConfig","MPlayer" );
gtk_widget_realize( EquConfig );
gtkAddIcon( EquConfig );
vbox1=AddVBox( AddDialogFrame( EquConfig ),0 );
table1=gtk_table_new( 6,2,FALSE );
gtk_widget_set_name( table1,"table1" );
gtk_widget_show( table1 );
gtk_box_pack_start( GTK_BOX( vbox1 ),table1,TRUE,TRUE,0 );
gtk_table_set_row_spacings( GTK_TABLE( table1 ),4 );
gtk_table_set_col_spacings( GTK_TABLE( table1 ),4 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Channel1,NULL ),
0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Channel2,NULL ),
0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Channel3,NULL ),
0,1,2,3,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Channel4,NULL ),
0,1,3,4,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Channel5,NULL ),
0,1,4,5,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Channel6,NULL ),
0,1,5,6,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CBChannel1=AddComboBox( NULL );
gtk_table_attach( GTK_TABLE( table1 ),CBChannel1,1,2,0,1,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CEChannel1=GTK_COMBO( CBChannel1 )->entry;
gtk_widget_set_name( CEChannel1,"CEChannel1" );
gtk_widget_show( CEChannel1 );
CBChannel2=AddComboBox( NULL );
gtk_table_attach( GTK_TABLE( table1 ),CBChannel2,1,2,1,2,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CEChannel2=GTK_COMBO( CBChannel2 )->entry;
gtk_widget_set_name( CEChannel2,"CEChannel2" );
gtk_widget_show( CEChannel2 );
CBChannel3=AddComboBox( NULL );
gtk_table_attach( GTK_TABLE( table1 ),CBChannel3,1,2,2,3,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CEChannel3=GTK_COMBO( CBChannel3 )->entry;
gtk_widget_set_name( CEChannel3,"CEChannel3" );
gtk_widget_show( CEChannel3 );
CBChannel4=AddComboBox( NULL );
gtk_table_attach( GTK_TABLE( table1 ),CBChannel4,1,2,3,4,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CEChannel4=GTK_COMBO( CBChannel4 )->entry;
gtk_widget_set_name( CEChannel4,"CEChannel4" );
gtk_widget_show( CEChannel4 );
CBChannel5=AddComboBox( NULL );
gtk_table_attach( GTK_TABLE( table1 ),CBChannel5,1,2,4,5,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CEChannel5=GTK_COMBO( CBChannel5 )->entry;
gtk_widget_set_name( CEChannel5,"CEChannel5" );
gtk_widget_show( CEChannel5 );
CBChannel6=AddComboBox( NULL );
gtk_table_attach( GTK_TABLE( table1 ),CBChannel6,1,2,5,6,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
CEChannel6=GTK_COMBO( CBChannel6 )->entry;
gtk_widget_set_name( CEChannel6,"CEChannel6" );
gtk_widget_show( CEChannel6 );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
ecOk=AddButton( MSGTR_Ok,hbuttonbox1 );
ecCancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( ecOk,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( ecCancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( EquConfig ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&EquConfig );
gtk_signal_connect( GTK_OBJECT( ecOk ),"clicked",GTK_SIGNAL_FUNC( ecButtonReleased ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( ecCancel ),"clicked",GTK_SIGNAL_FUNC( ecButtonReleased ),(void *)0 );
gtk_window_add_accel_group( GTK_WINDOW( EquConfig ),accel_group );
return EquConfig;
}
static GtkWidget *vte_create_popup_menu(void)
{
GtkWidget *menu, *item;
GtkAccelGroup *accel_group;
menu = gtk_menu_new();
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(main_widgets.window), accel_group);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
gtk_widget_add_accelerator(item, "activate", accel_group,
GDK_c, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_COPY));
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);
gtk_widget_add_accelerator(item, "activate", accel_group,
GDK_v, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PASTE));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_ALL, NULL);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_SELECTALL));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_with_mnemonic(_("_Set Path From Document"));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_CHANGEPATH));
item = gtk_image_menu_item_new_with_mnemonic(_("_Restart Terminal"));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_RESTARTTERMINAL));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PREFERENCES));
msgwin_menu_add_common_items(GTK_MENU(menu));
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
/* the IM submenu should always be the last item to be consistent with other GTK popup menus */
vc->im_submenu = gtk_menu_new();
item = gtk_image_menu_item_new_with_mnemonic(_("_Input Methods"));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), vc->im_submenu);
/* submenu populated after vte realized */
return menu;
}
GtkWidget * create_Equalizer( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * scrolledwindow1;
GtkWidget * table1;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
accel_group=gtk_accel_group_new();
Equalizer=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_set_name( Equalizer,MSGTR_Equalizer );
gtk_object_set_data( GTK_OBJECT( Equalizer ),MSGTR_Equalizer,Equalizer );
gtk_widget_set_usize( Equalizer,-1,256 );
gtk_window_set_title( GTK_WINDOW( Equalizer ),MSGTR_Equalizer );
gtk_window_set_position( GTK_WINDOW( Equalizer ),GTK_WIN_POS_CENTER );
gtk_window_set_policy( GTK_WINDOW( Equalizer ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( Equalizer ),"Equalizer","MPlayer" );
gtk_widget_realize( Equalizer );
gtkAddIcon( Equalizer );
vbox1=AddVBox( AddDialogFrame( Equalizer ),0 );
Notebook=gtk_notebook_new();
gtk_widget_set_name( Notebook,"Notebook" );
gtk_widget_show( Notebook );
gtk_box_pack_start( GTK_BOX( vbox1 ),Notebook,TRUE,TRUE,0 );
gtk_container_set_border_width( GTK_CONTAINER( Notebook ),1 );
hbox1=AddHBox( Notebook,0 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_set_name( scrolledwindow1,"scrolledwindow1" );
gtk_widget_show( scrolledwindow1 );
gtk_box_pack_start( GTK_BOX( hbox1 ),scrolledwindow1,FALSE,FALSE,0 );
gtk_widget_set_usize( scrolledwindow1,106,-2 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
ChannelsList=gtk_clist_new( 1 );
gtk_widget_set_name( ChannelsList,"ChannelsList" );
gtk_widget_show( ChannelsList );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),ChannelsList );
gtk_clist_set_column_width( GTK_CLIST( ChannelsList ),0,80 );
gtk_clist_column_titles_hide( GTK_CLIST( ChannelsList ) );
table1=gtk_table_new( 2,10,FALSE );
gtk_widget_set_name( table1,"table1" );
gtk_widget_show( table1 );
gtk_box_pack_start( GTK_BOX( hbox1 ),table1,FALSE,FALSE,0 );
gtk_table_set_row_spacings( GTK_TABLE( table1 ),4 );
gtk_table_set_col_spacings( GTK_TABLE( table1 ),9 );
A3125adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A3125=AddVScaler( A3125adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A3125,0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A6250adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A6250=AddVScaler( A6250adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A6250,1,2,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A125adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A125=AddVScaler( A125adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A125,2,3,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A250adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A250=AddVScaler( A250adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A250,3,4,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A500adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A500=AddVScaler( A500adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A500,4,5,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A1000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A1000=AddVScaler( A1000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A1000,5,6,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A2000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A2000=AddVScaler( A2000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A2000,6,7,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A4000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A4000=AddVScaler( A4000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A4000,7,8,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A8000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A8000=AddVScaler( A8000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A8000,8,9,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
A16000adj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-eqRange,eqRange,0.5,0,0 ) );
A16000=AddVScaler( A16000adj,NULL,-1 );
gtk_table_attach( GTK_TABLE( table1 ),A16000,9,10,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "31.25",NULL ),
0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "62.50",NULL ),
1,2,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "125",NULL ),
2,3,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "250",NULL ),
3,4,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "500",NULL ),
4,5,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "1000",NULL ),
5,6,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "2000",NULL ),
6,7,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "4000",NULL ),
7,8,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "8000",NULL ),
8,9,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( "16000",NULL ),
9,10,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_notebook_set_tab_label( GTK_NOTEBOOK( Notebook ),gtk_notebook_get_nth_page( GTK_NOTEBOOK( Notebook ),0 ),
AddLabel( MSGTR_EQU_Audio,NULL ) );
table1=gtk_table_new( 4,2,FALSE );
gtk_widget_set_name( table1,"table1" );
gtk_widget_show( table1 );
gtk_container_add( GTK_CONTAINER( Notebook ),table1 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Contrast,NULL ),
0,1,0,1,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Brightness,NULL ),
0,1,1,2,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Hue,NULL ),
0,1,2,3,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_table_attach( GTK_TABLE( table1 ),
AddLabel( MSGTR_EQU_Saturation,NULL ),
0,1,3,4,(GtkAttachOptions)( GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
VContrastadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VContrast=AddHScaler( VContrastadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VContrast,1,2,0,1,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VContrast,-1,45 );
VBrightnessadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VBrightness=AddHScaler( VBrightnessadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VBrightness,1,2,1,2,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VBrightness,-1,45 );
VHueadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VHue=AddHScaler( VHueadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VHue,1,2,2,3,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VHue,-1,45 );
VSaturationadj=GTK_ADJUSTMENT( gtk_adjustment_new( 0,-100,100,1,0,0 ) );
VSaturation=AddHScaler( VSaturationadj,NULL,1 );
gtk_table_attach( GTK_TABLE( table1 ),VSaturation,1,2,3,4,(GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),(GtkAttachOptions)( 0 ),0,0 );
gtk_widget_set_usize( VSaturation,-1,45 );
gtk_notebook_set_tab_label( GTK_NOTEBOOK( Notebook ),gtk_notebook_get_nth_page( GTK_NOTEBOOK( Notebook ),1 ),
AddLabel( MSGTR_EQU_Video,NULL ) );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
Config=AddButton( MSGTR_Config,hbuttonbox1 );
Clear=AddButton( MSGTR_Clear,hbuttonbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( Equalizer ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&Equalizer );
gtk_signal_connect( GTK_OBJECT( Equalizer ),"focus_in_event",GTK_SIGNAL_FUNC( eqFocus ),(void *)2 );
gtk_signal_connect( GTK_OBJECT( ChannelsList ),"select_row",GTK_SIGNAL_FUNC( eqSelectChannelsListRow ),NULL );
gtk_signal_connect( GTK_OBJECT( A3125 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( A6250 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( A125 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( A250 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( A500 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)4 );
gtk_signal_connect( GTK_OBJECT( A1000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)5 );
gtk_signal_connect( GTK_OBJECT( A2000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)6 );
gtk_signal_connect( GTK_OBJECT( A4000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)7 );
gtk_signal_connect( GTK_OBJECT( A8000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)8 );
gtk_signal_connect( GTK_OBJECT( A16000 ),"motion_notify_event",GTK_SIGNAL_FUNC( eqHScaleMotion ),(void*)9 );
gtk_signal_connect( GTK_OBJECT( VContrast ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( VBrightness ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( VHue ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( VSaturation ),"motion_notify_event",GTK_SIGNAL_FUNC( eqVScaleMotion ),(void *)4 );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( Clear ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)1 );
gtk_signal_connect( GTK_OBJECT( Config ),"clicked",GTK_SIGNAL_FUNC( eqButtonReleased ),(void *)2 );
gtk_signal_connect( GTK_OBJECT( Notebook ),"switch_page",GTK_SIGNAL_FUNC( eqNotebook ),NULL );
gtk_window_add_accel_group( GTK_WINDOW( Equalizer ),accel_group );
return Equalizer;
}
/**
* create_directory_config_window(): Create the Directory Configuration Window.
* @return Directory Configuration Window.
*/
GtkWidget* create_directory_config_window(void)
{
GdkPixbuf *directory_config_window_icon_pixbuf;
GtkWidget *vbox_dc;
GtkWidget *frame_direntry = NULL, *label_frame_direntry = NULL, *table_frame_direntry = NULL;
GtkWidget *label_direntry = NULL, *entry_direntry = NULL, *button_direntry = NULL;
GtkWidget *hbutton_box_dc_buttonRow;
GtkWidget *button_dc_Cancel, *button_dc_Apply, *button_dc_Save;
char tmp[64];
int dir = 0;
if (directory_config_window)
{
// Directory Configuration window is already created. Set focus.
gtk_widget_grab_focus(directory_config_window);
return NULL;
}
accel_group = gtk_accel_group_new();
// Create the Directory Configuration window.
CREATE_GTK_WINDOW(directory_config_window,
"directory_config_window",
"Configure Directories",
directory_config_window_icon_pixbuf, "Gens2.ico");
// Callbacks for if the window is closed.
g_signal_connect((gpointer)directory_config_window, "delete_event",
G_CALLBACK(on_directory_config_window_close), NULL);
g_signal_connect((gpointer)directory_config_window, "destroy_event",
G_CALLBACK(on_directory_config_window_close), NULL);
// Create the main VBox.
vbox_dc = gtk_vbox_new(FALSE, 10);
gtk_widget_set_name(vbox_dc, "vbox_dc");
gtk_widget_show(vbox_dc);
gtk_container_add(GTK_CONTAINER(directory_config_window), vbox_dc);
GLADE_HOOKUP_OBJECT(directory_config_window, vbox_dc, "vbox_dc");
// Create the directory entry frame.
frame_direntry = gtk_frame_new(NULL);
gtk_widget_set_name(frame_direntry, "frame_direntry");
gtk_container_set_border_width(GTK_CONTAINER(frame_direntry), 4);
gtk_frame_set_shadow_type(GTK_FRAME(frame_direntry), GTK_SHADOW_ETCHED_IN);
gtk_widget_show(frame_direntry);
gtk_box_pack_start(GTK_BOX(vbox_dc), frame_direntry, TRUE, TRUE, 0);
GLADE_HOOKUP_OBJECT(directory_config_window, frame_direntry, "frame_direntry");
// Add the frame label.
label_frame_direntry = gtk_label_new("<b><i>Configure Directories</i></b>");
gtk_widget_set_name(label_frame_direntry, "label_frame_direntry");
gtk_label_set_use_markup(GTK_LABEL(label_frame_direntry), TRUE);
gtk_widget_show(label_frame_direntry);
gtk_frame_set_label_widget(GTK_FRAME(frame_direntry), label_frame_direntry);
GLADE_HOOKUP_OBJECT(directory_config_window, label_frame_direntry, "label_frame_direntry");
// Add the frame table.
table_frame_direntry = gtk_table_new(1, 3, FALSE);
gtk_widget_set_name(table_frame_direntry, "table_frame_direntry");
gtk_container_set_border_width(GTK_CONTAINER(table_frame_direntry), 8);
gtk_table_set_row_spacings(GTK_TABLE(table_frame_direntry), 4);
gtk_table_set_col_spacings(GTK_TABLE(table_frame_direntry), 4);
gtk_widget_show(table_frame_direntry);
gtk_container_add(GTK_CONTAINER(frame_direntry), table_frame_direntry);
GLADE_HOOKUP_OBJECT(directory_config_window, table_frame_direntry, "table_frame_direntry");
// Create all directory entries.
while (DirEntries[dir].title)
{
// Check if the table needs to be resized.
if (dir > 0)
gtk_table_resize(GTK_TABLE(table_frame_direntry), dir + 1, 3);
// Create the label for this file.
sprintf(tmp, "label_%s", DirEntries[dir].tag);
label_direntry = gtk_label_new(DirEntries[dir].title);
gtk_widget_set_name(label_direntry, tmp);
gtk_widget_set_size_request(label_direntry, 100, -1);
gtk_misc_set_alignment(GTK_MISC(label_direntry), 0, 0.5);
gtk_widget_show(label_direntry);
gtk_table_attach(GTK_TABLE(table_frame_direntry), label_direntry,
0, 1, dir, dir + 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
GLADE_HOOKUP_OBJECT(directory_config_window, label_direntry, tmp);
// Create the entry for this file.
sprintf(tmp, "entry_%s", DirEntries[dir].tag);
entry_direntry = gtk_entry_new();
gtk_widget_set_name(entry_direntry, tmp);
gtk_entry_set_max_length(GTK_ENTRY(entry_direntry), GENS_PATH_MAX - 1);
gtk_entry_set_text(GTK_ENTRY(entry_direntry), DirEntries[dir].entry);
gtk_widget_set_size_request(entry_direntry, 250, -1);
gtk_widget_show(entry_direntry);
gtk_table_attach(GTK_TABLE(table_frame_direntry), entry_direntry,
1, 2, dir, dir + 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
GLADE_HOOKUP_OBJECT(directory_config_window, entry_direntry, tmp);
// Create the button for this file.
// TODO: Use an icon?
sprintf(tmp, "button_%s", DirEntries[dir].tag);
button_direntry = gtk_button_new_with_label("Change...");
gtk_widget_set_name(button_direntry, tmp);
gtk_widget_show(button_direntry);
gtk_table_attach(GTK_TABLE(table_frame_direntry), button_direntry,
2, 3, dir, dir + 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
g_signal_connect((gpointer)button_direntry, "clicked",
G_CALLBACK(on_button_dc_Change_clicked),
GINT_TO_POINTER(dir));
GLADE_HOOKUP_OBJECT(directory_config_window, button_direntry, tmp);
dir++;
}
// HButton Box for the row of buttons on the bottom of the window
hbutton_box_dc_buttonRow = gtk_hbutton_box_new();
gtk_widget_set_name(hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow");
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbutton_box_dc_buttonRow), GTK_BUTTONBOX_END);
gtk_widget_show(hbutton_box_dc_buttonRow);
gtk_box_pack_start(GTK_BOX(vbox_dc), hbutton_box_dc_buttonRow, FALSE, FALSE, 0);
GLADE_HOOKUP_OBJECT(directory_config_window, hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow");
// Cancel
button_dc_Cancel = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_set_name(button_dc_Cancel, "button_dc_cancel");
gtk_widget_show(button_dc_Cancel);
gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Cancel, FALSE, FALSE, 0);
gtk_widget_add_accelerator(button_dc_Cancel, "activate", accel_group,
GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0));
AddButtonCallback_Clicked(button_dc_Cancel, on_button_dc_Cancel_clicked);
GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Cancel, "button_dc_Cancel");
// Apply
button_dc_Apply = gtk_button_new_from_stock("gtk-apply");
gtk_widget_set_name(button_dc_Apply, "button_dc_Apply");
gtk_widget_show(button_dc_Apply);
gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Apply, FALSE, FALSE, 0);
gtk_widget_add_accelerator(button_dc_Apply, "activate", accel_group,
GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0));
AddButtonCallback_Clicked(button_dc_Apply, on_button_dc_Apply_clicked);
GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Apply, "button_dc_Apply");
// Save
button_dc_Save = gtk_button_new_from_stock("gtk-save");
gtk_widget_set_name(button_dc_Save, "button_dc_Save");
gtk_widget_show(button_dc_Save);
gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Save, FALSE, FALSE, 0);
gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group,
GDK_Return, (GdkModifierType)(0), (GtkAccelFlags)(0));
gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group,
GDK_KP_Enter, (GdkModifierType)(0), (GtkAccelFlags)(0));
AddButtonCallback_Clicked(button_dc_Save, on_button_dc_Save_clicked);
GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Save, "button_dc_Save");
// Add the accel group.
gtk_window_add_accel_group(GTK_WINDOW(directory_config_window), accel_group);
return directory_config_window;
}
WVselGtk::WVselGtk (
pwr_tStatus *status,
void *wv_parent_ctx,
GtkWidget *wv_parent_wid,
const char *wv_name,
ldh_tWBContext wv_wbctx,
char *volumename,
int (*bc_success)( void *, pwr_tVolumeId *, int),
void (*bc_cancel)(),
int (*bc_time_to_exit)( void *),
int show_volumes,
wb_eType wv_wb_type) :
WVsel(status,wv_parent_ctx,wv_name,wv_wbctx,volumename,bc_success,bc_cancel,
bc_time_to_exit,show_volumes,wv_wb_type), parent_wid(wv_parent_wid)
{
int sts;
pwr_tVolumeId volid, *volume_ptr;
pwr_tVolumeId volume;
pwr_tClassId classid;
char volname[80];
int size;
int volume_count;
int display_window;
GtkCellRenderer *text_renderer;
GtkTreeViewColumn *name_column;
strcpy( volname, "");
if ( volumename != NULL && *volumename != 0 && !show_volumes)
/* Start the navigater for this volume */
strcpy( volname, volumename);
else if ( !show_volumes && wb_type != wb_eType_Buffer)
{
/* If there is only one volume in the db, select this volume */
volume_count = 0;
sts = ldh_GetVolumeList( wbctx, &volume);
while ( ODD(sts) )
{
sts = ldh_GetVolumeClass( wbctx, volume, &classid);
if (EVEN(sts)) { *status = sts; return; }
if ( cdh_isClassVolumeClass( classid) ||
classid == pwr_eClass_WorkBenchVolume ||
volume == ldh_cRtVolume)
{
sts = ldh_GetNextVolume( wbctx, volume, &volume);
continue;
}
sts = ldh_VolumeIdToName( wbctx, volume, volname, sizeof(volname),
&size);
if (EVEN(sts)) { *status = sts; return; }
volume_count++;
sts = ldh_GetNextVolume( wbctx, volume, &volume);
}
if ( volume_count != 1)
strcpy( volname, "");
}
// If volume name is supplied, find this volume and open the navigator.
if ( strcmp( volname, "") && wb_type != wb_eType_Buffer)
/* Check syntax, if new volumes is found, show the window */
sts = check_volumelist( 1, &display_window);
if ( strcmp( volname, "") && !display_window)
{
sts = ldh_VolumeNameToId( wbctx, volname, &volid);
WFoe::error_msg(sts);
if ( ODD(sts))
{
volume_ptr = (pwr_tVolumeId *) calloc( 1, sizeof( pwr_tVolumeId));
*volume_ptr = volid;
(vsel_bc_success) ( (void *)this, volume_ptr, 1);
if (vsel_bc_cancel != NULL)
(vsel_bc_cancel) ();
*status = LOGIN__SUCCESS;
return;
}
else
printf( "-- Unable to open volume '%s', volume doesn't exist\n",
volname);
}
// Create the window
widgets.toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 400,
"default-width", 500,
"title", name,
NULL);
CoWowGtk::SetWindowIcon( widgets.toplevel);
// Menu
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(widgets.toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(WVselGtk::activate_close), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions Entry
GtkWidget *functions_showall = gtk_check_menu_item_new_with_mnemonic( "_Show All Volumes");
g_signal_connect( functions_showall, "activate",
G_CALLBACK(WVselGtk::activate_showall), this);
gtk_widget_add_accelerator( functions_showall, "activate", accel_g,
'a', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_showall);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// List widget
store = gtk_list_store_new( 1, G_TYPE_STRING);
widgets.volumelist = (GtkWidget *) g_object_new(GTK_TYPE_TREE_VIEW,
"model", store,
"rules-hint", TRUE,
"headers-visible", FALSE,
"reorderable", TRUE,
"enable-search", TRUE,
"search-column", 0,
NULL);
text_renderer = gtk_cell_renderer_text_new();
name_column = gtk_tree_view_column_new_with_attributes( NULL,
text_renderer,
"text", 0,
NULL);
g_object_set( name_column,
"resizable", TRUE,
"clickable", TRUE,
NULL);
gtk_tree_view_append_column( GTK_TREE_VIEW(widgets.volumelist), name_column);
GtkWidget *ok_button = gtk_button_new_with_label( "Ok");
gtk_widget_set_size_request( ok_button, 70, 25);
g_signal_connect( ok_button, "clicked",
G_CALLBACK(activate_ok), this);
GtkWidget *cancel_button = gtk_button_new_with_label( "Cancel");
gtk_widget_set_size_request( cancel_button, 70, 25);
g_signal_connect( cancel_button, "clicked",
G_CALLBACK(activate_cancel), this);
GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40);
gtk_box_pack_start( GTK_BOX(hboxbuttons), ok_button, FALSE, FALSE, 20);
gtk_box_pack_end( GTK_BOX(hboxbuttons), cancel_button, FALSE, FALSE, 20);
GtkWidget *scrolled_window = gtk_scrolled_window_new( NULL, NULL);
gtk_container_add( GTK_CONTAINER( scrolled_window), widgets.volumelist);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
gtk_box_pack_end( GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 10);
gtk_container_add( GTK_CONTAINER(widgets.toplevel), vbox);
gtk_widget_show_all( widgets.toplevel);
// GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(widgets.volumelist));
// gtk_tree_selection_set_mode( selection, GTK_SELECTION_SINGLE);
sts = load_volumelist();
WFoe::error_msg(sts);
// Set input focus to the scrolled list widget
gtk_widget_grab_focus( widgets.volumelist);
wow = new CoWowGtk( widgets.toplevel);
if ( wb_type != wb_eType_Buffer)
sts = check_volumelist( 0, &display_window);
*status = LOGIN__SUCCESS;
}
GtkUIManager *create_menu_bar(GtkWidget *window)
{
GtkUIManager *ifactory;
#if 0
gboolean flag_emacs = FALSE;
gchar *key_theme = NULL;
GtkSettings *settings = gtk_settings_get_default();
if (settings) {
g_object_get(settings, "gtk-key-theme-name", &key_theme, NULL);
if (key_theme) {
if (!g_ascii_strcasecmp(key_theme, "Emacs"))
flag_emacs = TRUE;
g_free(key_theme);
}
}
#endif
ifactory = gtk_ui_manager_new();
GtkActionGroup *actions = gtk_action_group_new("Actions");
gtk_action_group_set_translate_func(actions, menu_translate, NULL, NULL);
gtk_action_group_add_actions(actions, menu_items, nmenu_items, NULL);
gtk_action_group_add_toggle_actions (actions, toggle_entries, n_toggle_entries, NULL);
gtk_ui_manager_insert_action_group(ifactory, actions, 0);
g_object_unref(actions);
gtk_ui_manager_add_ui_from_string(ifactory, ui_info, -1, NULL);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
/* hidden keybinds */
gtk_accel_group_connect(
accel_group, GDK_W, GDK_CONTROL_MASK, 0,
g_cclosure_new_swap(G_CALLBACK(on_file_close), NULL, NULL));
gtk_accel_group_connect(
accel_group, GDK_T, GDK_CONTROL_MASK, 0,
g_cclosure_new_swap(G_CALLBACK(on_option_always_on_top), NULL, NULL));
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Edit/Redo"),
"activate", accel_group, GDK_Y, GDK_CONTROL_MASK, 0);
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindNext"),
"activate", accel_group, GDK_F3, 0, 0);
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindPrevious"),
"activate", accel_group, GDK_F3, GDK_SHIFT_MASK, 0);
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Search/Replace"),
"activate", accel_group, GDK_R, GDK_CONTROL_MASK, 0);
/* initialize sensitivities */
gtk_widget_set_sensitive(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindNext"),
FALSE);
gtk_widget_set_sensitive(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindPrevious"),
FALSE);
menu_item_save = gtk_ui_manager_get_widget(ifactory, "/M/File/Save");
menu_item_cut = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Cut");
menu_item_copy = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Copy");
menu_item_paste = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Paste");
menu_item_delete = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Delete");
menu_sensitivity_from_selection_bound(FALSE);
return ifactory;
}
static void browser_window_init(BrowserWindow *window)
{
g_atomic_int_inc(&windowCount);
gchar img_src_dir[BUFSIZE] = {0};
strcat(img_src_dir, get_cuprum_dir());
gchar img_source_1[BUFSIZE] = {0};
strcat(img_source_1, img_src_dir);
strcat(img_source_1, "/resources/img/1.png");
gchar img_source_2[BUFSIZE] = {0};
strcat(img_source_2, img_src_dir);
strcat(img_source_2, "/resources/img/2.png");
gtk_window_set_title(GTK_WINDOW(window), defaultWindowTitle);
gtk_window_set_default_size(GTK_WINDOW(window), 1000, 750);
window->uriEntry = gtk_entry_new();
g_signal_connect_swapped(window->uriEntry, "activate", G_CALLBACK(activateUriEntryCallback), (gpointer)window);
gtk_entry_set_icon_activatable(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_PRIMARY, FALSE);
g_signal_connect_swapped (G_OBJECT(window->uriEntry), "icon-press", G_CALLBACK(certificateCallback), window);
updateUriEntryIcon(window);
/* Keyboard accelerators */
window->accelGroup = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), window->accelGroup);
/* Global accelerators */
gtk_accel_group_connect(window->accelGroup, GDK_KEY_I, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(toggleWebInspector), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F12, 0, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(toggleWebInspector), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F11, 0, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(showFullscreen), window, NULL));
/* Reload page */
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F5, 0, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPage), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPage), window, NULL));
/* Reload page ignoring cache */
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F5, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPageIgnoringCache), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_R, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPageIgnoringCache), window, NULL));
//add by zgh menu
window->menubar = BROWSER_MENU_BAR(browser_menu_bar_new());
browser_menu_bar_add_accelerators(BROWSER_MENU_BAR(window->menubar), window->accelGroup);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_find", G_CALLBACK(menuSearchCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_zoom_in", G_CALLBACK(zoomInCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_zoom_out", G_CALLBACK(zoomOutCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_zoom_fit", G_CALLBACK(zoomFitCallback), window);
// g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_nopagestyle", G_CALLBACK(menuNopagestyleCallback), window);
// g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_webpagestyle", G_CALLBACK(menuWebpagestyleCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_fullscreen", G_CALLBACK(showFullscreen), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_bookmarkbar", G_CALLBACK(showBookmarkbar), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_history_manager", G_CALLBACK(showHistoryManagerWindow), window);//add by zlf
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_history_clear", G_CALLBACK(showHistoryClearWindow), window);//add by zlf
g_signal_connect(G_OBJECT(window->menubar), "menu_quit", G_CALLBACK(gtk_main_quit), window);
// gtk_container_set_border_width(GTK_CONTAINER(window->menubar), 0);
g_signal_connect(G_OBJECT(window->menubar), "button-press-event", G_CALLBACK(buttonmenuCallback), window);
GtkWidget *toolbar = gtk_toolbar_new();
window->toolbar = toolbar;
gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
// gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_container_set_border_width(GTK_CONTAINER(window->toolbar), 0);
g_signal_connect(G_OBJECT(toolbar), "button-press-event", G_CALLBACK(buttonmenuCallback), window);
GtkToolItem *item = gtk_menu_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
window->backItem = GTK_WIDGET(item);
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(item), 0);
g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
item = gtk_menu_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
window->forwardItem = GTK_WIDGET(item);
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(item), 0);
g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(goForwardCallback), (gpointer)window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
item = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
window->reloadOrStopButton = GTK_WIDGET(item);
g_signal_connect_swapped(item, "clicked", G_CALLBACK(reloadOrStopCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_add_accelerator(window->reloadOrStopButton, "clicked", window->accelGroup, GDK_KEY_F5, 0, GTK_ACCEL_VISIBLE);
gtk_widget_show(window->reloadOrStopButton);
item = gtk_tool_button_new_from_stock(GTK_STOCK_HOME);
window->homeButton = GTK_WIDGET(item);
g_signal_connect_swapped(item, "clicked", G_CALLBACK(homeButtonCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(window->homeButton);
gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_SECONDARY, create_pixbuf(img_source_1));
gtk_entry_set_icon_activatable(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_PRIMARY, TRUE);
gtk_entry_set_icon_tooltip_markup(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_SECONDARY, "将此页加为书签");
g_signal_connect_swapped (G_OBJECT(window->uriEntry), "icon-press", G_CALLBACK(collecturiCallback), window);
//by sunh
item = gtk_tool_button_new_from_stock(GTK_STOCK_GOTO_BOTTOM);
g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(downloadCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
//by sunh end
item = gtk_tool_item_new();
gtk_tool_item_set_expand(item, TRUE);
gtk_container_add(GTK_CONTAINER(item), window->uriEntry);
gtk_widget_show(window->uriEntry);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
//setting
item = gtk_tool_button_new_from_stock(GTK_STOCK_PREFERENCES);
g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(settingsCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
// -setting
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
window->mainBox = vbox;
gtk_widget_show_all(GTK_WIDGET(window->menubar));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(window->menubar), FALSE, FALSE, 0);
//<wangc add tab mamager
TabMng* tbmng=(TabMng*)malloc(sizeof(TabMng));
initTabMng(tbmng);
window->tabmng=tbmng;
GtkWidget *boxtab = gtk_box_new (FALSE, 0);
window->boxtab=boxtab;
GtkWidget * btab = gtk_button_new_with_label ("Add");
g_signal_connect (G_OBJECT (btab), "clicked",
G_CALLBACK (cbAddTab), window);
gtk_box_pack_start (GTK_BOX(boxtab), btab, FALSE, FALSE, 0);
gtk_widget_show (btab);
gtk_box_pack_start(GTK_BOX(vbox),boxtab,FALSE, FALSE, 0);
gtk_widget_show(boxtab);
//>
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show(toolbar);
//书签栏
GtkWidget *bookmarkbar = gtk_toolbar_new();
window->bookmarkbar = bookmarkbar;
/*
item =gtk_tool_item_new();
gtk_tool_item_set_expand(item, TRUE);
GtkWidget *bookmarkBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add(GTK_CONTAINER(item), bookmarkBox);
window->bookmarkbox = bookmarkBox;
gtk_toolbar_insert(GTK_TOOLBAR(bookmarkbar), item, 0);
gtk_widget_show(bookmarkBox);
gtk_widget_show(GTK_WIDGET(item));
*/
gtk_toolbar_set_icon_size (GTK_TOOLBAR (window->bookmarkbar),
GTK_ICON_SIZE_MENU);
gtk_toolbar_set_style (GTK_TOOLBAR (window->bookmarkbar),
GTK_TOOLBAR_BOTH);//GTK_TOOLBAR_BOTH_HORIZ
g_signal_connect(G_OBJECT(bookmarkbar), "button-press-event", G_CALLBACK(buttonmenuCallback), window);
gtk_box_pack_start(GTK_BOX(vbox), bookmarkbar, FALSE, FALSE, 0);
// gtk_widget_show(bookmarkbar);
/*
GtkWidget *status_bar = gtk_label_new("");
gtk_label_set_width_chars(GTK_LABEL(status_bar), 50);
gtk_misc_set_alignment(GTK_MISC(status_bar), 0, 0);
gtk_box_pack_end(GTK_BOX(vbox), status_bar, FALSE, FALSE, 0);
// gtk_widget_show(status_bar);
*/
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
HS_init(window);// add by zlf
}
GtkWindow * gw_progress_bar_box_create ( GtkWindow *window, gchar *title, gchar *subject, gchar *text, gfloat max, func_stop_progress_t stop, gpointer p)
{
GtkWidget *w = NULL;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *file_name;
GtkWidget *progress_bar = NULL;
GtkWidget *button;
guint button_key;
GtkAccelGroup *accel = NULL;
gchar *text_utf8 = NULL;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : %f\n", __FILE__, __LINE__, __PRETTY_FUNCTION__, max);
#endif
/* Inits accel group for keystroke shortcuts */
accel = gtk_accel_group_new ( );
if ( !w )
{
w = gtk_window_new ( GTK_WINDOW_DIALOG);
gtk_window_set_policy ( GTK_WINDOW ( w), FALSE, FALSE, FALSE);
g_strdup_to_gtk_text ( title, text_utf8);
gtk_window_set_title ( GTK_WINDOW ( w), text_utf8);
g_free ( text_utf8);
gtk_container_border_width ( GTK_CONTAINER ( w), 5);
gtk_window_set_modal ( GTK_WINDOW ( w),TRUE);
gtk_window_set_transient_for ( GTK_WINDOW ( w), window);
gtk_window_set_position ( GTK_WINDOW ( w), GTK_WIN_POS_CENTER);
gtk_widget_ref ( GTK_WIDGET ( window));
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_PROGRESS_BAR_BOX_PARENT_WINDOW, window, (GtkDestroyNotify) gtk_widget_unref);
if ( stop != NULL )
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : connect signals on delete_event and destroy\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
/* These signals do nothing. In this way the window cannot be destroyed. What must be done when stop is NULL? */
gtk_signal_connect ( GTK_OBJECT ( w), "delete_event", GTK_SIGNAL_FUNC ( gw_progress_bar_box_signal_do_nothing), NULL);
gtk_signal_connect ( GTK_OBJECT ( w), "destroy", GTK_SIGNAL_FUNC ( gw_progress_bar_box_signal_do_nothing), NULL);
}
g_strdup_to_gtk_text ( subject, text_utf8);
frame = gtk_frame_new ( text_utf8);
g_free ( text_utf8);
gtk_container_add ( GTK_CONTAINER ( w), frame);
vbox = gtk_vbox_new ( FALSE, 0);
gtk_container_add ( GTK_CONTAINER ( frame), vbox);
gtk_container_set_border_width ( GTK_CONTAINER ( vbox), 10);
g_strdup_to_gtk_text ( text, text_utf8);
file_name = gtk_label_new ( text_utf8);
g_free ( text_utf8);
/* Store the reference to the text info label to describe the current processing. */
gtk_widget_ref ( file_name);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_PROGRESS_BAR_BOX_TEXT_INFO_LABEL, file_name, (GtkDestroyNotify) gtk_widget_unref);
gtk_label_set_justify ( GTK_LABEL ( file_name), GTK_JUSTIFY_LEFT);
gtk_box_pack_start ( GTK_BOX ( vbox), file_name, TRUE, TRUE, 0);
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : creates the real progress bar\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
progress_bar = gtk_progress_bar_new ( );
/* Store reference to the real progress bar */
gtk_widget_ref ( progress_bar);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_PROGRESS_BAR_BOX_PROGRESS_BAR, progress_bar, (GtkDestroyNotify) gtk_widget_unref);
/* Doesn't show the progress bar if max value is 0 */
if ( max > 0 )
{
gtk_progress_configure ( GTK_PROGRESS ( progress_bar), 0, 0, max);
gtk_progress_set_show_text ( GTK_PROGRESS ( progress_bar), TRUE);
/* Set the format string of progess state visualization */
g_strdup_to_gtk_text ( GW_PROGRESS_BAR_BOX_PROGRESS_BAR_FORMAT_STRING, text_utf8);
gtk_progress_set_format_string ( GTK_PROGRESS ( progress_bar), text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( vbox), progress_bar, TRUE, TRUE, 0);
}
hbox = gtk_hbox_new ( TRUE, 10);
gtk_container_add ( GTK_CONTAINER ( vbox), hbox);
gtk_container_set_border_width ( GTK_CONTAINER ( hbox), 5);
button = gtk_button_new_with_label ( "");
/* Store reference to the ok/cancel button */
gtk_widget_ref ( button);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_PROGRESS_BAR_BOX_OK_CANCEL_BUTTON, button, (GtkDestroyNotify) gtk_widget_unref);
gw_progress_bar_box_set_state ( GTK_WINDOW ( w), STATE_CANCEL);
g_strdup_to_gtk_text ( _( "_Cancel"), text_utf8);
button_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( button)->child), text_utf8);
g_free ( text_utf8);
gtk_widget_add_accelerator ( button, "clicked", accel, button_key, GDK_MOD1_MASK, 0);
gtk_object_set_user_data ( GTK_OBJECT ( button), w);
gtk_box_pack_start ( GTK_BOX ( hbox), button, TRUE, TRUE, 0);
gtk_widget_grab_focus ( button);
if ( stop != NULL )
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : connect custom callback on ok/cancel button\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_signal_connect ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( stop), p);
}
else
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : connect standard callback on ok/cancel button\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_signal_connect ( GTK_OBJECT ( button), "clicked", GTK_SIGNAL_FUNC ( gw_progress_bar_box_ok_cancel_click), w);
}
gtk_window_add_accel_group ( GTK_WINDOW ( w), accel);
}
if ( !GTK_WIDGET_VISIBLE ( w) )
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : show window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_widget_show_all ( w);
}
else
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : destroy window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_widget_destroy ( w);
}
return GTK_WINDOW ( w);
}
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *filemenu, *item_file, *item_new, *item_open,*item_quit;
GtkWidget *editmenu, *item_edit, *item_undo, *item_redo, *item_cut, *item_copy, *item_paste;
GtkWidget *sep;
GtkAccelGroup *accel_group = NULL; //定义快捷键组
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
gtk_window_set_title(GTK_WINDOW(window), "menu better");
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = gtk_menu_bar_new(); //菜单栏构件（menubar），实际上是一个menu shell
filemenu = gtk_menu_new(); //菜单构件(menu),也是一个menu shell
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
item_file = gtk_menu_item_new_with_mnemonic("_File"); //替代 gtk_menu_item_new_with_label("File");
item_new = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL); //替代gtk_menu_item_new_with_label("New");
item_open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);//替代gtk_menu_item_new_with_label("Open");
sep = gtk_separator_menu_item_new(); //生成一条分割线
item_quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,accel_group);//替代gtk_menu_item_new_with_label("Quit");
gtk_widget_add_accelerator(item_quit, "activate", accel_group, GDK_q,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_new);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_open);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep); //加入分割线到file菜单中
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), item_quit); //把“quit”菜单选项被填加进file菜单中
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_file); //把“file”菜单选项被填加进菜单中（menubar）
/*这里构建Edit菜单，同上面的file菜单添加方法一样*/
editmenu = gtk_menu_new(); //菜单构件(menu),也是一个menu shell
item_edit = gtk_menu_item_new_with_mnemonic("_Edit");
item_undo = gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, NULL);
item_redo = gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, NULL);
sep = gtk_separator_menu_item_new();
item_cut = gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, NULL);
item_copy = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
item_paste = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);
gtk_widget_add_accelerator(item_undo, "activate", accel_group, GDK_z,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(item_redo, "activate", accel_group, GDK_r,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(item_cut, "activate", accel_group, GDK_x,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(item_copy, "activate", accel_group, GDK_c,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(item_paste, "activate", accel_group, GDK_v,GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_edit), editmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_undo);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_redo);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), sep);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_cut);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_copy);
gtk_menu_shell_append(GTK_MENU_SHELL(editmenu), item_paste);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_edit); //把“edit”菜单选项被填加进菜单中（menubar）
/*这里把窗口分为了上中下3个区域，最上面是menubar*/
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
g_signal_connect(G_OBJECT(item_quit),
"activate",G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void wxMenuItem::SetItemLabel( const wxString& string )
{
wxString str = string;
if ( str.empty() && !IsSeparator() )
{
wxASSERT_MSG(wxIsStockID(GetId()), wxT("A non-stock menu item with an empty label?"));
str = wxGetStockLabel(GetId(), wxSTOCK_WITH_ACCELERATOR |
wxSTOCK_WITH_MNEMONIC);
}
// Some optimization to avoid flicker
wxString oldLabel = m_text;
oldLabel = wxStripMenuCodes(oldLabel);
oldLabel.Replace(wxT("_"), wxEmptyString);
wxString label1 = wxStripMenuCodes(str);
wxString oldhotkey = GetHotKey(); // Store the old hotkey in Ctrl-foo format
wxCharBuffer oldbuf = wxGTK_CONV( GetGtkHotKey(*this) ); // and as <control>foo
DoSetText(str);
if (oldLabel == label1 &&
oldhotkey == GetHotKey()) // Make sure we can change a hotkey even if the label is unaltered
return;
if (m_menuItem)
{
GtkLabel *label;
if (m_labelWidget)
label = (GtkLabel*) m_labelWidget;
else
label = GTK_LABEL( GTK_BIN(m_menuItem)->child );
// set new text
gtk_label_set( label, wxGTK_CONV( m_text ) );
// reparse key accel
(void)gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV(m_text) );
gtk_accel_label_refetch( GTK_ACCEL_LABEL(label) );
}
guint accel_key;
GdkModifierType accel_mods;
gtk_accelerator_parse( (const char*) oldbuf, &accel_key, &accel_mods);
if (accel_key != 0)
{
gtk_widget_remove_accelerator( GTK_WIDGET(m_menuItem),
m_parentMenu->m_accel,
accel_key,
accel_mods );
}
wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*this) );
gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
if (accel_key != 0)
{
gtk_widget_add_accelerator( GTK_WIDGET(m_menuItem),
"activate",
m_parentMenu->m_accel,
accel_key,
accel_mods,
GTK_ACCEL_VISIBLE);
}
}
int
main (int argc, char **argv)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *optionmenu;
GtkWidget *separator;
gtk_init (&argc, &argv);
if (!window)
{
GtkWidget *menubar;
GtkWidget *menu;
GtkWidget *submenu;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_true), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "menus");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_menu (2, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("dynamic");
submenu = create_menu (3, TRUE);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
gdk_threads_add_timeout (250, change_item, submenu);
menuitem = gtk_menu_item_new_with_label ("bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
menu = create_menu (1, FALSE);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F1,
0,
GTK_ACCEL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F2,
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F2,
0,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F3,
0,
GTK_ACCEL_VISIBLE);
optionmenu = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
gtk_widget_show (optionmenu);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK(gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
gtk_main ();
return 0;
}
static GtkWidget *create_window(void)
{
GtkWidget *startwin;
GtkWidget *hlayout;
GtkWidget *banner;
GtkWidget *vlayout;
GtkWidget *tabs;
GtkWidget *configvlayout;
GtkWidget *configlayout;
GtkWidget *vmode3dlabel;
GtkWidget *vmode3dcombo;
GtkWidget *fullscreencheck;
GtkWidget *alwaysshowcheck;
GtkWidget *configtab;
GtkWidget *messagesscroll;
GtkWidget *messagestext;
GtkWidget *messagestab;
GtkWidget *buttons;
GtkWidget *cancelbutton;
GtkWidget *cancelbuttonalign;
GtkWidget *cancelbuttonlayout;
GtkWidget *cancelbuttonicon;
GtkWidget *cancelbuttonlabel;
GtkWidget *startbutton;
GtkWidget *startbuttonalign;
GtkWidget *startbuttonlayout;
GtkWidget *startbuttonicon;
GtkWidget *startbuttonlabel;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
// Basic window
startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (startwin), apptitle); // NOTE: use global app title
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);
// Horizontal layout of banner and controls
hlayout = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hlayout);
gtk_container_add (GTK_CONTAINER (startwin), hlayout);
// Banner
{
GdkPixbuf *pixbuf = load_banner();
banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_widget_show (banner);
gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
vlayout = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vlayout);
gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0);
// Tab control
tabs = gtk_notebook_new ();
gtk_widget_show (tabs);
gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (tabs), 4);
// Vertical layout of config page main body
configvlayout = gtk_vbox_new (FALSE, 0);
gtk_widget_show (configvlayout);
gtk_container_add (GTK_CONTAINER (tabs), configvlayout);
// Fixed-position layout of config page controls
configlayout = gtk_fixed_new ();
gtk_widget_show (configlayout);
gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6);
// 3D video mode label
vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:");
gtk_widget_show (vmode3dlabel);
gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0);
gtk_widget_set_size_request (vmode3dlabel, 88, 29);
gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
vmode3dcombo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL);
}
gtk_widget_show (vmode3dcombo);
gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0);
gtk_widget_set_size_request (vmode3dcombo, 150, 29);
gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group,
GDK_V, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Fullscreen checkbox
fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen");
gtk_widget_show (fullscreencheck);
gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0);
gtk_widget_set_size_request (fullscreencheck, 85, 29);
gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group,
GDK_F, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Always show config checkbox
alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start");
gtk_widget_show (alwaysshowcheck);
gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0);
gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group,
GDK_A, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Configuration tab
configtab = gtk_label_new ("Configuration");
gtk_widget_show (configtab);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab);
// Messages scrollable area
messagesscroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (messagesscroll);
gtk_container_add (GTK_CONTAINER (tabs), messagesscroll);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
messagestext = gtk_text_view_new ();
gtk_widget_show (messagestext);
gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext);
gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2);
// Messages tab
messagestab = gtk_label_new ("Messages");
gtk_widget_show (messagestab);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), messagestab);
// Dialogue box buttons layout
buttons = gtk_hbutton_box_new ();
gtk_widget_show (buttons);
gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (buttons), 3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END);
// Cancel button
cancelbutton = gtk_button_new ();
gtk_widget_show (cancelbutton);
gtk_container_add (GTK_CONTAINER (buttons), cancelbutton);
GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group,
GDK_C, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group,
GDK_Escape, 0,
GTK_ACCEL_VISIBLE);
cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (cancelbuttonalign);
gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign);
cancelbuttonlayout = gtk_hbox_new (FALSE, 2);
gtk_widget_show (cancelbuttonlayout);
gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout);
cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (cancelbuttonicon);
gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0);
cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel");
gtk_widget_show (cancelbuttonlabel);
gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
startbutton = gtk_button_new ();
gtk_widget_show (startbutton);
gtk_container_add (GTK_CONTAINER (buttons), startbutton);
GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group,
GDK_S, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (startbutton, "clicked", accel_group,
GDK_Return, 0,
GTK_ACCEL_VISIBLE);
startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (startbuttonalign);
gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign);
startbuttonlayout = gtk_hbox_new (FALSE, 2);
gtk_widget_show (startbuttonlayout);
gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout);
startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (startbuttonicon);
gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0);
startbuttonlabel = gtk_label_new_with_mnemonic ("_Start");
gtk_widget_show (startbuttonlabel);
gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect ((gpointer) startwin, "delete_event",
G_CALLBACK (on_startwin_delete_event),
NULL);
g_signal_connect ((gpointer) vmode3dcombo, "changed",
G_CALLBACK (on_vmode3dcombo_changed),
NULL);
g_signal_connect ((gpointer) fullscreencheck, "toggled",
G_CALLBACK (on_fullscreencheck_toggled),
NULL);
g_signal_connect ((gpointer) alwaysshowcheck, "toggled",
G_CALLBACK (on_alwaysshowcheck_toggled),
NULL);
g_signal_connect ((gpointer) cancelbutton, "clicked",
G_CALLBACK (on_cancelbutton_clicked),
NULL);
g_signal_connect ((gpointer) startbutton, "clicked",
G_CALLBACK (on_startbutton_clicked),
NULL);
// Associate labels with their controls
gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin");
GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout");
GLADE_HOOKUP_OBJECT (startwin, banner, "banner");
GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout");
GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs");
GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout");
GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout");
GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel");
GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo");
GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck");
GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck");
GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab");
GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll");
GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext");
GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab");
GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons");
GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon");
GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel");
GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton");
GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign");
GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout");
GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon");
GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel");
gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group);
return startwin;
}
void pressed_preferences( GtkMenuItem *menu_item, gpointer user_data )
{
int i;
#ifdef U_NLS
int j;
GSList *radio_group;
#endif
GtkWidget *vbox3, *hbox4, *table3, *table4, *table5, *drawingarea_tablet, *frame;
GtkWidget *button1, *button2, *notebook1, *vbox_1, *vbox_2, *vbox_3, *label;
GtkAccelGroup* ag = gtk_accel_group_new();
char *tab_tex[] = { _("Max memory used for undo (MB)"), _("Greyscale backdrop"),
_("Selection nudge pixels"), _("Max Pan Window Size") };
char *tab_tex2[] = { _("XPM/PNG transparency index"), _("XBM X hotspot"), _("XBM Y hotspot"),
_("JPEG Save Quality (100=High) "), _("Recently Used Files") };
char *tab_tex3[] = { _("Minimum grid zoom"), _("Grid colour RGB") };
char *stat_tex[] = { _("Colour A & B"), _("Canvas Geometry"), _("Cursor X,Y"),
_("Pixel [I] {RGB}"), _("Zoom %"), _("Selection Geometry"), _("Continuous Mode"),
_("Undo / Redo"), _("Opacity %"), _("Opacity Mode") },
*tablet_txt[] = { _("Size"), _("Flow"), _("Opacity") };
char txt[64];
men_item_state( menu_prefs, FALSE ); // Make sure the user can only open 1 prefs window
prefs_window = add_a_window( GTK_WINDOW_TOPLEVEL, _("Preferences"), GTK_WIN_POS_CENTER, FALSE );
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_container_add (GTK_CONTAINER (prefs_window), vbox3);
/// SETUP NOTEBOOK
notebook1 = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox3), notebook1, TRUE, TRUE, 0);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook1), GTK_POS_TOP);
gtk_widget_show (notebook1);
/// ---- TAB1 - GENERAL
vbox_1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_1);
gtk_container_add (GTK_CONTAINER (notebook1), vbox_1);
label = gtk_label_new( _("General") );
gtk_widget_show (label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK (notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label);
table3 = add_a_table( 3, 2, 10, vbox_1 );
/// TABLE TEXT
for ( i=0; i<4; i++ ) add_to_table( tab_tex[i], table3, i, 0, 0, GTK_JUSTIFY_LEFT, 0, 0.5 );
/// TABLE SPINBUTTONS
spin_to_table( table3, &spinbutton_maxmem, 0, 1, 5, inifile_get_gint32("undoMBlimit", 32 ), 1, 1000 );
spin_to_table( table3, &spinbutton_greys, 1, 1, 5, inifile_get_gint32("backgroundGrey", 180 ), 0, 255 );
spin_to_table( table3, &spinbutton_nudge, 2, 1, 5, inifile_get_gint32("pixelNudge", 8 ), 2, 512 );
spin_to_table( table3, &spinbutton_pan, 3, 1, 5, inifile_get_gint32("panSize", 128 ), 64, 256 );
checkbutton_paste = add_a_toggle( _("Display clipboard while pasting"),
vbox_1, inifile_get_gboolean("pasteToggle", TRUE) );
checkbutton_cursor = add_a_toggle( _("Mouse cursor = Tool"),
vbox_1, inifile_get_gboolean("cursorToggle", TRUE) );
checkbutton_exit = add_a_toggle( _("Confirm Exit"),
vbox_1, inifile_get_gboolean("exitToggle", FALSE) );
checkbutton_quit = add_a_toggle( _("Q key quits mtPaint"),
vbox_1, inifile_get_gboolean("quitToggle", TRUE) );
checkbutton_commit = add_a_toggle( _("Changing tool commits paste"),
vbox_1, inifile_get_gboolean("pasteCommit", FALSE) );
/// ---- TAB2 - FILES
vbox_2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_2);
gtk_container_add (GTK_CONTAINER (notebook1), vbox_2);
label = gtk_label_new( _("Files") );
gtk_widget_show (label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK (notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label);
table4 = add_a_table( 5, 2, 10, vbox_2 );
for ( i=0; i<5; i++ ) add_to_table( tab_tex2[i], table4, i, 0, 0, GTK_JUSTIFY_LEFT, 0, 0.5 );
spin_to_table( table4, &spinbutton_trans, 0, 1, 5, mem_xpm_trans, -1, mem_cols-1 );
spin_to_table( table4, &spinbutton_hotx, 1, 1, 5, mem_xbm_hot_x, -1, mem_width-1 );
spin_to_table( table4, &spinbutton_hoty, 2, 1, 5, mem_xbm_hot_y, -1, mem_height-1 );
spin_to_table( table4, &spinbutton_jpeg, 3, 1, 5, mem_jpeg_quality, 0, 100 );
spin_to_table( table4, &spinbutton_recent, 4, 1, 5, recent_files, 0, MAX_RECENT );
add_hseparator( vbox_2, -2, 10 );
label = gtk_label_new( _("Clipboard Files") );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX(vbox_2), label, FALSE, FALSE, 0 );
clipboard_entry = gtk_entry_new();
gtk_widget_show( clipboard_entry );
gtk_box_pack_start( GTK_BOX(vbox_2), clipboard_entry, FALSE, FALSE, 0 );
gtk_entry_set_text( GTK_ENTRY(clipboard_entry), mem_clip_file[0] );
strncpy( mem_clip_file[1], mem_clip_file[0], 250 );
button1 = add_a_button( _("Browse"), 4, vbox_2, FALSE );
gtk_signal_connect(GTK_OBJECT(button1), "clicked",
GTK_SIGNAL_FUNC(clip_file_browse), NULL);
/// ---- TAB3 - STATUS BAR
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_container_add (GTK_CONTAINER (notebook1), hbox4);
vbox_3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_3);
gtk_box_pack_start (GTK_BOX (hbox4), vbox_3, FALSE, FALSE, 0);
label = gtk_label_new( _("Status Bar") );
gtk_widget_show (label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK (notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), label);
for ( i=0; i<STATUS_ITEMS; i++ )
{
if (i==5)
{
vbox_3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_3);
gtk_box_pack_start (GTK_BOX (hbox4), vbox_3, FALSE, FALSE, 0);
}
sprintf(txt, "status%iToggle", i);
prefs_status[i] = add_a_toggle( stat_tex[i], vbox_3, inifile_get_gboolean(txt, TRUE) );
}
/// ---- TAB4 - ZOOM
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_container_add (GTK_CONTAINER (notebook1), hbox4);
vbox_3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_3);
gtk_box_pack_start (GTK_BOX (hbox4), vbox_3, FALSE, FALSE, 0);
label = gtk_label_new( _("Zoom") );
gtk_widget_show (label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK (notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), label);
table5 = add_a_table( 2, 4, 10, vbox_3 );
/// TABLE TEXT
for ( i=0; i<2; i++ ) add_to_table( tab_tex3[i], table5, i, 0, 0, GTK_JUSTIFY_LEFT, 0, 0.5 );
/// TABLE SPINBUTTONS
spin_to_table( table5, &spinbutton_grid[0], 0, 1, 5, mem_grid_min, 2, 12 );
spin_to_table( table5, &spinbutton_grid[1], 1, 1, 5, mem_grid_rgb[0], 0, 255 );
spin_to_table( table5, &spinbutton_grid[2], 1, 2, 5, mem_grid_rgb[1], 0, 255 );
spin_to_table( table5, &spinbutton_grid[3], 1, 3, 5, mem_grid_rgb[2], 0, 255 );
checkbutton_zoom = add_a_toggle( _("New image sets zoom to 100%"),
vbox_3, inifile_get_gboolean("zoomToggle", FALSE) );
#if GTK_MAJOR_VERSION == 2
checkbutton_wheel = add_a_toggle( _("Mouse Scroll Wheel = Zoom"),
vbox_3, inifile_get_gboolean("scrollwheelZOOM", TRUE) );
#endif
/// ---- TAB5 - TABLET
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_container_add (GTK_CONTAINER (notebook1), hbox4);
vbox_3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_3);
gtk_box_pack_start (GTK_BOX (hbox4), vbox_3, FALSE, FALSE, 0);
label = gtk_label_new( _("Tablet") );
gtk_widget_show (label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK (notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 4), label);
frame = gtk_frame_new (_("Device Settings"));
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox_3), frame, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
vbox_2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_2);
gtk_container_add (GTK_CONTAINER (frame), vbox_2);
gtk_container_set_border_width (GTK_CONTAINER (vbox_2), 5);
label_tablet_device = gtk_label_new ("");
gtk_widget_show (label_tablet_device);
gtk_box_pack_start (GTK_BOX (vbox_2), label_tablet_device, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label_tablet_device), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label_tablet_device), 5, 5);
button1 = add_a_button( _("Configure Device"), 0, vbox_2, FALSE );
gtk_signal_connect(GTK_OBJECT(button1), "clicked", GTK_SIGNAL_FUNC(conf_tablet), NULL);
table3 = gtk_table_new (4, 2, FALSE);
gtk_widget_show (table3);
gtk_box_pack_start (GTK_BOX (vbox_2), table3, TRUE, TRUE, 0);
label = add_to_table( _("Tool Variable"), table3, 0, 0, 0, 0, 0, 0 );
gtk_misc_set_padding (GTK_MISC (label), 5, 5);
label = add_to_table( _("Factor"), table3, 0, 1, 0, 0, 0, 0 );
gtk_misc_set_padding (GTK_MISC (label), 5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0.4, 0.5);
for ( i=0; i<3; i++ )
{
check_tablet[i] = gtk_check_button_new_with_label (tablet_txt[i]);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tablet[i]),
tablet_tool_use[i] );
gtk_widget_show (check_tablet[i]);
gtk_table_attach (GTK_TABLE (table3), check_tablet[i], 0, 1, i+1, i+2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
// Size/Flow/Opacity sliders
hscale_tablet[i] = add_slider2table( 0, -1, 1, table3, 1+i, 1, 200, -2 );
gtk_adjustment_set_value( GTK_HSCALE(hscale_tablet[i])->scale.range.adjustment,
tablet_tool_factor[i] );
gtk_scale_set_value_pos (GTK_SCALE (hscale_tablet[i]), GTK_POS_RIGHT);
gtk_scale_set_digits (GTK_SCALE (hscale_tablet[i]), 2);
gtk_scale_set_draw_value (GTK_SCALE (hscale_tablet[i]), TRUE);
}
frame = gtk_frame_new (_("Test Area"));
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox_3), frame, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
vbox_2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_2);
gtk_container_add (GTK_CONTAINER (frame), vbox_2);
gtk_container_set_border_width (GTK_CONTAINER (vbox_2), 5);
drawingarea_tablet = gtk_drawing_area_new ();
gtk_widget_show (drawingarea_tablet);
gtk_box_pack_start (GTK_BOX (vbox_2), drawingarea_tablet, TRUE, TRUE, 0);
gtk_widget_set_usize (drawingarea_tablet, 128, 64);
gtk_signal_connect( GTK_OBJECT(drawingarea_tablet), "expose_event",
GTK_SIGNAL_FUNC (expose_tablet_preview), (gpointer) drawingarea_tablet );
gtk_signal_connect (GTK_OBJECT (drawingarea_tablet), "motion_notify_event",
GTK_SIGNAL_FUNC (tablet_preview_motion), NULL);
gtk_signal_connect (GTK_OBJECT (drawingarea_tablet), "button_press_event",
GTK_SIGNAL_FUNC (tablet_preview_button), NULL);
gtk_widget_set_events (drawingarea_tablet, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
gtk_widget_set_extension_events (drawingarea_tablet, GDK_EXTENSION_EVENTS_CURSOR);
label_tablet_pressure = gtk_label_new ("");
gtk_widget_show (label_tablet_pressure);
gtk_box_pack_start (GTK_BOX (vbox_2), label_tablet_pressure, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label_tablet_pressure), 0, 0.5);
/// ---- TAB6 - LANGUAGE
#ifdef U_NLS
pref_lang_ini[1] = _("Default System Language");
pref_lang_ini[3] = _("Czech");
pref_lang_ini[5] = _("English (UK)");
pref_lang_ini[7] = _("French");
pref_lang_ini[9] = _("Portuguese");
pref_lang_ini[11] = _("Portuguese (Brazilian)");
pref_lang_ini[13] = _("Spanish");
vbox_2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_2);
gtk_container_add (GTK_CONTAINER (notebook1), vbox_2);
gtk_container_set_border_width( GTK_CONTAINER(vbox_2), 10 );
label = gtk_label_new( _("Language") );
gtk_widget_show (label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK (notebook1),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 5), label);
add_hseparator( vbox_2, 200, 10 );
label = gtk_label_new( _("Select preferred language translation\n\n"
"You will need to restart mtPaint\nfor this to take full effect") );
pref_lang_label = label;
gtk_widget_show (label);
gtk_box_pack_start( GTK_BOX(vbox_2), label, FALSE, FALSE, 0 );
add_hseparator( vbox_2, 200, 10 );
pref_lang_radio[0] = add_radio_button( pref_lang_ini[1], NULL, NULL, vbox_2, 0 );
radio_group = gtk_radio_button_group( GTK_RADIO_BUTTON(pref_lang_radio[0]) );
pref_lang_radio[1] = add_radio_button( pref_lang_ini[3], radio_group, NULL, vbox_2, 1 );
for ( i=2; i<PREF_LANGS; i++ )
pref_lang_radio[i] = add_radio_button(
pref_lang_ini[i*2+1], NULL, pref_lang_radio[1], vbox_2, i );
for ( i=0; i<PREF_LANGS; i++ )
gtk_container_set_border_width( GTK_CONTAINER(pref_lang_radio[i]), 5 );
j = 0;
for ( i = PREF_LANGS - 1; i>0; i-- )
{
if ( strcmp( pref_lang_ini[i*2], inifile_get( "languageSETTING", "system" ) ) == 0 )
j = i;
}
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(pref_lang_radio[j]), TRUE );
#endif
/// Bottom of Prefs window
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox3), hbox4, FALSE, FALSE, 0);
button1 = add_a_button(_("Cancel"), 5, hbox4, TRUE);
gtk_signal_connect(GTK_OBJECT(button1), "clicked", GTK_SIGNAL_FUNC(delete_prefs), NULL);
gtk_widget_add_accelerator (button1, "clicked", ag, GDK_Escape, 0, (GtkAccelFlags) 0);
button1 = add_a_button(_("Apply"), 5, hbox4, TRUE);
gtk_signal_connect(GTK_OBJECT(button1), "clicked", GTK_SIGNAL_FUNC(prefs_apply), NULL);
button2 = add_a_button(_("OK"), 5, hbox4, TRUE);
gtk_signal_connect(GTK_OBJECT(button2), "clicked", GTK_SIGNAL_FUNC(prefs_ok), NULL);
gtk_widget_add_accelerator (button2, "clicked", ag, GDK_Return, 0, (GtkAccelFlags) 0);
gtk_widget_add_accelerator (button2, "clicked", ag, GDK_KP_Enter, 0, (GtkAccelFlags) 0);
gtk_signal_connect_object (GTK_OBJECT (prefs_window), "delete_event",
GTK_SIGNAL_FUNC (delete_prefs), NULL);
gtk_window_set_transient_for( GTK_WINDOW(prefs_window), GTK_WINDOW(main_window) );
gtk_widget_show (prefs_window);
gtk_window_add_accel_group(GTK_WINDOW (prefs_window), ag);
if ( tablet_working )
{
tablet_update_device( tablet_device->name );
} else tablet_update_device( "NONE" );
}
int
main (int argc, char *argv [])
{
/*Running Shell*/
GError *error = NULL;
python_shell_data = g_try_malloc (sizeof (ChildProcessData));
python_shell_data->argv = NULL;
python_shell_data->slave_termios = g_try_malloc (sizeof (struct termios));
python_shell_data->current_dir = NULL;
bash_loaded = ptyFork (python_shell_data, &error);
gtk_init (&argc, &argv);
python_shell_data->channel = g_io_channel_unix_new (python_shell_data->master_fd);
g_io_add_watch (python_shell_data->channel, G_IO_IN,
(GIOFunc)read_masterFd, &(python_shell_data->master_fd));
/**********/
/*Loading Options*/
if (g_file_test ("./options.inf", G_FILE_TEST_EXISTS))
load_options_from_file ("./options.inf");
else
{
options.indent_width = 4;
options.tab_width = 4;
options.is_code_completion = TRUE;
options.is_code_folding = TRUE;
options.show_line_numbers = TRUE;
options.font_name = "Liberation Mono";
}
/*************/
options.python_shell_path = "/usr/bin/python";
options.comment_out_str = "##";
options.indent_width_str = " ";
options.tab_width_str = " ";
env_python_path = "";
gchar **p = options.env_vars;
if (p)
{
while (*p)
{
gchar *s = g_strstr_len (*p, -1, "PYTHONPATH=");
if (s)
{
env_python_path = s + strlen ("PYTHONPATH=");
break;
}
p++;
}
}
/*Get sys.path*/
char *sys_path_argv[] = {"python", "./scripts/path.py", NULL};
g_spawn_sync (NULL, sys_path_argv, NULL, G_SPAWN_SEARCH_PATH,
NULL, NULL, &sys_path_string, NULL, NULL, NULL);
/***********/
char *_str = g_strconcat (sys_path_string, "\n", env_python_path, NULL);
g_free (sys_path_string);
sys_path_string = _str;
file_monitor = file_monitor_new (file_monitor_changed);
/*Setting Main Window*/
GtkWidget *navigate_bookmarks;
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, "./ui/main.ui", NULL);
content_box = GTK_WIDGET (gtk_builder_get_object (builder, "content_box"));
window = gtk_builder_get_object (builder, "main_window");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
path_browser = path_browser_new ();
g_object_ref (path_browser);
proj_notebook = project_notebook_new ();
/**Setting proj_syms_tree_view**/
symbols_view = symbols_view_new ();
g_object_ref (symbols_view);
/*************************/
content_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
g_object_ref (content_paned);
status_bar = gtk_statusbar_new ();
g_object_ref (status_bar);
gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook),
symbols_view, gtk_label_new ("Symbols"));
gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook),
path_browser,
gtk_label_new ("Paths"));
navigate_bookmarks = GTK_WIDGET (gtk_builder_get_object (builder,
"navigate_bookmarks"));
bookmarks_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (navigate_bookmarks),
bookmarks_menu);
GtkAccelGroup *accelgroup = GTK_ACCEL_GROUP (gtk_builder_get_object (builder,
"accelgroup"));
/*Connecting menu item's signals*/
//For File Menu
g_signal_connect (gtk_builder_get_object (builder, "file_new"), "activate",
G_CALLBACK (file_new_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_new_tab"), "activate",
G_CALLBACK (file_new_tab_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_open"), "activate",
G_CALLBACK (file_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "recentchoosermenu"), "selection-done",
G_CALLBACK (file_recent_menu_selection_done), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save"), "activate",
G_CALLBACK (file_save_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_as"), "activate",
G_CALLBACK (file_save_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_copy_as"), "activate",
G_CALLBACK (file_save_copy_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_all"), "activate",
G_CALLBACK (file_save_all_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_close_tab"), "activate",
G_CALLBACK (file_close_tab_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_close_all_tabs"), "activate",
G_CALLBACK (file_close_all_tabs_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_quit"), "activate",
G_CALLBACK (file_quit_activate), NULL);
//For Edit Menu
g_signal_connect (gtk_builder_get_object (builder, "edit_undo"), "activate",
G_CALLBACK (edit_undo_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_redo"), "activate",
G_CALLBACK (edit_redo_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_cut"), "activate",
G_CALLBACK (edit_cut_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_copy"), "activate",
G_CALLBACK (edit_copy_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_paste"), "activate",
G_CALLBACK (edit_paste_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_delete"), "activate",
G_CALLBACK (edit_delete_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_all"), "activate",
G_CALLBACK (edit_select_all_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_function"), "activate",
G_CALLBACK (edit_select_function_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_block"), "activate",
G_CALLBACK (edit_select_block_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_fold_all_func"), "activate",
G_CALLBACK (edit_fold_all_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_unfold_all_func"), "activate",
G_CALLBACK (edit_unfold_all_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_fold_current_func"), "activate",
G_CALLBACK (edit_fold_current_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_autocomplete"), "activate",
G_CALLBACK (edit_autocomplete_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_matching_paranthesis"), "activate",
G_CALLBACK (edit_matching_paranthesis_activate), NULL);
//For Format Menu
g_signal_connect (gtk_builder_get_object (builder, "format_inc_indent"), "activate",
G_CALLBACK (format_inc_indent_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_inc_indent")),
"activate", accelgroup, GDK_KEY_bracketright,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_dec_indent"), "activate",
G_CALLBACK (format_dec_indent_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_dec_indent")),
"activate", accelgroup, GDK_KEY_bracketleft,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_comment_out"), "activate",
G_CALLBACK (format_comment_out_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_comment_out")),
"activate", accelgroup, GDK_KEY_3,
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_uncomment_out"), "activate",
G_CALLBACK (format_uncomment_out_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_uncomment_out")),
"activate", accelgroup, GDK_KEY_4,
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_tabify_region"), "activate",
G_CALLBACK (format_tabify_region_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_untabify_region"), "activate",
G_CALLBACK (format_untabify_region_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_uppercase"), "activate",
G_CALLBACK (format_uppercase_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_lowercase"), "activate",
G_CALLBACK (format_lowercase_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_strip_spaces"), "activate",
G_CALLBACK (format_strip_spaces_activate), NULL);
//For Search Menu
g_signal_connect (gtk_builder_get_object (builder, "search_find"), "activate",
G_CALLBACK (search_find_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_next"), "activate",
G_CALLBACK (search_find_next_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_prev"), "activate",
G_CALLBACK (search_find_prev_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_replace"), "activate",
G_CALLBACK (search_find_replace_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_selected"), "activate",
G_CALLBACK (search_find_selected_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_in_text"), "activate",
G_CALLBACK (search_find_in_text_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_file"), "activate",
G_CALLBACK (search_find_file_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_replace_file"), "activate",
G_CALLBACK (search_replace_file_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_reg_exp"), "activate",
G_CALLBACK (search_reg_exp_activate), NULL);
//For Navigation Menu
g_signal_connect (gtk_builder_get_object (builder, "navigate_back"), "activate",
G_CALLBACK (navigate_back_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_forward"), "activate",
G_CALLBACK (navigate_forward_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_first_line"), "activate",
G_CALLBACK (navigate_first_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_last_line"), "activate",
G_CALLBACK (navigate_last_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_line_history"), "select",
G_CALLBACK (navigate_line_history_select), NULL);
g_signal_connect (gtk_builder_get_object (builder, "naviagate_add_bookmark"), "activate",
G_CALLBACK (naviagate_add_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "naviagate_clear_bookmarks"), "activate",
G_CALLBACK (naviagate_clear_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_prev_bookmarks"), "activate",
G_CALLBACK (navigate_prev_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_next_bookmark"), "activate",
G_CALLBACK (navigate_next_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_bookmarks"), "activate",
G_CALLBACK (navigate_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_line"), "activate",
G_CALLBACK (navigate_go_to_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_block_start"), "activate",
G_CALLBACK (navigate_go_to_block_start_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_func_def"), "activate",
G_CALLBACK (navigate_go_to_func_def_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_next_func"), "activate",
G_CALLBACK (navigate_go_to_next_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_prev_func"), "activate",
G_CALLBACK (navigate_go_to_prev_func_activate), NULL);
//For Project Menu
g_signal_connect (gtk_builder_get_object (builder, "project_new"), "activate",
G_CALLBACK (project_new_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_open"), "activate",
G_CALLBACK (project_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save"), "activate",
G_CALLBACK (project_save_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save_as"), "activate",
G_CALLBACK (project_save_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save_copy_as"), "activate",
G_CALLBACK (project_save_copy_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_empty"), "activate",
G_CALLBACK (project_empty_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_close"), "activate",
G_CALLBACK (project_close_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_preferences"), "activate",
G_CALLBACK (project_preferences_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_recent"), "activate",
G_CALLBACK (project_recent_activate), NULL);
//For Python Shell Menu
g_signal_connect (gtk_builder_get_object (builder, "python_shell_open"), "activate",
G_CALLBACK (python_shell_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "python_shell_restart"), "activate",
G_CALLBACK (python_shell_restart_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "python_shell_close"), "activate",
G_CALLBACK (python_shell_close_activate), NULL);
//For Run Menu
g_signal_connect (gtk_builder_get_object (builder, "run_run_script"), "activate",
G_CALLBACK (run_run_script_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_debug_script"), "activate",
G_CALLBACK (run_debug_script_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_run_project"), "activate",
G_CALLBACK (run_run_project_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_debug_project"), "activate",
G_CALLBACK (run_debug_project_activate), NULL);
//For Debug Menu
g_signal_connect (gtk_builder_get_object (builder, "debug_open_pdb_shell"), "activate",
G_CALLBACK (debug_open_pdb_shell_activate), NULL);
//For Tools Menu
g_signal_connect (gtk_builder_get_object (builder, "tools_options"), "activate",
G_CALLBACK (tools_options_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "tools_auto_indent"), "activate",
G_CALLBACK (tools_auto_indent_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "tools_class_browser"), "activate",
G_CALLBACK (tools_class_browser_activate), NULL);
/*************************/
/**Connecting Toolbar's signals**/
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_menu"), "clicked",
G_CALLBACK (toolbar_new_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_file"), "activate",
G_CALLBACK (toolbar_new_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_project"), "activate",
G_CALLBACK (toolbar_new_proj_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_menu"), "clicked",
G_CALLBACK (toolbar_open_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_file"), "activate",
G_CALLBACK (toolbar_open_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_project"), "activate",
G_CALLBACK (toolbar_open_proj_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_menu"), "clicked",
G_CALLBACK (toolbar_save_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_file"), "activate",
G_CALLBACK (toolbar_save_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_project"), "activate",
G_CALLBACK (toolbar_save_project_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as"), "clicked",
G_CALLBACK (toolbar_save_as_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_file"), "activate",
G_CALLBACK (toolbar_save_as_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_project"), "activate",
G_CALLBACK (toolbar_save_as_project_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_undo"), "clicked",
G_CALLBACK (toolbar_undo_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_redo"), "clicked",
G_CALLBACK (toolbar_redo_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_cut"), "clicked",
G_CALLBACK (toolbar_cut_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_copy"), "clicked",
G_CALLBACK (toolbar_copy_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_paste"), "clicked",
G_CALLBACK (toolbar_cut_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_delete"), "clicked",
G_CALLBACK (toolbar_delete_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_select_all"), "clicked",
G_CALLBACK (toolbar_select_all_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_find"), "clicked",
G_CALLBACK (toolbar_find_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_find_replace"), "clicked",
G_CALLBACK (toolbar_find_replace_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_inc_indent"), "clicked",
G_CALLBACK (toolbar_inc_indent_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_dec_indent"), "clicked",
G_CALLBACK (toolbar_dec_indent_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_line"), "clicked",
G_CALLBACK (navigate_forward_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_line"), "clicked",
G_CALLBACK (navigate_back_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_add_bookmark"), "clicked",
G_CALLBACK (naviagate_add_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_bookmark"), "clicked",
G_CALLBACK (navigate_next_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_bookmark"), "clicked",
G_CALLBACK (navigate_prev_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_clear_bookmark"), "clicked",
G_CALLBACK (naviagate_clear_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_run"), "clicked",
G_CALLBACK (toolbar_run), NULL);
/*g_signal_connect (gtk_builder_get_object (builder, "toolbar_debug"), "clicked",
G_CALLBACK (toolbar_dec_indent_clicked), NULL); */
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_shell"), "clicked",
G_CALLBACK (python_shell_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_options"), "clicked",
G_CALLBACK (tools_options_activate), NULL);
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_add_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksadd.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_next_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksnext.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_prev_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksprev.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_clear_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksclear.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_debug")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/debug.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_open_shell")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/python_shell.png",NULL)));
/*************************/
line_history_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (builder, "navigate_line_history")),
line_history_menu);
GtkRecentFilter *py_recent_filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (py_recent_filter, "Python Files");
gtk_recent_filter_add_pattern (py_recent_filter, "*.py");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (gtk_builder_get_object (builder, "recentchoosermenu")),
py_recent_filter);
/* Connecting window's signals and events */
g_signal_connect (window, "delete-event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (main_window_destroy), NULL);
/********************************/
/*Other global variables*/
search_text = NULL;
bookmark_array= NULL;
bookmark_array_size = 0;
current_bookmark_index = -1;
/******************/
/*Initialize Regular Expressions*/
regex_class = g_regex_new ("[ \\ \\t]*\\bclass\\b\\s*\\w+\\s*\\(*.*\\)*:", 0, 0, NULL);
regex_func = g_regex_new ("[ \\ \\t]*def\\s+[\\w\\d_]+\\s*\\(.+\\)\\:", 0, 0, NULL);
/*Regex if you don't want to search imports with in indentation*/
/*regex_import = g_regex_new ("^import\\s+[\\w\\d_\\.]+", 0, 0, NULL);
regex_import_as = g_regex_new ("^import\\s+[\\w\\d_\\.]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);*/
regex_from_import = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+", 0, 0, NULL);
regex_from_import_as = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+as\\s+[\\w\\d_]", 0, 0, NULL);
regex_global_var = g_regex_new ("^[\\w\\d_]+\\s*=\\s*[\\w\\d_]+\\s*\\(.+\\)", 0, 0, NULL);
regex_static_var = g_regex_new ("^\\s*[\\w\\d_]+\\s*=.+", 0, 0, NULL);
regex_word = g_regex_new ("[self]*[\\w\\d_\\.]+$", 0, 0, NULL);
regex_local_var = g_regex_new ("^\\s*[\\w\\d_\\.]+\\s*=.+", 0, 0, NULL);
regex_self_var = g_regex_new ("^\\s+self\\.[\\w\\d_]+\\s*=.+", 0, 0, NULL);
/*Regex if you want to search imports with in indentation*/
regex_import = g_regex_new ("^\\s*import\\s+[\\w\\d_\\.]+", 0, 0, NULL);
regex_import_as = g_regex_new ("^\\s*import\\s+[\\w\\d_]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);
/***********************/
async_queue = g_async_queue_new ();
//Creating code_widget_array
//code_widget_array = g_malloc0 (1*sizeof (CodeWidget *));
//code_widget_array [0] = codewidget_new ();
code_widget_array_size = 0;
notebook = gtk_notebook_new ();
g_object_ref (notebook);
//gtk_notebook_append_page (GTK_NOTEBOOK (notebook), code_widget_array [0]->vbox,
// gtk_label_new ("New File"));
/*If bash is not loaded*/
if (!bash_loaded)
{
gchar *msg = g_strdup_printf ("Cannot run Python Shell (%s)", error->message);
gtk_statusbar_push (GTK_STATUSBAR (status_bar), 0, msg);
g_free (msg);
g_error_free (error);
}
/****************/
GtkSettings *settings = gtk_settings_get_default ();
g_object_set (settings, "gtk-application-prefer-dark-theme", TRUE, NULL);
gtk_window_maximize (GTK_WINDOW (window));
gtk_widget_show_all (GTK_WIDGET (window));
gtk_main ();
return 0;
}
/*
* CreateMenuItem
*
* Creates an item and puts it in the menu and returns the item.
*
* menu - container menu
* szName - Name of the menu - NULL for a separator
* szAccel - Acceleration string - "^C" for Control-C
* szTip - Tool tips
* func - Call back function
* data - call back function data
*
* returns new menuitem
*/
GtkWidget *CreateMenuItem (GtkWidget *menu,
GtkAccelGroup *accel_group,
GtkTooltips *tooltips,
char *szName,
char *szAccel,
char *szTip,
GtkSignalFunc func,
gpointer data)
{
GtkWidget *menuitem;
/* --- If there's a name, create the item and put a
* Signal handler on it.
*/
if (szName && strlen (szName)) {
menuitem = gtk_menu_item_new_with_label (szName);
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
GTK_SIGNAL_FUNC(func), data);
} else {
/* --- Create a separator --- */
menuitem = gtk_menu_item_new ();
}
/* --- Add menu item to the menu and show it. --- */
gtk_menu_append (GTK_MENU (menu), menuitem);
gtk_widget_show (menuitem);
/* --- If there was an accelerator --- */
if (szAccel && accel_group != NULL) {
guint modifier = 0;
guint key;
if (szAccel[0] == '^') {
szAccel++;
modifier |= GDK_CONTROL_MASK;
}
if (strncmp(szAccel, "M-", 2) == 0) {
szAccel += 2;
modifier |= GDK_MOD1_MASK;
}
key = szAccel[0];
if (strncmp(szAccel,"<enter>", sizeof("<enter>")) == 0) {
key = GDK_Return;
}
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
key,
(GdkModifierType)modifier,
GTK_ACCEL_VISIBLE);
}
/* --- If there was a tool tip --- */
if (szTip && strlen (szTip) && tooltips != NULL) {
/* --- If tooltips not created yet --- */
gtk_tooltips_set_tip (tooltips, menuitem, szTip, NULL);
}
return (menuitem);
}
/* Initialize password dialog */
static void
passdlg_init (PasswordDialog *pdialog, GtkWindow *parent)
{
GtkBuilder *dialog;
GtkWidget *wpassdlg;
GtkAccelGroup *group;
/* Initialize dialog */
dialog = gtk_builder_new ();
gtk_builder_add_from_file (dialog, MATECC_UI_DIR "/mate-about-me-password.ui", NULL);
pdialog->ui = dialog;
wpassdlg = WID ("change-password");
capplet_set_icon (wpassdlg, "user-info");
group = gtk_accel_group_new ();
/*
* Initialize backend
*/
/* Initialize backend_pid. -1 means the backend is not running */
pdialog->backend_pid = -1;
/* Initialize IO Channels */
pdialog->backend_stdin = NULL;
pdialog->backend_stdout = NULL;
/* Initialize write queue */
pdialog->backend_stdin_queue = g_queue_new ();
/* Initialize watchers */
pdialog->backend_child_watch_id = 0;
pdialog->backend_stdout_watch_id = 0;
/* Initialize backend state */
pdialog->backend_state = PASSWD_STATE_NONE;
/*
* Initialize UI
*/
/* Initialize pdialog widgets */
pdialog->current_password = GTK_ENTRY (WID ("current-password"));
pdialog->new_password = GTK_ENTRY (WID ("new-password"));
pdialog->retyped_password = GTK_ENTRY (WID ("retyped-password"));
pdialog->dialog_image = GTK_IMAGE (WID ("dialog-image"));
pdialog->status_label = GTK_LABEL (WID ("status-label"));
/* Initialize accelerators */
gtk_widget_add_accelerator (GTK_WIDGET (pdialog->current_password),
"activate", group,
GDK_KEY_Return, 0,
0);
gtk_widget_add_accelerator (GTK_WIDGET (pdialog->new_password),
"activate", group,
GDK_KEY_Return, 0,
0);
/* Activate authenticate-button when enter is pressed in current-password */
g_signal_connect (G_OBJECT (pdialog->current_password), "activate",
G_CALLBACK (passdlg_activate), WID ("authenticate-button"));
/* Activate retyped-password when enter is pressed in new-password */
g_signal_connect (G_OBJECT (pdialog->new_password), "activate",
G_CALLBACK (passdlg_activate), pdialog->retyped_password);
/* Clear status message */
passdlg_set_status (pdialog, "");
/* Set non-authenticated state */
passdlg_set_auth_state (pdialog, FALSE);
/* Connect signal handlers */
g_signal_connect (G_OBJECT (WID ("authenticate-button")), "clicked",
G_CALLBACK (passdlg_authenticate), pdialog);
/* Verify new passwords on-the-fly */
g_signal_connect (G_OBJECT (WID ("new-password")), "changed",
G_CALLBACK (passdlg_check_password), pdialog);
g_signal_connect (G_OBJECT (WID ("retyped-password")), "changed",
G_CALLBACK (passdlg_check_password), pdialog);
/* Set misc dialog properties */
gtk_window_set_resizable (GTK_WINDOW (wpassdlg), FALSE);
gtk_window_set_transient_for (GTK_WINDOW (wpassdlg), GTK_WINDOW (parent));
}
EMessageBoxReturn gtk_MessageBox (GtkWidget *parent, const char* text, const char* title, EMessageBoxType type, EMessageBoxIcon icon)
{
ModalDialog dialog;
ModalDialogButton ok_button(dialog, eIDOK);
ModalDialogButton cancel_button(dialog, eIDCANCEL);
ModalDialogButton yes_button(dialog, eIDYES);
ModalDialogButton no_button(dialog, eIDNO);
GtkWindow* parentWindow = parent != 0 ? GTK_WINDOW(parent) : 0;
GtkWindow* window = create_fixedsize_modal_dialog_window(parentWindow, title, dialog, 400, 100);
if(parentWindow != 0)
{
//g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(floating_window_delete_present), parent);
gtk_window_deiconify(parentWindow);
}
GtkAccelGroup* accel = gtk_accel_group_new();
gtk_window_add_accel_group(window, accel);
GtkVBox* vbox = create_dialog_vbox(8, 8);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(vbox));
GtkHBox* hboxDummy = create_dialog_hbox(0, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hboxDummy), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hboxDummy), create_padding(0, 50), FALSE, FALSE, 0); // HACK to force minimum height
GtkHBox* iconBox = create_dialog_hbox(16, 0);
gtk_box_pack_start(GTK_BOX(hboxDummy), GTK_WIDGET(iconBox), FALSE, FALSE, 0);
GtkImage* image = GTK_IMAGE(gtk_image_new_from_stock(messagebox_stock_icon(icon), GTK_ICON_SIZE_DIALOG));
gtk_widget_show(GTK_WIDGET(image));
gtk_box_pack_start(GTK_BOX(iconBox), GTK_WIDGET(image), FALSE, FALSE, 0);
GtkLabel* label = GTK_LABEL(gtk_label_new(text));
gtk_widget_show(GTK_WIDGET(label));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_label_set_justify(label, GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap(label, TRUE);
gtk_box_pack_start(GTK_BOX(iconBox), GTK_WIDGET(label), TRUE, TRUE, 0);
GtkVBox* vboxDummy = create_dialog_vbox(0, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(vboxDummy), FALSE, FALSE, 0);
GtkAlignment* alignment = GTK_ALIGNMENT(gtk_alignment_new(0.5, 0.0, 0.0, 0.0));
gtk_widget_show(GTK_WIDGET(alignment));
gtk_box_pack_start(GTK_BOX(vboxDummy), GTK_WIDGET(alignment), FALSE, FALSE, 0);
GtkHBox* hbox = create_dialog_hbox(8, 0);
gtk_container_add(GTK_CONTAINER(alignment), GTK_WIDGET(hbox));
gtk_box_pack_start(GTK_BOX(vboxDummy), create_padding(400, 0), FALSE, FALSE, 0); // HACK to force minimum width
if (type == eMB_OK)
{
GtkButton* button = create_modal_dialog_button("OK", ok_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
widget_make_default(GTK_WIDGET(button));
gtk_widget_show(GTK_WIDGET(button));
dialog.ret = eIDOK;
}
else if (type == eMB_OKCANCEL)
{
{
GtkButton* button = create_modal_dialog_button("OK", ok_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
widget_make_default(GTK_WIDGET(button));
gtk_widget_show(GTK_WIDGET(button));
}
{
GtkButton* button = create_modal_dialog_button("OK", cancel_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
gtk_widget_show(GTK_WIDGET(button));
}
dialog.ret = eIDCANCEL;
}
else if (type == eMB_YESNOCANCEL)
{
{
GtkButton* button = create_modal_dialog_button("Yes", yes_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
widget_make_default(GTK_WIDGET(button));
gtk_widget_show(GTK_WIDGET(button));
}
{
GtkButton* button = create_modal_dialog_button("No", no_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_show(GTK_WIDGET(button));
}
{
GtkButton* button = create_modal_dialog_button("Cancel", cancel_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_show(GTK_WIDGET(button));
}
dialog.ret = eIDCANCEL;
}
else if (type == eMB_NOYES)
{
{
GtkButton* button = create_modal_dialog_button("No", no_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
widget_make_default(GTK_WIDGET(button));
gtk_widget_show(GTK_WIDGET(button));
}
{
GtkButton* button = create_modal_dialog_button("Yes", yes_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_show(GTK_WIDGET(button));
}
dialog.ret = eIDNO;
}
else /* if (type == eMB_YESNO) */
{
{
GtkButton* button = create_modal_dialog_button("Yes", yes_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
widget_make_default(GTK_WIDGET(button));
gtk_widget_show(GTK_WIDGET(button));
}
{
GtkButton* button = create_modal_dialog_button("No", no_button);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), TRUE, FALSE, 0);
gtk_widget_show(GTK_WIDGET(button));
}
dialog.ret = eIDNO;
}
modal_dialog_show(window, dialog);
gtk_widget_destroy(GTK_WIDGET(window));
return dialog.ret;
}
void
create_main_window (const char *tag, int instance_count)
{
GtkWidget *vbox1;
GtkWidget *menubar1;
GtkWidget *file1;
GtkWidget *file1_menu;
GtkWidget *menu_save;
GtkWidget *menu_patchlist;
GtkWidget *separator1;
GtkWidget *menu_quit;
GtkWidget *help1;
GtkWidget *help1_menu;
GtkWidget *menu_about;
GtkWidget *scrolledwindow1;
GtkWidget *viewport1;
GtkAccelGroup *accel_group;
GdkPixbuf *icon;
if ((icon = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),
"ghostess", 32, 0, NULL)) != NULL) {
gtk_window_set_default_icon(icon);
g_object_unref(icon);
}
accel_group = gtk_accel_group_new ();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (main_window), "main_window", main_window);
gtk_window_set_title (GTK_WINDOW (main_window), tag);
/* gtk_widget_realize(main_window); // window must be realized for create_logo_pixmap() */
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (main_window), vbox1);
menubar1 = gtk_menu_bar_new ();
gtk_widget_ref (menubar1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menubar1", menubar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menubar1);
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
file1 = gtk_menu_item_new_with_label ("File");
gtk_widget_ref (file1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "file1", file1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (file1);
gtk_container_add (GTK_CONTAINER (menubar1), file1);
file1_menu = gtk_menu_new ();
gtk_widget_ref (file1_menu);
gtk_object_set_data_full (GTK_OBJECT (main_window), "file1_menu", file1_menu,
(GtkDestroyNotify) gtk_widget_unref);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (file1), file1_menu);
menu_save = gtk_menu_item_new_with_label ("Save Configuration...");
gtk_widget_ref (menu_save);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_save", menu_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_save);
gtk_container_add (GTK_CONTAINER (file1_menu), menu_save);
gtk_widget_add_accelerator (menu_save, "activate", accel_group,
GDK_S, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_patchlist = gtk_menu_item_new_with_label ("Patchlist Export for Freewheeling...");
gtk_widget_ref (menu_patchlist);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_patchlist", menu_patchlist,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_patchlist);
gtk_container_add (GTK_CONTAINER (file1_menu), menu_patchlist);
gtk_widget_add_accelerator (menu_patchlist, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separator1 = gtk_menu_item_new ();
gtk_widget_ref (separator1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "separator1", separator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (file1_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
menu_quit = gtk_menu_item_new_with_label ("Quit");
gtk_widget_ref (menu_quit);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_quit", menu_quit,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_quit);
gtk_container_add (GTK_CONTAINER (file1_menu), menu_quit);
gtk_widget_add_accelerator (menu_quit, "activate", accel_group,
GDK_Q, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
help1 = gtk_menu_item_new_with_label ("About");
gtk_widget_ref (help1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "help1", help1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (help1);
gtk_container_add (GTK_CONTAINER (menubar1), help1);
gtk_menu_item_right_justify (GTK_MENU_ITEM (help1));
help1_menu = gtk_menu_new ();
gtk_widget_ref (help1_menu);
gtk_object_set_data_full (GTK_OBJECT (main_window), "help1_menu", help1_menu,
(GtkDestroyNotify) gtk_widget_unref);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help1), help1_menu);
menu_about = gtk_menu_item_new_with_label ("About ghostess");
gtk_widget_ref (menu_about);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_about", menu_about,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_about);
gtk_container_add (GTK_CONTAINER (help1_menu), menu_about);
plugin_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (plugin_hbox);
gtk_object_set_data_full (GTK_OBJECT (main_window), "plugin_hbox", plugin_hbox,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (plugin_hbox);
if (instance_count > 5) {
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_range_set_update_policy (GTK_RANGE (GTK_SCROLLED_WINDOW (scrolledwindow1)->vscrollbar), GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0);
gtk_widget_set_size_request(GTK_WIDGET(scrolledwindow1), 400, -1);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_widget_ref (viewport1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "viewport1", viewport1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (viewport1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);
gtk_container_add (GTK_CONTAINER (viewport1), plugin_hbox);
} else {
gtk_box_pack_start (GTK_BOX (vbox1), plugin_hbox, TRUE, TRUE, 0);
}
gtk_signal_connect(GTK_OBJECT(main_window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect (GTK_OBJECT (main_window), "delete_event",
(GtkSignalFunc)on_delete_event_wrapper,
(gpointer)on_menu_quit_activate);
gtk_signal_connect (GTK_OBJECT (menu_save), "activate",
GTK_SIGNAL_FUNC (on_menu_save_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (menu_patchlist), "activate",
GTK_SIGNAL_FUNC (on_menu_patchlist_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (menu_quit), "activate",
GTK_SIGNAL_FUNC (on_menu_quit_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (menu_about), "activate",
GTK_SIGNAL_FUNC (on_menu_about_activate),
NULL);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
}
GtkWidget * create_PlayList( void )
{
GtkWidget * vbox1;
GtkWidget * hbox1;
GtkWidget * scrolledwindow1;
GtkWidget * vbox2;
GtkWidget * scrolledwindow2;
GtkWidget * scrolledwindow3;
GtkWidget * hbuttonbox1;
GtkAccelGroup * accel_group;
GdkColor transparent = { 0,0,0,0 };
gchar * root = "/";
gchar * dummy = "dummy";
DirNodeType * DirNode;
accel_group=gtk_accel_group_new();
PlayList=gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_object_set_data( GTK_OBJECT( PlayList ),"PlayList",PlayList );
gtk_widget_set_usize( PlayList,512,384 );
gtk_window_set_title( GTK_WINDOW( PlayList ),MSGTR_PlayList );
gtk_window_set_position( GTK_WINDOW( PlayList ),GTK_WIN_POS_CENTER );
// gtk_window_set_policy( GTK_WINDOW( PlayList ),FALSE,FALSE,FALSE );
gtk_window_set_wmclass( GTK_WINDOW( PlayList ),"Playlist","MPlayer" );
gtk_widget_realize( PlayList );
gtkAddIcon( PlayList );
vbox1=AddVBox( AddDialogFrame( PlayList ),0 );
hbox1=AddHBox( NULL,1 );
gtk_box_pack_start( GTK_BOX( vbox1 ),hbox1,TRUE,TRUE,0 );
scrolledwindow1=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow1 );
gtk_container_add( GTK_CONTAINER(
AddFrame( NULL,0,hbox1,1 ) ),scrolledwindow1 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow1 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CTDirTree=gtk_ctree_new( 1,0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"tree_expand",GTK_SIGNAL_FUNC( plCTree ),(void*)0 );
gtk_signal_connect( GTK_OBJECT( CTDirTree ),"select_row",GTK_SIGNAL_FUNC( plCTRow ),(void *)0 );
gtk_container_add( GTK_CONTAINER( scrolledwindow1 ),CTDirTree );
gtk_clist_set_column_auto_resize( GTK_CLIST( CTDirTree ),0,TRUE );
gtk_clist_set_column_width( GTK_CLIST( CTDirTree ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CTDirTree ),GTK_SELECTION_SINGLE );
gtk_ctree_set_line_style( GTK_CTREE( CTDirTree ),GTK_CTREE_LINES_SOLID );
gtk_clist_column_titles_show( GTK_CLIST( CTDirTree ) );
gtk_clist_set_shadow_type( GTK_CLIST( CTDirTree ),GTK_SHADOW_NONE );
if ( !pxOpenedBook ) pxOpenedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msOpenedBook,&transparent,book_closed_xpm );
if ( !pxClosedBook ) pxClosedBook=gdk_pixmap_create_from_xpm_d( PlayList->window,&msClosedBook,&transparent,book_open_xpm );
parent=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),NULL,NULL,&root,4,pxOpenedBook,msOpenedBook,pxClosedBook,msClosedBook,FALSE,FALSE );
DirNode=malloc( sizeof( DirNodeType ) );
DirNode->scaned=0; DirNode->path=strdup( root );
gtk_ctree_node_set_row_data_full(GTK_CTREE( CTDirTree ),parent,DirNode,NULL );
sibling=gtk_ctree_insert_node( GTK_CTREE( CTDirTree ),parent,NULL,&dummy,4,NULL,NULL,NULL,NULL,TRUE,TRUE );
gtk_ctree_expand( GTK_CTREE( CTDirTree ),parent );
gtk_widget_show( CTDirTree );
gtk_clist_set_column_widget( GTK_CLIST( CTDirTree ),0,
AddLabel( MSGTR_PLAYLIST_DirectoryTree,NULL ) );
vbox2=AddVBox(
AddFrame( NULL,1,hbox1,1 ),0 );
scrolledwindow2=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow2 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow2,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow2 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLFiles=gtk_clist_new( 1 );
gtk_widget_show( CLFiles );
gtk_container_add( GTK_CONTAINER( scrolledwindow2 ),CLFiles );
gtk_clist_set_column_width( GTK_CLIST( CLFiles ),0,80 );
gtk_clist_set_selection_mode( GTK_CLIST( CLFiles ),GTK_SELECTION_EXTENDED );
gtk_clist_column_titles_show( GTK_CLIST( CLFiles ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLFiles ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLFiles ),0,
AddLabel( MSGTR_PLAYLIST_Files,NULL ) );
AddHSeparator( vbox2 );
scrolledwindow3=gtk_scrolled_window_new( NULL,NULL );
gtk_widget_show( scrolledwindow3 );
gtk_box_pack_start( GTK_BOX( vbox2 ),scrolledwindow3,TRUE,TRUE,0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledwindow3 ),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC );
CLSelected=gtk_clist_new( 2 );
gtk_widget_show( CLSelected );
gtk_container_add( GTK_CONTAINER( scrolledwindow3 ),CLSelected );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),0,295 );
gtk_clist_set_column_width( GTK_CLIST( CLSelected ),1,295 );
gtk_clist_set_selection_mode( GTK_CLIST( CLSelected ),GTK_SELECTION_MULTIPLE );
gtk_clist_column_titles_show( GTK_CLIST( CLSelected ) );
gtk_clist_set_shadow_type( GTK_CLIST( CLSelected ),GTK_SHADOW_NONE );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),0,
AddLabel( MSGTR_PLAYLIST_Selected,NULL ) );
gtk_clist_set_column_widget( GTK_CLIST( CLSelected ),1,
AddLabel( MSGTR_PLAYLIST_Path,NULL ) );
AddHSeparator( vbox1 );
hbuttonbox1=AddHButtonBox( vbox1 );
gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END );
gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 );
Add=AddButton( MSGTR_Add,hbuttonbox1 );
Remove=AddButton( MSGTR_Remove,hbuttonbox1 );
Ok=AddButton( MSGTR_Ok,hbuttonbox1 );
Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 );
gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE );
gtk_signal_connect( GTK_OBJECT( PlayList ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&PlayList );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void *)0 );
gtk_signal_connect( GTK_OBJECT( CLFiles ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void *)0 );
sigSel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"select_row",GTK_SIGNAL_FUNC( plRowSelect ),(void*)1 );
sigUnsel=gtk_signal_connect( GTK_OBJECT( CLSelected ),"unselect_row",GTK_SIGNAL_FUNC( plUnRowSelect ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Add ),"clicked",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)3 );
gtk_signal_connect( GTK_OBJECT( Remove ),"clicked",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)2 );
gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)1 );
gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( plButtonReleased ),(void*)0 );
gtk_window_add_accel_group( GTK_WINDOW( PlayList ),accel_group );
return PlayList;
}
GtkWidget*
create_dbgopt_dbox (void)
{
GtkWidget *dbgopt_dbox;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *frame2;
GtkWidget *hbox3;
GtkWidget *label3;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *label4;
GtkWidget *frame3;
GtkWidget *hbox4;
GtkWidget *label5;
GtkObject *spinbutton2_adj;
GtkWidget *spinbutton2;
GtkWidget *label6;
GtkWidget *frame4;
GtkWidget *hbox5;
GtkWidget *label7;
GtkObject *spinbutton3_adj;
GtkWidget *spinbutton3;
GtkWidget *label8;
GtkWidget *dialog_action_area1;
GtkWidget *hbuttonbox1;
GtkWidget *ok_button;
GtkWidget *hbox2;
GtkWidget *pixmap2;
guint label2_key;
GtkWidget *label2;
GtkWidget *cancel_button;
GtkWidget *hbox1;
GtkWidget *pixmap1;
guint label1_key;
GtkWidget *label1;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
dbgopt_dbox = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (dbgopt_dbox), "dbgopt_dbox", dbgopt_dbox);
gtk_window_set_title (GTK_WINDOW (dbgopt_dbox), _("Advanced settings"));
gtk_window_set_position (GTK_WINDOW (dbgopt_dbox), GTK_WIN_POS_CENTER);
gtk_window_set_policy (GTK_WINDOW (dbgopt_dbox), TRUE, FALSE, TRUE);
dialog_vbox1 = GTK_DIALOG (dbgopt_dbox)->vbox;
gtk_object_set_data (GTK_OBJECT (dbgopt_dbox), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (TRUE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
frame2 = gtk_frame_new (_("Dissasembly window"));
gtk_widget_ref (frame2);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "frame2", frame2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (vbox1), frame2, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame2), 5);
hbox3 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox3);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "hbox3", hbox3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox3);
gtk_container_add (GTK_CONTAINER (frame2), hbox3);
gtk_container_set_border_width (GTK_CONTAINER (hbox3), 5);
label3 = gtk_label_new (_("Size:"));
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (hbox3), label3, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label3), 5, 0);
spinbutton1_adj = gtk_adjustment_new (20, 1, 100, 1, 10, 10);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0);
gtk_widget_ref (spinbutton1);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "spinbutton1", spinbutton1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (hbox3), spinbutton1, FALSE, TRUE, 0);
label4 = gtk_label_new (_("lines"));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (hbox3), label4, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label4), 5, 0);
frame3 = gtk_frame_new (_("Memory window"));
gtk_widget_ref (frame3);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "frame3", frame3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame3);
gtk_box_pack_start (GTK_BOX (vbox1), frame3, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame3), 5);
hbox4 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox4);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "hbox4", hbox4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox4);
gtk_container_add (GTK_CONTAINER (frame3), hbox4);
gtk_container_set_border_width (GTK_CONTAINER (hbox4), 5);
label5 = gtk_label_new (_("Size:"));
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_box_pack_start (GTK_BOX (hbox4), label5, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label5), 5, 0);
spinbutton2_adj = gtk_adjustment_new (20, 1, 100, 1, 10, 10);
spinbutton2 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton2_adj), 1, 0);
gtk_widget_ref (spinbutton2);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "spinbutton2", spinbutton2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spinbutton2);
gtk_box_pack_start (GTK_BOX (hbox4), spinbutton2, FALSE, TRUE, 0);
label6 = gtk_label_new (_("lines"));
gtk_widget_ref (label6);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label6", label6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label6);
gtk_box_pack_start (GTK_BOX (hbox4), label6, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label6), 5, 0);
frame4 = gtk_frame_new (_("Stack window"));
gtk_widget_ref (frame4);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "frame4", frame4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (vbox1), frame4, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame4), 5);
hbox5 = gtk_hbox_new (TRUE, 0);
gtk_widget_ref (hbox5);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "hbox5", hbox5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox5);
gtk_container_add (GTK_CONTAINER (frame4), hbox5);
gtk_container_set_border_width (GTK_CONTAINER (hbox5), 5);
label7 = gtk_label_new (_("Size:"));
gtk_widget_ref (label7);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label7", label7,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label7);
gtk_box_pack_start (GTK_BOX (hbox5), label7, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label7), 5, 0);
spinbutton3_adj = gtk_adjustment_new (10, 1, 50, 1, 10, 10);
spinbutton3 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton3_adj), 1, 0);
gtk_widget_ref (spinbutton3);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "spinbutton3", spinbutton3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spinbutton3);
gtk_box_pack_start (GTK_BOX (hbox5), spinbutton3, FALSE, TRUE, 0);
label8 = gtk_label_new (_("lines"));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (hbox5), label8, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label8), 5, 0);
dialog_action_area1 = GTK_DIALOG (dbgopt_dbox)->action_area;
gtk_object_set_data (GTK_OBJECT (dbgopt_dbox), "dialog_action_area1", dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_ref (hbuttonbox1);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "hbuttonbox1", hbuttonbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE, 0);
ok_button = gtk_button_new ();
gtk_widget_ref (ok_button);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "ok_button", ok_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (ok_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), ok_button);
GTK_WIDGET_SET_FLAGS (ok_button, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (ok_button, "clicked", accel_group,
GDK_Return, 0,
GTK_ACCEL_VISIBLE);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox2);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "hbox2", hbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox2);
gtk_container_add (GTK_CONTAINER (ok_button), hbox2);
pixmap2 = create_pixmap (dbgopt_dbox, "yes.xpm");
gtk_widget_ref (pixmap2);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "pixmap2", pixmap2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap2);
gtk_box_pack_start (GTK_BOX (hbox2), pixmap2, TRUE, TRUE, 0);
label2 = gtk_label_new ("");
label2_key = gtk_label_parse_uline (GTK_LABEL (label2),
_("_OK"));
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (hbox2), label2, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label2), 5, 0);
cancel_button = gtk_button_new ();
gtk_widget_ref (cancel_button);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "cancel_button", cancel_button,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (cancel_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), cancel_button);
GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator (cancel_button, "clicked", accel_group,
GDK_Escape, 0,
GTK_ACCEL_VISIBLE);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (cancel_button), hbox1);
pixmap1 = create_pixmap (dbgopt_dbox, "no.xpm");
gtk_widget_ref (pixmap1);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "pixmap1", pixmap1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap1);
gtk_box_pack_start (GTK_BOX (hbox1), pixmap1, TRUE, TRUE, 0);
label1 = gtk_label_new ("");
label1_key = gtk_label_parse_uline (GTK_LABEL (label1),
_("_Cancel"));
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (dbgopt_dbox), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (label1), 5, 0);
gtk_signal_connect (GTK_OBJECT (dbgopt_dbox), "destroy",
GTK_SIGNAL_FUNC (on_dbgopt_dbox_destroy),
dbgopt_dbox);
gtk_signal_connect (GTK_OBJECT (spinbutton1), "changed",
GTK_SIGNAL_FUNC (on_dbgopt_spinbutton1_changed),
spinbutton1);
gtk_signal_connect (GTK_OBJECT (spinbutton2), "changed",
GTK_SIGNAL_FUNC (on_dbgopt_spinbutton2_changed),
spinbutton2);
gtk_signal_connect (GTK_OBJECT (spinbutton3), "changed",
GTK_SIGNAL_FUNC (on_dbgopt_spinbutton3_changed),
spinbutton3);
gtk_signal_connect (GTK_OBJECT (ok_button), "clicked",
GTK_SIGNAL_FUNC (on_dbgopt_ok_button_clicked),
dbgopt_dbox);
gtk_signal_connect (GTK_OBJECT (cancel_button), "clicked",
GTK_SIGNAL_FUNC (on_dbgopt_cancel_button_clicked),
dbgopt_dbox);
gtk_widget_add_accelerator (ok_button, "clicked", accel_group,
label2_key, GDK_MOD1_MASK, 0);
gtk_widget_add_accelerator (cancel_button, "clicked", accel_group,
label1_key, GDK_MOD1_MASK, 0);
gtk_window_add_accel_group (GTK_WINDOW (dbgopt_dbox), accel_group);
return dbgopt_dbox;
}
GtkWidget* MedSLTPatWindow::CreateMenu(GtkAccelGroup* accel)
{
ACE_TRACE("[MedSLTPatWindow::CreateMenu()]");
GtkMenuItem* connection;
GtkMenuShell* connectionsub;
GtkMenuItem* help;
GtkMenuShell* helpsub;
GtkWidget* connect;
GtkWidget* disconnect;
GtkWidget* quit;
GtkWidget* about;
PangoFontDescription* font;
#ifdef _MAEMO
GtkMenuShell* bar = GTK_MENU_SHELL(gtk_menu_new());
#else
GtkMenuShell* bar = GTK_MENU_SHELL(gtk_menu_bar_new());
#endif
font = pango_font_description_from_string("Monospace Bold 16");
// Connections
connection = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic("_Connections"));
connectionsub = GTK_MENU_SHELL(gtk_menu_new());
connect = gtk_menu_item_new_with_label("Connect to remote...");
disconnect = gtk_menu_item_new_with_label("Disconnect from remote...");
gtk_menu_shell_append(bar, GTK_WIDGET(connection));
gtk_menu_item_set_submenu(connection, GTK_WIDGET(connectionsub));
gtk_menu_shell_append(connectionsub, connect);
gtk_menu_shell_append(connectionsub, disconnect);
g_signal_connect(G_OBJECT(connect), "activate",
G_CALLBACK(ConnectToRemote), this);
g_signal_connect(G_OBJECT(disconnect), "activate",
G_CALLBACK(DisconnectFromRemote), this);
quit = gtk_menu_item_new_with_label("Quit");
gtk_widget_add_accelerator(quit, "activate", accel, GDK_q,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_modify_font(gtk_bin_get_child(GTK_BIN(connection)), font);
gtk_widget_modify_font(gtk_bin_get_child(GTK_BIN(connect)), font);
gtk_widget_modify_font(gtk_bin_get_child(GTK_BIN(disconnect)), font);
gtk_widget_modify_font(gtk_bin_get_child(GTK_BIN(quit)), font);
#ifndef _MAEMO
gtk_menu_shell_append(connectionsub, quit);
#endif
g_signal_connect(G_OBJECT(quit), "activate",
G_CALLBACK(DeleteEvent), this);
// Help
help = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic("_Help"));
helpsub = GTK_MENU_SHELL(gtk_menu_new());
about = gtk_menu_item_new_with_label("About...");
gtk_menu_shell_append(bar, GTK_WIDGET(help));
gtk_menu_item_set_submenu(help, GTK_WIDGET(helpsub));
gtk_menu_shell_append(helpsub, about);
g_signal_connect(G_OBJECT(about), "activate",
G_CALLBACK(ShowAboutDialog), m_window);
gtk_widget_modify_font(gtk_bin_get_child(GTK_BIN(help)), font);
gtk_widget_modify_font(gtk_bin_get_child(GTK_BIN(about)), font);
#ifdef _MAEMO
gtk_menu_shell_append(bar, quit);
#endif
m_conmenu = GTK_WIDGET(connect);
m_disconmenu = GTK_WIDGET(disconnect);
return GTK_WIDGET(bar);
}
