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