GtkWidget *create_main_win(void)
{
GtkWidget *win_main;
GtkWidget *main_box;
GtkWidget *menubar;
GtkWidget *black_label;
GtkWidget *black_label_frame;
GtkWidget *white_label;
GtkWidget *white_label_frame;
GtkWidget *label_box;
GtkWidget *again_button;
GtkWidget *drawingarea;
GtkWidget *statusbar;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
win_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_object_set_data(G_OBJECT(win_main), "main_win", win_main);
gtk_window_set_title(GTK_WINDOW(win_main), _("Reversi"));
main_box = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(main_box);
g_object_set_data_full(G_OBJECT(win_main), "main_box", main_box,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(main_box);
gtk_container_add(GTK_CONTAINER(win_main), main_box);
menubar = create_menus(win_main);
gtk_widget_ref(menubar);
g_object_set_data_full(G_OBJECT(win_main), "menubar", menubar,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(menubar);
gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0);
// Create labels frames
white_label_frame = gtk_frame_new(NULL);
gtk_widget_ref(white_label_frame);
g_object_set_data_full(G_OBJECT(win_main), "white_label_frame",
white_label_frame,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(white_label_frame);
black_label_frame = gtk_frame_new(NULL);
gtk_widget_ref(black_label_frame);
g_object_set_data_full(G_OBJECT(win_main), "black_label_frame",
black_label_frame,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(black_label_frame);
// Create labels
white_label = gtk_label_new("White: 0");
// Why is that? Really don't know, but all the other scripts have it!
gtk_widget_ref(white_label);
g_object_set_data_full(G_OBJECT(win_main), "white_label",
white_label,
(GtkDestroyNotify) gtk_widget_unref);
black_label = gtk_label_new("Black: 0");
gtk_widget_ref(black_label);
g_object_set_data_full(G_OBJECT(win_main), "black_label",
black_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_container_add(GTK_CONTAINER(white_label_frame), white_label);
gtk_container_add(GTK_CONTAINER(black_label_frame), black_label);
gtk_widget_show(white_label);
gtk_widget_show(black_label);
// Play again button
again_button = gtk_button_new_with_label("Play again");
gtk_widget_ref(again_button);
g_object_set_data_full(G_OBJECT(win_main), "again_button",
again_button,
(GtkDestroyNotify) gtk_widget_unref);
//gtk_container_add(GTK_CONTAINER(win_main), again_button);
// Label box
label_box = gtk_hbox_new(TRUE, 5);
gtk_widget_ref(label_box);
g_object_set_data_full(G_OBJECT(win_main), "label_box", label_box,
(GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start(GTK_BOX(label_box), black_label_frame, FALSE,
TRUE, 0);
gtk_box_pack_start(GTK_BOX(label_box), again_button, TRUE, TRUE,
0);
gtk_box_pack_end(GTK_BOX(label_box), white_label_frame, FALSE,
TRUE, 0);
gtk_widget_show(label_box);
gtk_box_pack_start(GTK_BOX(main_box), label_box, FALSE, TRUE, 0);
// Drawing area
drawingarea = gtk_drawing_area_new();
gtk_widget_ref(drawingarea);
g_object_set_data_full(G_OBJECT(win_main), "drawingarea",
drawingarea,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(drawingarea);
gtk_box_pack_start(GTK_BOX(main_box), drawingarea, TRUE, TRUE, 0);
gtk_widget_set_size_request(drawingarea, 48 * 8, 48 * 8);
gtk_widget_set_events(drawingarea,
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
// Status bar
statusbar = gtk_statusbar_new();
gtk_widget_ref(statusbar);
g_object_set_data_full(G_OBJECT(win_main), "statusbar", statusbar,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(statusbar);
gtk_box_pack_start(GTK_BOX(main_box), statusbar, FALSE, FALSE, 0);
g_signal_connect(GTK_OBJECT(win_main), "delete_event",
GTK_SIGNAL_FUNC(main_exit), NULL);
g_signal_connect(GTK_OBJECT(win_main), "realize",
GTK_SIGNAL_FUNC(on_main_win_realize), NULL);
g_signal_connect(GTK_OBJECT(drawingarea), "configure_event",
GTK_SIGNAL_FUNC(configure_handle), NULL);
g_signal_connect(GTK_OBJECT(drawingarea), "expose_event",
GTK_SIGNAL_FUNC(expose_handle), NULL);
g_signal_connect(GTK_OBJECT(drawingarea), "button_press_event",
GTK_SIGNAL_FUNC(handle_move), NULL);
g_signal_connect(GTK_OBJECT(again_button), "clicked",
GTK_SIGNAL_FUNC(play_again), NULL);
gtk_window_add_accel_group(GTK_WINDOW(win_main), accel_group);
return win_main;
}
static void
anjuta_window_instance_init (AnjutaWindow *win)
{
GtkWidget *menubar, *about_menu;
GtkWidget *view_menu, *hbox;
GtkWidget *main_box;
GtkWidget *dockbar;
GtkAction* action;
GList *plugins_dirs = NULL;
GdkGeometry size_hints = {
100, 100, 0, 0, 100, 100, 1, 1, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
};
DEBUG_PRINT ("%s", "Initializing Anjuta...");
gtk_window_set_geometry_hints (GTK_WINDOW (win), GTK_WIDGET (win),
&size_hints, GDK_HINT_RESIZE_INC);
gtk_window_set_resizable (GTK_WINDOW (win), TRUE);
/*
* Main box
*/
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (win), main_box);
gtk_widget_show (main_box);
win->values = NULL;
win->widgets = NULL;
win->maximized = FALSE;
/* Settings */
win->settings = g_settings_new (PREF_SCHEMA);
/* Status bar */
win->status = ANJUTA_STATUS (anjuta_status_new ());
anjuta_status_set_title_window (win->status, GTK_WIDGET (win));
gtk_widget_show (GTK_WIDGET (win->status));
gtk_box_pack_end (GTK_BOX (main_box),
GTK_WIDGET (win->status), FALSE, TRUE, 0);
g_object_ref (G_OBJECT (win->status));
g_object_add_weak_pointer (G_OBJECT (win->status), (gpointer)&win->status);
/* configure dock */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (hbox);
win->dock = gdl_dock_new ();
gtk_widget_show (win->dock);
gtk_box_pack_end(GTK_BOX (hbox), win->dock, TRUE, TRUE, 0);
dockbar = gdl_dock_bar_new (G_OBJECT (win->dock));
gtk_widget_show (dockbar);
gtk_box_pack_start(GTK_BOX (hbox), dockbar, FALSE, FALSE, 0);
win->layout_manager = gdl_dock_layout_new (G_OBJECT (win->dock));
g_signal_connect (win->layout_manager, "notify::dirty",
G_CALLBACK (on_layout_dirty_notify), win);
g_signal_connect (gdl_dock_layout_get_master (win->layout_manager), "notify::locked",
G_CALLBACK (on_layout_locked_notify), win);
/* UI engine */
win->ui = anjuta_ui_new ();
g_object_add_weak_pointer (G_OBJECT (win->ui), (gpointer)&win->ui);
/* show tooltips in the statusbar */
g_signal_connect (win->ui,
"connect_proxy",
G_CALLBACK (connect_proxy_cb),
win);
g_signal_connect (win->ui,
"disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb),
win);
/* Plugin Manager */
plugins_dirs = g_list_prepend (plugins_dirs, PACKAGE_PLUGIN_DIR);
win->plugin_manager = anjuta_plugin_manager_new (G_OBJECT (win),
win->status,
plugins_dirs);
win->profile_manager = anjuta_profile_manager_new (win->plugin_manager);
g_list_free (plugins_dirs);
/* Preferences */
win->preferences = anjuta_preferences_new (win->plugin_manager, PREF_SCHEMA);
g_object_add_weak_pointer (G_OBJECT (win->preferences),
(gpointer)&win->preferences);
g_signal_connect (win->settings, "changed::" GDL_STYLE,
G_CALLBACK (on_gdl_style_changed), win);
on_gdl_style_changed (win->settings, GDL_STYLE, win);
/* Register actions */
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupFile", _("File"),
menu_entries_file,
G_N_ELEMENTS (menu_entries_file),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupEdit", _("Edit"),
menu_entries_edit,
G_N_ELEMENTS (menu_entries_edit),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupView", _("View"),
menu_entries_view,
G_N_ELEMENTS (menu_entries_view),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_toggle_action_group_entries (win->ui, "ActionGroupToggleView",
_("View"),
menu_entries_toggle_view,
G_N_ELEMENTS (menu_entries_toggle_view),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupHelp", _("Help"),
menu_entries_help,
G_N_ELEMENTS (menu_entries_help),
GETTEXT_PACKAGE, TRUE, win);
/* Merge UI */
anjuta_ui_merge (win->ui, UI_FILE);
/* Adding accels group */
gtk_window_add_accel_group (GTK_WINDOW (win),
gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (win->ui)));
/* create main menu */
menubar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (win->ui),
"/MenuMain");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* create toolbar */
win->toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (win->ui),
"/ToolbarMain");
if (!g_settings_get_boolean (win->settings, TOOLBAR_VISIBLE))
gtk_widget_hide (win->toolbar);
gtk_style_context_add_class (gtk_widget_get_style_context (win->toolbar),
GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (win->toolbar),
GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (main_box), win->toolbar, FALSE, FALSE, 0);
action = gtk_ui_manager_get_action (GTK_UI_MANAGER (win->ui),
"/MenuMain/MenuView/Toolbar");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION(action),
g_settings_get_boolean (win->settings,
TOOLBAR_VISIBLE));
g_signal_connect (win->settings, "changed::" TOOLBAR_STYLE,
G_CALLBACK (on_toolbar_style_changed), win);
on_toolbar_style_changed (win->settings, TOOLBAR_STYLE, win);
/* Create widgets menu */
view_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(win->ui),
"/MenuMain/MenuView");
win->view_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (view_menu));
/* Create about plugins menu */
about_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(win->ui),
"/MenuMain/PlaceHolderHelpMenus/MenuHelp/"
"PlaceHolderHelpAbout/AboutPlugins");
about_create_plugins_submenu (ANJUTA_SHELL (win), about_menu);
/* Add main view */
gtk_box_pack_start (GTK_BOX (main_box), hbox, TRUE, TRUE, 0);
/* Connect to session */
g_signal_connect (G_OBJECT (win), "save_session",
G_CALLBACK (on_session_save), win);
g_signal_connect (G_OBJECT (win), "load_session",
G_CALLBACK (on_session_load), win);
/* Loading accels */
anjuta_ui_load_accels (NULL);
win->save_count = 0;
}
static void
create_window (MduShell *shell)
{
GtkWidget *vbox;
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *menubar;
GtkAccelGroup *accel_group;
GtkWidget *hpane;
GtkWidget *tree_view_scrolled_window;
GtkTreeSelection *select;
GtkWidget *label;
GtkTreeViewColumn *column;
GError *error;
error = NULL;
if (!add_pool (shell, NULL, NULL, &error)) {
g_printerr ("Error creating pool: `%s'\n", error->message);
g_error_free (error);
g_critical ("Bailing out");
}
shell->priv->app_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (shell->priv->app_window), TRUE);
gtk_window_set_default_size (GTK_WINDOW (shell->priv->app_window), 800, 600);
gtk_window_set_title (GTK_WINDOW (shell->priv->app_window), _("Disk Utility"));
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (shell->priv->app_window), vbox);
shell->priv->ui_manager = create_ui_manager (shell);
accel_group = gtk_ui_manager_get_accel_group (shell->priv->ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (shell->priv->app_window), accel_group);
menubar = gtk_ui_manager_get_widget (shell->priv->ui_manager, "/menubar");
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
/* tree view */
tree_view_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tree_view_scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tree_view_scrolled_window),
GTK_SHADOW_IN);
shell->priv->model = mdu_pool_tree_model_new (shell->priv->pools,
NULL,
MDU_POOL_TREE_MODEL_FLAGS_NO_VOLUMES);
shell->priv->tree_view = mdu_pool_tree_view_new (shell->priv->model,
MDU_POOL_TREE_VIEW_FLAGS_NONE);
g_object_unref (shell->priv->model);
gtk_container_add (GTK_CONTAINER (tree_view_scrolled_window), shell->priv->tree_view);
/* --- */
vbox1 = gtk_vbox_new (FALSE, 0);
/* --- */
vbox2 = gtk_vbox_new (FALSE, 0);
//gtk_container_set_border_width (GTK_CONTAINER (vbox2), 12);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
/* --- */
shell->priv->sections_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (shell->priv->sections_vbox), 6);
gtk_box_pack_start (GTK_BOX (vbox2), shell->priv->sections_vbox, TRUE, TRUE, 0);
/* setup and add horizontal pane */
hpane = gtk_hpaned_new ();
label = gtk_label_new (NULL);
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
_("_Storage Devices"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), shell->priv->tree_view);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (shell->priv->tree_view), 0);
gtk_tree_view_column_set_widget (column, label);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (shell->priv->tree_view), TRUE);
gtk_widget_show (label);
gtk_paned_add1 (GTK_PANED (hpane), tree_view_scrolled_window);
gtk_paned_add2 (GTK_PANED (hpane), vbox1);
gtk_widget_set_size_request (shell->priv->tree_view, 260, -1),
//gtk_paned_set_position (GTK_PANED (hpane), 260);
gtk_box_pack_start (GTK_BOX (vbox), hpane, TRUE, TRUE, 0);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (shell->priv->tree_view));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (select, "changed", (GCallback) device_tree_changed, shell);
/* when starting up, set focus on tree view */
gtk_widget_grab_focus (shell->priv->tree_view);
g_signal_connect (shell->priv->app_window, "delete-event", gtk_main_quit, NULL);
gtk_widget_show_all (vbox);
mdu_pool_tree_view_select_first_presentable (MDU_POOL_TREE_VIEW (shell->priv->tree_view));
}
int main (int argc, char *argv[]) {
/* set up i18n */
bindtextdomain (PACKAGE, GUMMI_LOCALES);
setlocale (LC_ALL, "");
textdomain (PACKAGE);
GError* error = NULL;
GOptionContext* context = g_option_context_new ("files");
g_option_context_add_main_entries (context, entries, PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
if (error) g_error("%s\n", error->message);
if (showversion) {
printf("Gummi %s\n", PACKAGE_VERSION);
return 0;
}
/* initialize GTK */
g_thread_init (NULL);
gdk_threads_init ();
gtk_init (&argc, &argv);
GError* ui_error = NULL;
GtkBuilder* builder = gtk_builder_new ();
gchar* ui = g_build_filename (GUMMI_DATA, "ui", "gummi.glade", NULL);
// exit program when gummi.glade can not be located:
if (!g_file_test (ui, G_FILE_TEST_EXISTS)) {
printf("Could not locate Glade interface file at:\n%s\n", ui);
return 0;
}
gtk_builder_add_from_file (builder, ui, &ui_error);
if (ui_error) {
g_error ("%s\n", ui_error->message);
}
gtk_builder_set_translation_domain (builder, PACKAGE);
g_free (ui);
/* Initialize logging */
slog_init (debug);
slog (L_INFO, PACKAGE_NAME" version: "PACKAGE_VERSION"\n");
/* Initialize configuration */
gchar* configname = g_build_filename (g_get_user_config_dir (), "gummi",
"gummi.cfg", NULL);
config_init (configname);
config_load ();
g_free (configname);
/* Initialize signals */
gummi_signals_register ();
/* Initialize Classes */
gchar* snippetsname = g_build_filename (g_get_user_config_dir (), "gummi",
"snippets.cfg", NULL);
// why do we not load this from environment, like gui-main does? -A
GuMotion* motion = motion_init ();
GuIOFunc* io = iofunctions_init();
GuLatex* latex = latex_init ();
GuBiblio* biblio = biblio_init (builder);
GuTemplate* templ = template_init (builder);
GuTabmanager* tabm = tabmanager_init ();
GuProject* proj = project_init ();
GuSnippets* snippets = snippets_init (snippetsname);
gummi = gummi_init (motion, io, latex, biblio, templ, snippets, tabm, proj);
slog (L_DEBUG, "Gummi created!\n");
g_free (snippetsname);
/* Initialize GUI */
gui = gui_init (builder);
slog_set_gui_parent (gui->mainwindow);
slog (L_DEBUG, "GummiGui created!\n");
/* Start compile thread */
if (external_exists (config_get_value("typesetter"))) {
typesetter_setup ();
motion_start_compile_thread (motion);
}
else {
infoscreengui_enable (gui->infoscreengui, "program_error");
slog (L_ERROR, "Could not locate the typesetter program\n");
}
/* Install acceleration group to mainwindow */
gtk_window_add_accel_group (gui->mainwindow, snippets->accel_group);
if (argc != 2)
tabmanager_create_tab (A_DEFAULT, NULL, NULL);
else {
if (!g_file_test(argv[1], G_FILE_TEST_EXISTS)) {
slog(L_ERROR, "Failed to open file '%s': No such file or "
"directory\n", argv[1]);
exit(1);
}
tabmanager_create_tab (A_LOAD, argv[1], NULL);
}
if (config_get_value ("autosaving")) iofunctions_start_autosave ();
gui_main (builder);
config_save ();
config_clean_up ();
return 0;
}
void gtkui_create_menu(int live)
{
GtkAccelGroup *accel_group;
GtkWidget *vbox, *item;
GtkItemFactory *root_menu;
int num_items = 0;
DEBUG_MSG("gtk_create_menu");
/* remove old menu, it will be automatically destroyed by gtk_main */
vbox = gtk_bin_get_child(GTK_BIN (window));
gtk_container_remove(GTK_CONTAINER (vbox), main_menu);
/* Prepare to generate menus from the definitions in ec_gtk.h */
accel_group = gtk_accel_group_new ();
root_menu = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* Start Menu */
num_items = sizeof (gmenu_start) / sizeof (gmenu_start[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_start, NULL);
/* Targets Menu */
num_items = sizeof (gmenu_targets) / sizeof (gmenu_targets[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_targets, NULL);
/* Hosts Menu */
if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) {
num_items = sizeof (gmenu_hosts) / sizeof (gmenu_hosts[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_hosts, NULL);
}
/* View Menu */
num_items = sizeof (gmenu_view) / sizeof (gmenu_view[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_view, NULL);
/* MITM Menu */
if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) {
num_items = sizeof (gmenu_mitm) / sizeof (gmenu_mitm[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_mitm, NULL);
}
/* Filters Menu */
num_items = sizeof (gmenu_filters) / sizeof (gmenu_filters[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_filters, NULL);
/* Logging Menu */
num_items = sizeof (gmenu_logging) / sizeof (gmenu_logging[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_logging, NULL);
#ifdef HAVE_PLUGINS
/* Plugins Menu */
if(live > 0) {
num_items = sizeof (gmenu_plugins) / sizeof (gmenu_plugins[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_plugins, NULL);
}
#endif
#ifndef OS_WINDOWS
/* Help Menu */
num_items = sizeof (gmenu_help) / sizeof (gmenu_help[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_help, NULL);
#endif
if(GBL_OPTIONS->reversed) {
GBL_OPTIONS->reversed = 0;
item = gtk_item_factory_get_item(root_menu, "/Targets/Reverse matching");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->resolve) {
GBL_OPTIONS->resolve = 0;
item = gtk_item_factory_get_item(root_menu, "/View/Resolve IP addresses");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->compress) {
GBL_OPTIONS->compress = 0;
item = gtk_item_factory_get_item(root_menu, "/Logging/Compressed file");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
/* get the menu widget and add it to the window */
main_menu = gtk_item_factory_get_widget (root_menu, "<main>");
gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0);
gtk_widget_show(main_menu);
}
static bool_t init (void)
{
search_tool = aud_plugin_lookup_basename ("search-tool");
aud_config_set_defaults ("gtkui", gtkui_defaults);
pw_col_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL);
accel = gtk_accel_group_new ();
gtk_window_add_accel_group ((GtkWindow *) window, accel);
vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add ((GtkContainer *) window, vbox_outer);
menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS);
GtkStyleContext * context = gtk_widget_get_style_context (toolbar);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0);
/* search button */
if (search_tool)
{
search_button = toggle_button_new ("edit-find", toggle_search_tool);
gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1);
gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button,
aud_plugin_get_enabled (search_tool));
aud_plugin_add_watch (search_tool, search_tool_toggled, NULL);
}
/* playback buttons */
toolbar_button_add (toolbar, button_open_pressed, "document-open");
toolbar_button_add (toolbar, button_add_pressed, "list-add");
button_play = toolbar_button_add (toolbar, aud_drct_play_pause, "media-playback-start");
button_stop = toolbar_button_add (toolbar, aud_drct_stop, "media-playback-stop");
toolbar_button_add (toolbar, aud_drct_pl_prev, "media-skip-backward");
toolbar_button_add (toolbar, aud_drct_pl_next, "media-skip-forward");
/* time slider and label */
GtkToolItem * boxitem1 = gtk_tool_item_new ();
gtk_tool_item_set_expand (boxitem1, TRUE);
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1);
GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem1, box1);
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_range_set_increments ((GtkRange *) slider, 5000, 5000);
gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE);
gtk_widget_set_size_request(slider, 120, -1);
gtk_widget_set_valign (slider, GTK_ALIGN_CENTER);
gtk_widget_set_can_focus(slider, FALSE);
gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6);
label_time = markup_label_new(NULL);
gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6);
gtk_widget_set_no_show_all (slider, TRUE);
gtk_widget_set_no_show_all (label_time, TRUE);
/* repeat and shuffle buttons */
button_repeat = toggle_button_new ("media-playlist-repeat", toggle_repeat);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1);
button_shuffle = toggle_button_new ("media-playlist-shuffle", toggle_shuffle);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1);
/* volume button */
GtkToolItem * boxitem2 = gtk_tool_item_new ();
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1);
GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem2, box2);
volume = gtk_volume_button_new();
gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE);
gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0)));
gtk_widget_set_can_focus(volume, FALSE);
int lvol = 0, rvol = 0;
aud_drct_get_volume(&lvol, &rvol);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2);
gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0);
/* main UI layout */
layout_load ();
GtkWidget * layout = layout_new ();
gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
layout_add_center (vbox);
ui_playlist_notebook_new ();
gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0);
/* optional UI elements */
show_menu (aud_get_bool ("gtkui", "menu_visible"));
show_infoarea (aud_get_bool ("gtkui", "infoarea_visible"));
if (aud_get_bool ("gtkui", "statusbar_visible"))
{
statusbar = ui_statusbar_new ();
gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0);
}
AUDDBG("hooks associate\n");
ui_hooks_associate();
AUDDBG("playlist associate\n");
ui_playlist_notebook_populate();
g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL);
g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL);
g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL);
volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL);
g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL);
g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL);
update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume);
g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL);
g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL);
g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL);
if (aud_drct_get_playing ())
{
ui_playback_begin ();
if (aud_drct_get_ready ())
ui_playback_ready ();
}
else
ui_playback_stop ();
title_change_cb ();
gtk_widget_show_all (vbox_outer);
update_toggles (NULL, NULL);
menu_rclick = make_menu_rclick (accel);
menu_tab = make_menu_tab (accel);
return TRUE;
}
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;
}
/*主界面进入点*/
int main(int argc,char **argv)
{
GtkWidget *win;
GtkWidget *menu;
GtkWidget *menu_bar;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *text;
GtkWidget *scrolled;
GtkWidget *open;
GtkWidget *close;
GtkWidget *clean;
GtkTextBuffer *buffer;
GtkAccelGroup *accel_group;
PangoFontDescription *font_name;
DATA data;
CONFDATA conf;
ABOUT about_data;
//HELP help_data;
struct sigaction act,old;
setpgrp();
init_with_conf(&conf);
init_about_data(&about_data);
//init_help_data(&help_data);
data.buf=g_string_new(NULL);
data.python_path=conf.python_path;
data.proxy_py_path=conf.proxy_py_path;
setlocale(LC_ALL,"");
/*设置语言环境*/
if(conf.language_env == NULL)
{
setlocale(LC_CTYPE,"zh_CN.UTF-8");
setenv("LANG","zh_CN.UTF-8",1);
}
else
{
setlocale(LC_CTYPE,conf.language_env);
setenv("LANG",conf.language_env,1);
}
if(conf.gtk_goagent_path!=NULL)
chdir(conf.gtk_goagent_path);
/*是否自动更新
* 如果是则在后台运行版更新进程
*/
if(strcmp(conf.goagent_auto_upgrade,"true")==0)
auto_upgrade_goagent(GOAGENT_URL,&conf);
/*国际化*/
bindtextdomain("gtk_goagent","./locale/");
textdomain("gtk_goagent");
act.sa_flags=0;
act.sa_handler=clean_data;
/*设置自定义信号处理
* 用于在启动GoAgent失败时清理数据
*/
sigaction(SIGUSR1,&act,&old);
gtk_init(&argc,&argv);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(win),"Gtk GoAgent");
gtk_window_set_icon_from_file(GTK_WINDOW(win),"img/64x64/gtk_goagent.png",NULL);
create_tray(win);
//create_pre_ui(&pre,&conf);
vbox=gtk_vbox_new(FALSE,0);
accel_group=gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(win),accel_group);
gtk_container_add(GTK_CONTAINER(win),vbox);
text=gtk_text_view_new();
/*设置日志显示框字体*/
if(conf.font!=NULL)
{
font_name=pango_font_description_from_string(conf.font);
gtk_widget_modify_font(text,font_name);
}
buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
/*创建红色黑色和黄色标记
* 正常日志黑色输出
* 绿色用于警告
* 红色用于错误
* 黄色用于调试
*/
gtk_text_buffer_create_tag(buffer,"green_fg",
"foreground","green",NULL);
gtk_text_buffer_create_tag(buffer,"red_fg","foreground",
"red",NULL);
gtk_text_buffer_create_tag(buffer,"black_fg","foreground",
"black",NULL);
gtk_text_buffer_create_tag(buffer,"yellow_fg",
"foreground","yellow",NULL);
data.text=text;
data.off=0;
menu_bar=gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox),menu_bar,FALSE,FALSE,0);
/*创建菜单*/
menu=create_menu(menu_bar,_("_File"));
create_menu_with_image(menu,GTK_STOCK_OPEN,accel_group,connect_goagent,&data);
create_menu_with_image(menu,GTK_STOCK_CLOSE,accel_group,disconnect_goagent,&data);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),gtk_separator_menu_item_new());
create_menu_with_image(menu,GTK_STOCK_QUIT,accel_group,really_quit,&data);
menu=create_menu(menu_bar,_("_Edit"));
create_menu_with_image(menu,GTK_STOCK_PREFERENCES,accel_group,preferences,NULL);
create_menu_with_image(menu,_("Up_load"),accel_group,upload,&conf);
menu=create_menu(menu_bar,_("_Help"));
create_menu_with_image(menu,GTK_STOCK_HELP,accel_group,help,NULL);
create_menu_with_image(menu,GTK_STOCK_ABOUT,accel_group,about,&about_data);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),gtk_separator_menu_item_new());
create_menu_with_image(menu,_("Upgrade GoAg_ent"),accel_group,upgrade_goagent,conf.proxy_py_path);
//create_menu_with_image(menu,_("Upgrade _Gtk GoAGent"),accel_group,upgrade_gtk_goagent,NULL);
gtk_widget_set_size_request(text,0x300,0x180);
/*设置显示构件不可编辑和自动换行*/
gtk_text_view_set_editable(GTK_TEXT_VIEW(text),FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text),GTK_WRAP_CHAR);
/*创建滚动条并设置自动更新*/
scrolled=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrolled),text);
gtk_box_pack_start(GTK_BOX(vbox),scrolled,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),gtk_separator_menu_item_new(),FALSE,FALSE,5);
show_time(vbox);
gtk_box_pack_start(GTK_BOX(vbox),gtk_separator_menu_item_new(),FALSE,FALSE,5);
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);
open=gtk_button_new_with_label(_("Connect"));
gtk_box_pack_start(GTK_BOX(hbox),open,FALSE,FALSE,30);
g_signal_connect(G_OBJECT(open),"clicked",G_CALLBACK(connect_goagent),&data);
clean=gtk_button_new_with_label(_("Clean"));
gtk_box_pack_start(GTK_BOX(hbox),clean,TRUE,TRUE,100);
g_signal_connect(G_OBJECT(clean),"clicked",G_CALLBACK(clean_buffer),&data);
close=gtk_button_new_with_label(_("Disconnect"));
gtk_box_pack_end(GTK_BOX(hbox),close,FALSE,FALSE,30);
g_signal_connect(G_OBJECT(close),"clicked",G_CALLBACK(disconnect_goagent),&data);
g_signal_connect(G_OBJECT(win),"delete_event",G_CALLBACK(really_quit),NULL);
gtk_widget_show_all(win);
gtk_main();
//setpgrp();
g_idle_remove_by_data(&data);
g_string_free(data.buf,TRUE);
kill(0,SIGKILL);
//killpg(getpgrp(),SIGKILL);
while(waitpid(-1,NULL,WNOHANG)!=-1);
//g_idle_remove_by_data(&data);
return 0;
}
void IWindow::add_accel_group(AccelGroup group)
{
gtk_window_add_accel_group(this, group);
}
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);
}
BOOL
create_confirm (HWND hwnd, LPCSTR dsn, LPCSTR text)
{
GtkWidget *confirm, *dialog_vbox1, *hbox1, *pixmap1, *l_text;
GtkWidget *dialog_action_area1, *hbuttonbox1, *b_yes, *b_no;
guint b_yes_key, b_no_key;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GtkAccelGroup *accel_group;
char msg[1024];
TCONFIRM confirm_t;
if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
return FALSE;
accel_group = gtk_accel_group_new ();
confirm = gtk_dialog_new ();
if (dsn)
sprintf (msg, "Confirm action/operation on %s", dsn);
else
sprintf (msg, "Confirm action/operation ...");
gtk_object_set_data (GTK_OBJECT (confirm), "confirm", confirm);
gtk_widget_set_size_request (confirm, 400, 150);
gtk_window_set_title (GTK_WINDOW (confirm), msg);
gtk_window_set_position (GTK_WINDOW (confirm), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (confirm), TRUE);
gtk_window_set_default_size (GTK_WINDOW (confirm), 400, 150);
gtk_window_set_type_hint (GTK_WINDOW (confirm), GDK_WINDOW_TYPE_HINT_DIALOG);
#if GTK_CHECK_VERSION(2,0,0)
gtk_widget_show (confirm);
#endif
dialog_vbox1 = GTK_DIALOG (confirm)->vbox;
gtk_object_set_data (GTK_OBJECT (confirm), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
hbox1 = gtk_hbox_new (FALSE, 6);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (confirm), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 6);
#if GTK_CHECK_VERSION(2,0,0)
style = gtk_widget_get_style (confirm);
pixmap =
gdk_pixmap_create_from_xpm_d (confirm->window, &mask,
&style->bg[GTK_STATE_NORMAL], (gchar **) question_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 **) question_xpm);
#endif
pixmap1 = gtk_pixmap_new (pixmap, mask);
gtk_widget_ref (pixmap1);
gtk_object_set_data_full (GTK_OBJECT (confirm), "pixmap1", pixmap1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pixmap1);
gtk_box_pack_start (GTK_BOX (hbox1), pixmap1, FALSE, FALSE, 0);
l_text = gtk_label_new ("");
gtk_label_parse_uline (GTK_LABEL (l_text), text);
gtk_widget_ref (l_text);
gtk_object_set_data_full (GTK_OBJECT (confirm), "l_text", l_text,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (l_text);
gtk_box_pack_start (GTK_BOX (hbox1), l_text, TRUE, TRUE, 0);
gtk_label_set_justify (GTK_LABEL (l_text), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (l_text), TRUE);
dialog_action_area1 = GTK_DIALOG (confirm)->action_area;
gtk_object_set_data (GTK_OBJECT (confirm), "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 (confirm), "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_yes = gtk_button_new_from_stock ("gtk-yes");
gtk_widget_ref (b_yes);
gtk_object_set_data_full (GTK_OBJECT (confirm), "b_yes", b_yes,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_yes);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_yes);
gtk_dialog_add_action_widget (GTK_DIALOG (confirm), b_yes, GTK_RESPONSE_YES);
GTK_WIDGET_SET_FLAGS (b_yes, GTK_CAN_DEFAULT);
b_no = gtk_button_new_from_stock ("gtk-no");
gtk_widget_ref (b_no);
gtk_object_set_data_full (GTK_OBJECT (confirm), "b_no", b_no,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_no);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_no);
gtk_dialog_add_action_widget (GTK_DIALOG (confirm), b_no, GTK_RESPONSE_NO);
GTK_WIDGET_SET_FLAGS (b_no, GTK_CAN_DEFAULT);
/* Yes button events */
gtk_signal_connect (GTK_OBJECT (b_yes), "clicked",
GTK_SIGNAL_FUNC (confirm_yes_clicked), &confirm_t);
/* No button events */
gtk_signal_connect (GTK_OBJECT (b_no), "clicked",
GTK_SIGNAL_FUNC (confirm_no_clicked), &confirm_t);
/* Close window button events */
gtk_signal_connect (GTK_OBJECT (confirm), "delete_event",
GTK_SIGNAL_FUNC (delete_event), &confirm_t);
gtk_signal_connect (GTK_OBJECT (confirm), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_window_add_accel_group (GTK_WINDOW (confirm), accel_group);
confirm_t.yes_no = FALSE;
confirm_t.mainwnd = confirm;
gtk_widget_show_all (confirm);
gtk_main ();
return confirm_t.yes_no;
}
/* Returns a menubar widget made from the above menu */
static GtkWidget *_get_menubar_menu(GtkWidget *window, GtkWidget *notebook)
{
GtkAccelGroup *accel_group = NULL;
GError *error = NULL;
char *ui_description;
GtkActionEntry entries[] = {
{"actions", NULL, "_Actions", "<alt>a"},
{"options", NULL, "_Options", "<alt>o"},
{"displays", NULL, "_Query", "<alt>q"},
{"batch_job", NULL, "Batch Job", "", "Submit batch job",
G_CALLBACK(create_create_popup)},
{"partition", NULL, "Partition", "", "Create partition",
G_CALLBACK(create_create_popup)},
{"reservation", NULL, "Reservation", "", "Create reservation",
G_CALLBACK(create_create_popup)},
{"search", GTK_STOCK_FIND, "Search", ""},
{"jobid", NULL, "Job ID",
"", "Search for jobid",
G_CALLBACK(create_search_popup)},
{"user_jobs", NULL, "Specific User's Job(s)",
"", "Search for a specific users job(s)",
G_CALLBACK(create_search_popup)},
{"state_jobs", NULL, "Job(s) in a Specific State",
"", "Search for job(s) in a specific state",
G_CALLBACK(create_search_popup)},
{"partition_name", NULL, "Slurm Partition Name",
"", "Search for a specific SLURM partition",
G_CALLBACK(create_search_popup)},
{"partition_state", NULL, "Slurm Partition State",
"", "Search for SLURM partitions in a given state",
G_CALLBACK(create_search_popup)},
{"reservation_name", NULL, "Reservation Name",
"", "Search for reservation",
G_CALLBACK(create_search_popup)},
{"tab_pos", NULL, "_Tab Position"},
{"create", GTK_STOCK_ADD, "Create"},
{"interval", GTK_STOCK_REFRESH, "Set Refresh _Interval",
"<control>i", "Change Refresh Interval",
G_CALLBACK(change_refresh_popup)},
{"refresh", GTK_STOCK_REFRESH, "Refresh",
"F5", "Refreshes page", G_CALLBACK(refresh_main)},
{"config", GTK_STOCK_INFO, "_Config Info",
"<control>c", "Displays info from slurm.conf file",
G_CALLBACK(create_config_popup)},
{"dbconfig", GTK_STOCK_INFO, "_Database Config Info",
"<control>d",
"Displays info relevant to the "
"configuration of the Slurm Database.",
G_CALLBACK(create_dbconfig_popup)},
{"exit", GTK_STOCK_QUIT, "E_xit",
"<control>x", "Exits Program", G_CALLBACK(_delete)},
{"help", NULL, "_Help", "<alt>h"},
{"about", GTK_STOCK_ABOUT, "Ab_out", "<control>o",
"About", G_CALLBACK(about_popup)},
{"usage", GTK_STOCK_HELP, "Usage", "",
"Usage", G_CALLBACK(usage_popup)},
//{"manual", GTK_STOCK_HELP, "_Manual", "<control>m"},
{"grid_specs", GTK_STOCK_EDIT, "Set Grid _Properties",
"<control>p", "Change Grid Properties",
G_CALLBACK(change_grid_popup)},
{"defaults", GTK_STOCK_EDIT, "_Set Default Settings",
"<control>s", "Change Default Settings",
G_CALLBACK(configure_defaults)},
};
GtkActionEntry bg_entries[] = {
{"bg_block_name", NULL, "BG Block Name",
"", "Search for a specific BG Block",
G_CALLBACK(create_search_popup)},
{"bg_block_size", NULL, "BG Block Size",
"",
"Search for BG Blocks having given size in cnodes",
G_CALLBACK(create_search_popup)},
{"bg_block_state", NULL, "BG Block State",
"",
"Search for BG Blocks having given state",
G_CALLBACK(create_search_popup)},
{"node_name_bg", NULL,
"Midplane(s) Name",
"", "Search for a specific Midplane(s)",
G_CALLBACK(create_search_popup)},
{"node_state_bg", NULL,
"Midplane State",
"", "Search for a Midplane in a given state",
G_CALLBACK(create_search_popup)},
};
GtkActionEntry nonbg_entries[] = {
{"node_name", NULL,
"Node(s) Name",
"", "Search for a specific Node(s)",
G_CALLBACK(create_search_popup)},
{"node_state", NULL,
"Node State",
"", "Search for a Node in a given state",
G_CALLBACK(create_search_popup)},
};
GtkActionEntry admin_entries[] = {
{"reconfig", GTK_STOCK_REDO, "SLUR_M Reconfigure",
"<control>m", "Reconfigures System",
G_CALLBACK(_reconfigure)},
{"debugflags", GTK_STOCK_DIALOG_WARNING,
"Slurmctld DebugFlags",
"", "Set slurmctld DebugFlags",
G_CALLBACK(_get_current_debug_flags)},
{"debuglevel", GTK_STOCK_DIALOG_WARNING,
"Slurmctld Debug Level",
"", "Set slurmctld debug level",
G_CALLBACK(_get_current_debug)},
};
GtkRadioActionEntry radio_entries[] = {
{"tab_top", GTK_STOCK_GOTO_TOP, "_Top",
"<control>T", "Move tabs to top", GTK_POS_TOP},
{"tab_bottom", GTK_STOCK_GOTO_BOTTOM, "_Bottom",
"<control>B", "Move tabs to the bottom", GTK_POS_BOTTOM},
{"tab_left", GTK_STOCK_GOTO_FIRST, "_Left",
"<control>L", "Move tabs to the Left", GTK_POS_LEFT},
{"tab_right", GTK_STOCK_GOTO_LAST, "_Right",
"<control>R", "Move tabs to the Right", GTK_POS_RIGHT}
};
GtkToggleActionEntry toggle_entries[] = {
{"grid", GTK_STOCK_SELECT_COLOR, "Show _Grid",
"<control>g", "Visual display of cluster",
G_CALLBACK(_set_grid), working_sview_config.show_grid},
{"hidden", GTK_STOCK_SELECT_COLOR, "Show _Hidden",
"<control>h", "Display Hidden Partitions/Jobs",
G_CALLBACK(_set_hidden), working_sview_config.show_hidden},
{"page_opts", GTK_STOCK_SELECT_COLOR, "Save Page Options",
"<control>w", "Save Page Options",
G_CALLBACK(_set_page_opts),
working_sview_config.save_page_opts},
#ifdef WANT_TOPO_ON_MAIN_OPTIONS
{"topoorder", GTK_STOCK_SELECT_COLOR, "Set Topology Grid",
"<control>t", "Set Topology Grid",
G_CALLBACK(_set_topogrid),
working_sview_config.grid_topological},
#endif
{"ruled", GTK_STOCK_SELECT_COLOR, "R_uled Tables",
"<control>u", "Have ruled tables or not",
G_CALLBACK(_set_ruled), working_sview_config.ruled_treeview},
{"admin", GTK_STOCK_PREFERENCES,
"_Admin Mode", "<control>a",
"Allows user to change or update information",
G_CALLBACK(_set_admin_mode),
working_sview_config.admin_mode}
};
GtkRadioActionEntry debug_entries[] = {
{"debug_quiet", NULL, "quiet(0)", "", "Quiet level", 0},
{"debug_fatal", NULL, "fatal(1)", "", "Fatal level", 1},
{"debug_error", NULL, "error(2)", "", "Error level", 2},
{"debug_info", NULL, "info(3)", "", "Info level", 3},
{"debug_verbose", NULL, "verbose(4)", "", "Verbose level", 4},
{"debug_debug", NULL, "debug(5)", "", "Debug debug level", 5},
{"debug_debug2", NULL, "debug2(6)", "", "Debug2 level", 6},
{"debug_debug3", NULL, "debug3(7)", "", "Debug3 level", 7},
{"debug_debug4", NULL, "debug4(8)", "", "Debug4 level", 8},
{"debug_debug5", NULL, "debug5(9)", "", "Debug5 level", 9},
};
char *all_debug_flags = debug_flags2str(0xFFFFFFFFFFFFFFFF);
char *last = NULL;
char *tok = strtok_r(all_debug_flags, ",", &last);
/* set up the global debug_actions */
debug_actions = xmalloc(sizeof(GtkToggleActionEntry));
while (tok) {
xrealloc(debug_actions,
(debug_action_entries + 1)
* sizeof(GtkToggleActionEntry));
debug_actions[debug_action_entries].name =
debug_actions[debug_action_entries].label =
debug_actions[debug_action_entries].tooltip =
xstrdup(tok);
debug_actions[debug_action_entries].callback =
G_CALLBACK(_set_flags);
debug_action_entries++;
tok = strtok_r(NULL, ",", &last);
}
xfree(all_debug_flags);
/* Make an accelerator group (shortcut keys) */
menu_action_group = gtk_action_group_new ("MenuActions");
gtk_action_group_add_actions(menu_action_group, entries,
G_N_ELEMENTS(entries), window);
gtk_action_group_add_actions(menu_action_group, bg_entries,
G_N_ELEMENTS(bg_entries), window);
gtk_action_group_add_actions(menu_action_group, nonbg_entries,
G_N_ELEMENTS(nonbg_entries),
window);
gtk_action_group_add_radio_actions(menu_action_group, radio_entries,
G_N_ELEMENTS(radio_entries),
working_sview_config.tab_pos,
G_CALLBACK(_tab_pos), notebook);
gtk_action_group_add_toggle_actions(menu_action_group, debug_actions,
debug_action_entries, NULL);
gtk_action_group_add_radio_actions(menu_action_group, debug_entries,
G_N_ELEMENTS(debug_entries),
-1, G_CALLBACK(_set_debug),
notebook);
gtk_action_group_add_toggle_actions(menu_action_group, toggle_entries,
G_N_ELEMENTS(toggle_entries),
NULL);
admin_action_group = gtk_action_group_new ("MenuAdminActions");
gtk_action_group_add_actions(admin_action_group, admin_entries,
G_N_ELEMENTS(admin_entries),
window);
gtk_action_group_set_sensitive(admin_action_group,
working_sview_config.admin_mode);
g_ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(g_ui_manager, menu_action_group, 0);
gtk_ui_manager_insert_action_group(g_ui_manager, admin_action_group, 1);
accel_group = gtk_ui_manager_get_accel_group(g_ui_manager);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
ui_description = _get_ui_description();
if (!(g_menu_id = gtk_ui_manager_add_ui_from_string(
g_ui_manager, ui_description, -1, &error))) {
xfree(ui_description);
g_error("building menus failed: %s", error->message);
g_error_free (error);
exit (0);
}
xfree(ui_description);
/* GList *action_list = */
/* gtk_action_group_list_actions(menu_action_group); */
/* GtkAction *action = NULL; */
/* int i=0; */
/* while ((action = g_list_nth_data(action_list, i++))) { */
/* g_print("got %s and %x\n", gtk_action_get_name(action), */
/* action); */
/* } */
/* Get the pointers to the correct action so if we ever need
to change it we can effect the action directly so
everything stays in sync.
*/
default_sview_config.action_admin =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "admin");
default_sview_config.action_grid =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "grid");
default_sview_config.action_hidden =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "hidden");
default_sview_config.action_page_opts =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "page_opts");
// default_sview_config.action_gridtopo =
// (GtkToggleAction *)gtk_action_group_get_action(
// menu_action_group, "topoorder");
default_sview_config.action_ruled =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "ruled");
/* Pick the first one of the Radio, it is how GTK references
the group in the future.
*/
default_sview_config.action_tab =
(GtkRadioAction *)gtk_action_group_get_action(
menu_action_group, "tab_top");
/* g_print("action grid is %x\n", default_sview_config.action_grid); */
/* Finally, return the actual menu bar created by the item factory. */
return gtk_ui_manager_get_widget (g_ui_manager, "/main");
}
static void
anjuta_app_instance_init (AnjutaApp *app)
{
gint merge_id;
GtkWidget *menubar, *about_menu;
GtkWidget *view_menu, *hbox;
GtkWidget *main_box;
GtkWidget *dockbar;
GtkAction* action;
GList *plugins_dirs = NULL;
gchar* style;
GdkGeometry size_hints = {
100, 100, 0, 0, 100, 100, 1, 1, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
};
DEBUG_PRINT ("%s", "Initializing Anjuta...");
gtk_window_set_geometry_hints (GTK_WINDOW (app), GTK_WIDGET (app),
&size_hints, GDK_HINT_RESIZE_INC);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
/*
* Main box
*/
main_box = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (app), main_box);
gtk_widget_show (main_box);
app->values = NULL;
app->widgets = NULL;
/* Status bar */
app->status = ANJUTA_STATUS (anjuta_status_new ());
anjuta_status_set_title_window (app->status, GTK_WIDGET (app));
gtk_widget_show (GTK_WIDGET (app->status));
gtk_box_pack_end (GTK_BOX (main_box),
GTK_WIDGET (app->status), FALSE, TRUE, 0);
g_object_ref (G_OBJECT (app->status));
g_object_add_weak_pointer (G_OBJECT (app->status), (gpointer)&app->status);
/* configure dock */
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
app->dock = gdl_dock_new ();
gtk_widget_show (app->dock);
gtk_box_pack_end(GTK_BOX (hbox), app->dock, TRUE, TRUE, 0);
dockbar = gdl_dock_bar_new (GDL_DOCK(app->dock));
gtk_widget_show (dockbar);
gtk_box_pack_start(GTK_BOX (hbox), dockbar, FALSE, FALSE, 0);
app->layout_manager = gdl_dock_layout_new (GDL_DOCK (app->dock));
g_signal_connect (app->layout_manager, "notify::dirty",
G_CALLBACK (on_layout_dirty_notify), app);
g_signal_connect (app->layout_manager->master, "notify::locked",
G_CALLBACK (on_layout_locked_notify), app);
/* UI engine */
app->ui = anjuta_ui_new ();
g_object_add_weak_pointer (G_OBJECT (app->ui), (gpointer)&app->ui);
/* show tooltips in the statusbar */
g_signal_connect (app->ui,
"connect_proxy",
G_CALLBACK (connect_proxy_cb),
app);
g_signal_connect (app->ui,
"disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb),
app);
/* Plugin Manager */
plugins_dirs = g_list_prepend (plugins_dirs, PACKAGE_PLUGIN_DIR);
app->plugin_manager = anjuta_plugin_manager_new (G_OBJECT (app),
app->status,
plugins_dirs);
app->profile_manager = anjuta_profile_manager_new (app->plugin_manager);
g_list_free (plugins_dirs);
/* Preferences */
app->preferences = anjuta_preferences_new (app->plugin_manager);
g_object_add_weak_pointer (G_OBJECT (app->preferences),
(gpointer)&app->preferences);
anjuta_preferences_notify_add_string (app->preferences, "anjuta.gdl.style",
on_gdl_style_changed, app, NULL);
style = anjuta_preferences_get (app->preferences, "anjuta.gdl.style");
on_gdl_style_changed (app->preferences, NULL,
style, app);
g_free (style);
/* Register actions */
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupFile", _("File"),
menu_entries_file,
G_N_ELEMENTS (menu_entries_file),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupEdit", _("Edit"),
menu_entries_edit,
G_N_ELEMENTS (menu_entries_edit),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupView", _("View"),
menu_entries_view,
G_N_ELEMENTS (menu_entries_view),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_toggle_action_group_entries (app->ui, "ActionGroupToggleView",
_("View"),
menu_entries_toggle_view,
G_N_ELEMENTS (menu_entries_toggle_view),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupHelp", _("Help"),
menu_entries_help,
G_N_ELEMENTS (menu_entries_help),
GETTEXT_PACKAGE, TRUE, app);
/* Merge UI */
merge_id = anjuta_ui_merge (app->ui, UI_FILE);
/* Adding accels group */
gtk_window_add_accel_group (GTK_WINDOW (app),
gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (app->ui)));
/* create main menu */
menubar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (app->ui),
"/MenuMain");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* create toolbar */
app->toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (app->ui),
"/ToolbarMain");
if (!anjuta_preferences_get_bool (app->preferences, "anjuta.toolbar.visible"))
gtk_widget_hide (app->toolbar);
gtk_box_pack_start (GTK_BOX (main_box), app->toolbar, FALSE, FALSE, 0);
action = gtk_ui_manager_get_action (GTK_UI_MANAGER (app->ui),
"/MenuMain/MenuView/Toolbar");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION(action),
anjuta_preferences_get_bool_with_default (app->preferences,
"anjuta.toolbar.visible",
TRUE));
anjuta_preferences_notify_add_string (app->preferences, "anjuta.toolbar.style",
on_toolbar_style_changed, app, NULL);
style = anjuta_preferences_get (app->preferences, "anjuta.toolbar.style");
on_toolbar_style_changed (app->preferences, NULL, style, app);
g_free (style);
/* Create widgets menu */
view_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(app->ui),
"/MenuMain/MenuView");
app->view_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (view_menu));
/* Disable unavailible tutorials */
action = anjuta_ui_get_action(app->ui, "ActionGroupHelp", "ActionHelpTutorial");
g_object_set(G_OBJECT(action), "visible", FALSE, NULL);
action = anjuta_ui_get_action(app->ui, "ActionGroupHelp", "ActionHelpAdvancedTutorial");
g_object_set(G_OBJECT(action), "visible", FALSE, NULL);
/* Create about plugins menu */
about_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(app->ui),
"/MenuMain/PlaceHolderHelpMenus/MenuHelp/"
"PlaceHolderHelpAbout/AboutPlugins");
about_create_plugins_submenu (ANJUTA_SHELL (app), about_menu);
/* Add main view */
gtk_box_pack_start (GTK_BOX (main_box), hbox, TRUE, TRUE, 0);
/* Connect to session */
g_signal_connect (G_OBJECT (app), "save_session",
G_CALLBACK (on_session_save), app);
g_signal_connect (G_OBJECT (app), "load_session",
G_CALLBACK (on_session_load), app);
/* Loading accels */
anjuta_ui_load_accels (NULL);
app->save_count = 0;
}
void
c_main_window_initialize (CMainWindow * self)
{
GtkActionGroup* actions;
GtkUIManager * ui_manager;
GtkActionEntry entries[] = {
{"File", NULL, N_("_File")},
{"FileClose", GTK_STOCK_CLOSE, NULL,
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (file_close_activated)},
{"Edit", NULL, N_("_Edit")},
{"EditCopy", GTK_STOCK_COPY, NULL,
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (edit_copy_activated)},
{"EditDelete", GTK_STOCK_DELETE, NULL,
"Delete", NULL, // FIXME: add tooltip
G_CALLBACK (edit_delete_activated)},
{"EditPaste", GTK_STOCK_PASTE, NULL,
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (edit_paste_activated)},
{"EditRename", NULL, N_("_Rename"),
"F2", NULL, // FIXME: add tooltip
G_CALLBACK (edit_rename)},
{"TaskBottom", GTK_STOCK_GOTO_BOTTOM, N_("To _Bottom"),
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (task_bottom_activated)},
{"TaskNew", GTK_STOCK_ADD, NULL,
"<Ctrl>n", NULL, // FIXME: add tooltip
G_CALLBACK (task_new_activated)},
{"TaskTop", GTK_STOCK_GOTO_TOP, N_("To _Top"),
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (task_top_activated)},
{"View", NULL, N_("_View")},
{"ViewExpandAll", NULL, N_("_Expand All"),
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (view_expand_all_activated)},
{"ViewCollapseAll", NULL, N_("_Collapse All"),
NULL, NULL, // FIXME: add tooltip
G_CALLBACK (view_collapse_all_activated)}
};
GError * error = NULL;
g_return_if_fail (C_IS_MAIN_WINDOW (self));
ui_manager = gtk_ui_manager_new ();
g_object_set (self,
"ui-manager", ui_manager,
NULL);
gtk_window_set_default_size (GTK_WINDOW (self),
400, 300);
gtk_window_set_title (GTK_WINDOW (self),
_("List of Tasks"));
gtk_window_add_accel_group (GTK_WINDOW (self),
gtk_ui_manager_get_accel_group (ui_manager));
actions = gtk_action_group_new (g_type_name (C_TYPE_MAIN_WINDOW));
gtk_action_group_add_actions (actions, entries, G_N_ELEMENTS (entries), self);
gtk_ui_manager_insert_action_group (ui_manager, actions, -1);
g_object_unref (actions);
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
"<toolbar name='toolbar'>"
"<toolitem action='TaskNew'/>"
"<placeholder name='remove'/>"
"<separator/>"
"<toolitem action='TaskTop'/>"
"<toolitem action='TaskBottom'/>"
"</toolbar>"
"</ui>",
-1,
&error);
if (error) {
g_warning ("Error setting up the user interface: %s",
error->message);
g_error_free (error);
error = NULL;
}
g_object_unref (ui_manager);
}
void gtkui_create_menu(int live)
{
GtkAccelGroup *accel_group;
GtkWidget *vbox, *main_menu;
GtkActionGroup *menuactions;
GtkAction *action;
GError *error = NULL;
GClosure *closure = NULL;
gint keyval;
GdkModifierType mods;
const gchar *menu_structure =
"<ui>"
" <menubar name='MenuBar'>"
" <menu name='StartMenu' action='StartMenuAction'>"
" <menuitem name='SniffStart' action='SniffStartAction' />"
" <menuitem name='SniffStop' action='SniffStopAction' />"
" <separator />"
" <menuitem name='Exit' action='ExitAction' />"
" </menu>"
" <menu name='TargetsMenu' action='TargetsMenuAction'>"
" <menuitem name='CurrentTargets' action='CurrentTargetsAction' />"
" <menuitem name='SelectTargets' action='SelectTargetsAction' />"
" <separator />"
" <menuitem name='Protocol' action='ProtocolAction' />"
" <menuitem name='ReverseMatching' action='ReverseMatchingAction' />"
" <separator />"
" <menuitem name='WipeTargets' action='WipeTargetsAction' />"
" </menu>"
" <menu name='HostsMenu' action='HostsMenuAction'>"
" <menuitem name='HostsList' action='HostsListAction' />"
" <separator />"
#ifdef WITH_IPV6
" <menuitem name='EnableIPv6Scan' action='EnableIPv6ScanAction' />"
#endif
" <menuitem name='ScanHosts' action='ScanHostsAction' />"
" <menuitem name='LoadHosts' action='LoadHostsAction' />"
" <menuitem name='SaveHosts' action='SaveHostsAction' />"
" </menu>"
" <menu name='ViewMenu' action='ViewMenuAction'>"
" <menuitem name='ViewConnections' action='ViewConnectionsAction' />"
" <menuitem name='ViewProfiles' action='ViewProfilesAction' />"
" <menuitem name='ViewStatistics' action='ViewStatisticsAction' />"
" <separator />"
" <menuitem name='ResolveIpAddresses' action='ResolveIpAddressesAction' />"
" <menuitem name='VisualisationMethod' action='VisualisationMethodAction' />"
" <menuitem name='VisualisationRegex' action='VisualisationRegexAction' />"
" <separator />"
" <menuitem name='SetWifiKey' action='SetWifiKeyAction' />"
" </menu>"
" <menu name='MitmMenu' action='MitmMenuAction'>"
" <menuitem name='ArpPoisoning' action='ArpPoisoningAction' />"
" <menuitem name='IcmpRedirect' action='IcmpRedirectAction' />"
" <menuitem name='PortStealing' action='PortStealingAction' />"
" <menuitem name='DhcpSpoofing' action='DhcpSpoofingAction' />"
#ifdef WITH_IPV6
" <menuitem name='NdpPoisoning' action='NdpPoisoningAction' />"
#endif
" <separator />"
" <menuitem name='StopMitmAttacks' action='StopMitmAttacksAction' />"
" </menu>"
" <menu name='FiltersMenu' action='FiltersMenuAction'>"
" <menuitem name='LoadFilter' action='LoadFilterAction' />"
" <menuitem name='StopFilter' action='StopFilterAction' />"
" </menu>"
" <menu name='LoggingMenu' action='LoggingMenuAction'>"
" <menuitem name='LoggingAll' action='LoggingAllAction' />"
" <menuitem name='LoggingInfo' action='LoggingInfoAction' />"
" <menuitem name='LoggingStop' action='LoggingStopAction' />"
" <separator />"
" <menuitem name='LogMessages' action='LogMessagesAction' />"
" <menuitem name='LogMessagesStop' action='LogMessagesStopAction' />"
" <separator />"
" <menuitem name='LogCompressed' action='LogCompressedAction' />"
" </menu>"
#ifdef HAVE_PLUGINS
" <menu name='PluginsMenu' action='PluginsMenuAction'>"
" <menuitem name='ManagePlugins' action='ManagePluginsAction' />"
" <menuitem name='LoadPlugin' action='LoadPluginAction' />"
" </menu>"
#endif
" <menu name='HelpMenu' action='HelpMenuAction'>"
#ifndef OS_WINDOWS
" <menuitem name='Help' action='HelpAction' />"
#endif
" <menuitem name='About' action='AboutDialogAction' />"
" </menu>"
" </menubar>"
"</ui>";
GtkActionEntry start_menu_items[] = {
/* Start Menu */
{
"StartMenuAction", NULL,
"_Start", NULL,
NULL, NULL
},
{
"SniffStartAction", GTK_STOCK_YES,
"Start sniffing", "<control><shift>w",
NULL, G_CALLBACK(gtkui_start_sniffing)
},
{
"SniffStopAction", GTK_STOCK_NO,
"Stop sniffing", "<control><shift>e",
NULL, G_CALLBACK(gtkui_stop_sniffing)
},
{
"ExitAction", GTK_STOCK_QUIT,
"E_xit", "<control>q",
NULL, G_CALLBACK(gtkui_exit)
}
};
GtkActionEntry targets_menu_items[] = {
/* Targets Menu */
{
"TargetsMenuAction", NULL,
"_Targets", NULL,
NULL, NULL
},
{
"CurrentTargetsAction", GTK_STOCK_FIND,
"Current targets", "<control>t",
NULL, G_CALLBACK(gtkui_current_targets)
},
{
"SelectTargetsAction", GTK_STOCK_ADD,
"Select target(s)", "<control><shift>t",
NULL, G_CALLBACK(gtkui_select_targets)
},
{
"ProtocolAction", GTK_STOCK_JUMP_TO,
"_Protocol...", "<control>p",
NULL, G_CALLBACK(gtkui_select_protocol)
},
{
"WipeTargetsAction", GTK_STOCK_CLEAR,
"_Wipe targets", "<control>W",
NULL, G_CALLBACK(wipe_targets)
}
};
GtkActionEntry hosts_menu_items[] = {
/* Hosts Menu */
{
"HostsMenuAction", NULL,
"_Hosts", NULL,
NULL, NULL
},
{
"HostsListAction", GTK_STOCK_INDEX,
"_Hosts list", "<control>h",
NULL, G_CALLBACK(gtkui_host_list)
},
{
"ScanHostsAction", GTK_STOCK_FIND,
"_Scan for hosts", "<control>s",
NULL, G_CALLBACK(gtkui_scan)
},
{
"LoadHostsAction", GTK_STOCK_OPEN,
"Load from file...", "",
NULL, G_CALLBACK(gtkui_load_hosts)
},
{
"SaveHostsAction", GTK_STOCK_SAVE,
"Save to file...", "",
NULL, G_CALLBACK(gtkui_save_hosts)
}
};
GtkActionEntry view_menu_items[] = {
/* View Menu */
{
"ViewMenuAction", NULL,
"_View", NULL,
NULL, NULL
},
{
"ViewConnectionsAction", GTK_STOCK_JUSTIFY_FILL,
"_Connections", "<control><shift>c",
NULL, G_CALLBACK(gtkui_show_connections)
},
{
"ViewProfilesAction", GTK_STOCK_JUSTIFY_LEFT,
"Pr_ofiles", "<control>o",
NULL, G_CALLBACK(gtkui_show_profiles)
},
{
"ViewStatisticsAction", GTK_STOCK_PROPERTIES,
"_Statistics", NULL,
NULL, G_CALLBACK(gtkui_show_stats)
},
{
"VisualisationMethodAction", GTK_STOCK_PREFERENCES,
"_Visualisation method...", "<control><shift>v",
NULL, G_CALLBACK(gtkui_vis_method)
},
{
"VisualisationRegexAction", GTK_STOCK_FIND,
"Visualisation _regex...", "<control>R",
NULL, G_CALLBACK(gtkui_vis_regex)
},
{
"SetWifiKeyAction", GTK_STOCK_FIND,
"Set the _WiFi key...", NULL,
NULL, G_CALLBACK(gtkui_wifi_key)
}
};
GtkActionEntry mitm_menu_items[] = {
/* Mitm Menu */
{
"MitmMenuAction", NULL,
"_Mitm", NULL,
NULL, NULL
},
{
"ArpPoisoningAction", NULL,
"ARP poisoning...", NULL,
NULL, G_CALLBACK(gtkui_arp_poisoning)
},
{
"IcmpRedirectAction", NULL,
"ICMP redirect...", NULL,
NULL, G_CALLBACK(gtkui_icmp_redir)
},
{
"PortStealingAction", NULL,
"Port stealing...", NULL,
NULL, G_CALLBACK(gtkui_port_stealing)
},
{
"DhcpSpoofingAction", NULL,
"DHCP spoofing...", NULL,
NULL, G_CALLBACK(gtkui_dhcp_spoofing)
},
#ifdef WITH_IPV6
{
"NdpPoisoningAction", NULL,
"NDP poisoning...", NULL,
NULL, G_CALLBACK(gtkui_ndp_poisoning)
},
#endif
{
"StopMitmAttacksAction", NULL,
"Stop mitm attack(s)", NULL,
NULL, G_CALLBACK(gtkui_mitm_stop)
}
};
GtkActionEntry filters_menu_items[] = {
/* Filters Menu */
{
"FiltersMenuAction", NULL,
"_Filters", NULL,
NULL, NULL
},
{
"LoadFilterAction", GTK_STOCK_OPEN,
"Load a filter...", "<control>f",
NULL, G_CALLBACK(gtkui_load_filter)
},
{
"StopFilterAction", GTK_STOCK_STOP,
"Stop _filtering", "<control><shift>f",
NULL, G_CALLBACK(gtkui_stop_filter)
}
};
GtkActionEntry logging_menu_items[] = {
/* Logging Menu */
{
"LoggingMenuAction", NULL,
"_Logging", NULL,
NULL, NULL
},
{
"LoggingAllAction", GTK_STOCK_SAVE,
"Logging all packets and infos...", "<control><shift>i",
NULL, G_CALLBACK(gtkui_log_all)
},
{
"LoggingInfoAction", GTK_STOCK_SAVE_AS,
"Logging only infos...", "<control>i",
NULL, G_CALLBACK(gtkui_log_info)
},
{
"LoggingStopAction", GTK_STOCK_STOP,
"Stop logging infos", NULL,
NULL, G_CALLBACK(gtkui_stop_log)
},
{
"LogMessagesAction", GTK_STOCK_REVERT_TO_SAVED,
"Log user messages...", "<control>m",
NULL, G_CALLBACK(gtkui_log_msg)
},
{
"LogMessagesStopAction", GTK_STOCK_STOP,
"Stop logging messages", NULL,
NULL, G_CALLBACK(gtkui_stop_msg)
}
};
#ifdef HAVE_PLUGINS
GtkActionEntry plugins_menu_items[] = {
/* Plugins Menu */
{
"PluginsMenuAction", NULL,
"_Plugins", NULL,
NULL, NULL
},
{
"ManagePluginsAction", GTK_STOCK_EXECUTE,
"Manage the plugins", "<control>p",
NULL, G_CALLBACK(gtkui_plugin_mgmt)
},
{
"LoadPluginAction", GTK_STOCK_OPEN,
"Load a plugin...", NULL,
NULL, G_CALLBACK(gtkui_plugin_load)
}
};
#endif
GtkActionEntry help_menu_items[] = {
/* Help Menu */
{
"HelpMenuAction", NULL,
"_Info", NULL,
NULL, NULL
},
#ifndef OS_WINDOWS
{
"HelpAction", GTK_STOCK_HELP,
"Help", "F1",
NULL, G_CALLBACK(gtkui_help)
},
#endif
{
"AboutDialogAction", GTK_STOCK_ABOUT,
"About", NULL,
NULL, G_CALLBACK(gtkui_about)
}
};
GtkToggleActionEntry toggle_items[] = {
{
"ReverseMatchingAction", NULL,
"Reverse matching", NULL,
NULL, G_CALLBACK(toggle_reverse),
FALSE
},
#ifdef WITH_IPV6
{
"EnableIPv6ScanAction", NULL,
"Enable IPv6 scan", NULL,
NULL, G_CALLBACK(toggle_ip6scan),
FALSE
},
#endif
{
"ResolveIpAddressesAction", NULL,
"Resolve IP addresses", NULL,
NULL, G_CALLBACK(toggle_resolve),
FALSE
},
{
"LogCompressedAction", NULL,
"Compressed file", NULL,
NULL, G_CALLBACK(toggle_compress),
FALSE
}
};
DEBUG_MSG("gtk_create_menu");
/* remove old menu, it will be automatically destroyed by gtk_main */
vbox = gtk_bin_get_child(GTK_BIN (window));
main_menu = gtk_ui_manager_get_widget(menu_manager, "/MenuBar");
gtk_widget_hide(main_menu);
gtk_ui_manager_remove_ui(menu_manager, merge_id);
menuactions = gtk_action_group_new("MenuActions");
/* Start Menu */
gtk_action_group_add_actions(menuactions, start_menu_items, G_N_ELEMENTS(start_menu_items), NULL);
/* Targets Menu */
gtk_action_group_add_actions(menuactions, targets_menu_items, G_N_ELEMENTS(targets_menu_items), NULL);
/* Hosts Menu */
gtk_action_group_add_actions(menuactions, hosts_menu_items, G_N_ELEMENTS(hosts_menu_items), NULL);
/* View Menu */
gtk_action_group_add_actions(menuactions, view_menu_items, G_N_ELEMENTS(view_menu_items), NULL);
/* MITM Menu */
gtk_action_group_add_actions(menuactions, mitm_menu_items, G_N_ELEMENTS(mitm_menu_items), NULL);
/* Filters Menu */
gtk_action_group_add_actions(menuactions, filters_menu_items, G_N_ELEMENTS(filters_menu_items), NULL);
/* Logging Menu */
gtk_action_group_add_actions(menuactions, logging_menu_items, G_N_ELEMENTS(logging_menu_items), NULL);
#ifdef HAVE_PLUGINS
/* Plugins Menu */
gtk_action_group_add_actions(menuactions, plugins_menu_items, G_N_ELEMENTS(plugins_menu_items), NULL);
#endif
#ifndef OS_WINDOWS
/* Help Menu */
gtk_action_group_add_actions(menuactions, help_menu_items, G_N_ELEMENTS(help_menu_items), NULL);
#endif
gtk_action_group_add_toggle_actions(menuactions, toggle_items, G_N_ELEMENTS(toggle_items), NULL);
menu_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(menu_manager, menuactions, 0);
merge_id = gtk_ui_manager_add_ui_from_string(menu_manager, menu_structure, -1, &error);
if (error) {
g_message("building menu failed: %s", error->message);
g_error_free(error);
error = NULL;
}
/* Some hidden accellerators */
accel_group = gtk_accel_group_new ();
closure = g_cclosure_new(G_CALLBACK(gtkui_exit), NULL, NULL);
gtk_accelerator_parse("<control>X", &keyval, &mods);
gtk_accel_group_connect(accel_group, keyval, mods, 0, closure);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(menu_manager));
if(GBL_OPTIONS->reversed) {
GBL_OPTIONS->reversed = 0;
action = gtk_ui_manager_get_action(menu_manager, "/MenuBar/TargetsMenu/ReverseMatching");
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), TRUE);
}
if(GBL_OPTIONS->resolve) {
GBL_OPTIONS->resolve = 0;
action = gtk_ui_manager_get_action(menu_manager, "/MenuBar/ViewMenu/ResolveIpAddresses");
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), TRUE);
}
if(GBL_OPTIONS->compress) {
GBL_OPTIONS->compress = 0;
action = gtk_ui_manager_get_action(menu_manager, "/MenuBar/LoggingMenu/LogCompressed");
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), TRUE);
}
/* Some menus doesn't apply if started in offline or bridged sniffing mode */
if (live == 0 || GBL_SNIFF->type == SM_BRIDGED) {
gtk_widget_set_visible(gtk_ui_manager_get_widget(menu_manager, "/MenuBar/HostsMenu"), FALSE);
gtk_widget_set_visible(gtk_ui_manager_get_widget(menu_manager, "/MenuBar/MitmMenu"), FALSE);
}
#ifdef HAVE_PLUGINS
if (live == 0)
gtk_widget_set_visible(gtk_ui_manager_get_widget(menu_manager, "/MenuBar/PluginsMenu"), FALSE);
#endif
/* get the menu widget and add it to the window */
main_menu = gtk_ui_manager_get_widget(menu_manager, "/MenuBar");
gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0);
gtk_widget_show(main_menu);
}
gint main(gint argc, gchar *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *subMenu;
GtkWidget *menuitem;
GtkWidget *toolbar;
GtkActionGroup* actiongroup;
GtkUIManager* ui_manager;//主界面，包含了待建立的界面和相关的动作
gtk_init(&argc, &argv);
/**********初始化主界面$$$$$$$$**********{*/
/*初始化主界面相关动作信息*/
action_init(&actiongroup, &ui_manager);
/*初始华主界面具体界面信息*/
ui_init(&actiongroup, &ui_manager);
/**********初始化主界面$$$$$$$$**********}*/
/*window*/
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "destroy"
, G_CALLBACK(gtk_main_quit), NULL);
/*添加快捷键*/
gtk_window_add_accel_group(GTK_WINDOW(window),
gtk_ui_manager_get_accel_group(ui_manager));
/*vbox*/
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
/***********使用、设置主界面中的元素$$$$$$******{*/
/*从主界面获取一个部件的方法,便于添加到窗口中为什么这里有一个警告？*/
menubar = gtk_ui_manager_get_widget(ui_manager, "/menubar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
/*从主界面获取一个菜单项的方法,获取之后设置其属性*/
menuitem = gtk_ui_manager_get_widget(ui_manager, "/menubar/Menu1/menuitem1.1");
/*从主界面把本来可以点击的菜单按钮设置为无法点击，非激活状态，工具栏上面仍然可以点*/
gtk_widget_set_sensitive(GTK_WIDGET(menuitem),
FALSE);
/*从主界面获取一个子菜单的方法,获取之后添加一个额外不属于主界面的菜单*/
subMenu = gtk_menu_item_get_submenu(
GTK_MENU_ITEM(gtk_ui_manager_get_widget(ui_manager, "/menubar/Menu2")));
/*可以添加2个额外的分割线*/
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(subMenu), menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(subMenu), menuitem);
menuitem = gtk_menu_item_new_with_label("added out the Ui");
gtk_menu_shell_append(GTK_MENU_SHELL(subMenu), menuitem);
gtk_widget_show_all(GTK_WIDGET(subMenu));//此处如果不写，那么即使后面有window的show_all那也没法显示这个菜单.
/*从主界面获取工具栏的部件*/
toolbar = gtk_ui_manager_get_widget(ui_manager, "/toolbar_navigation");
gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolbar), 0);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
g_object_unref(ui_manager);
/***********使用、设置主界面中的元素$$$$$$******}*/
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void gtkui_create_tab_menu(void)
{
GtkWidget *context;
GtkUIManager *tab_menu_manager;
GtkActionGroup *tabactions;
GError *error = NULL;
static gchar *tab_menu_structure =
"<ui>"
" <popup name='NoteBook'>"
" <menuitem name='DetachPage' action='DetachPageAction' />"
" <menuitem name='ClosePage' action='ClosePageAction' />"
" <separator />"
" <menuitem name='NextPage' action='NextPageAction' />"
" <menuitem name='PreviousPage' action='PreviousPageAction' />"
" </popup>"
"</ui>";
GtkActionEntry tab_menu_items[] = {
{
"DetachPageAction", GTK_STOCK_GO_UP,
"Detach page", "<control>D",
NULL, G_CALLBACK(gtkui_page_detach_current)
},
{
"ClosePageAction", GTK_STOCK_CLOSE,
"Close page", "<control>W",
NULL, G_CALLBACK(gtkui_page_close_current)
},
{
"NextPageAction", GTK_STOCK_GO_FORWARD,
"Next page", "<control>Tab",
NULL, G_CALLBACK(gtkui_page_right)
},
{
"PreviousPageAction", GTK_STOCK_GO_BACK,
"Previous page", "<control><shift>Tab",
NULL, G_CALLBACK(gtkui_page_left)
}
};
/* Create Action Group for tab menu */
tabactions = gtk_action_group_new("TabActions");
gtk_action_group_add_actions(tabactions, tab_menu_items, G_N_ELEMENTS(tab_menu_items), NULL);
/* context menu for notebook */
tab_menu_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(tab_menu_manager, tabactions, 0);
gtk_ui_manager_add_ui_from_string(tab_menu_manager, tab_menu_structure, -1, &error);
if (error) {
g_message("building tab menu failed: %s", error->message);
g_error_free(error);
error = NULL;
}
/* Add Accelerators */
gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(tab_menu_manager));
/* Bind popup menu to event */
context = gtk_ui_manager_get_widget(tab_menu_manager, "/NoteBook");
g_signal_connect(G_OBJECT(notebook), "button-press-event", G_CALLBACK(gtkui_context_menu), context);
}
/**
* nautilus_window_initialize_menus
*
* Create and install the set of menus for this window.
* @window: A recently-created NautilusWindow.
*/
void
nautilus_window_initialize_menus (NautilusWindow *window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAction *action;
gint i;
window->details->ui_manager = gtk_ui_manager_new ();
ui_manager = window->details->ui_manager;
/* shell actions */
action_group = gtk_action_group_new ("ShellActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
window->details->main_action_group = action_group;
gtk_action_group_add_actions (action_group,
main_entries, G_N_ELEMENTS (main_entries),
window);
gtk_action_group_add_toggle_actions (action_group,
main_toggle_entries, G_N_ELEMENTS (main_toggle_entries),
window);
nautilus_window_menus_set_visibility_for_app_menu (window);
g_signal_connect_swapped (gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window))),
"notify::gtk-shell-shows-app-menu",
G_CALLBACK (nautilus_window_menus_set_visibility_for_app_menu), window);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_UP);
g_object_set (action, "short_label", _("_Up"), NULL);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_HOME);
g_object_set (action, "short_label", _("_Home"), NULL);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_SHOW_HIDDEN_FILES);
g_signal_handlers_block_by_func (action, action_show_hidden_files_callback, window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES));
g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window);
g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES,
G_CALLBACK(show_hidden_files_preference_callback),
window);
/* Alt+N for the first 10 tabs */
for (i = 0; i < 10; ++i) {
gchar action_name[80];
gchar accelerator[80];
snprintf(action_name, sizeof (action_name), "Tab%d", i);
action = gtk_action_new (action_name, NULL, NULL, NULL);
g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i));
g_signal_connect (action, "activate",
G_CALLBACK (action_tab_change_action_activate_callback), window);
snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10);
gtk_action_group_add_action_with_accel (action_group, action, accelerator);
g_object_unref (action);
gtk_ui_manager_add_ui (ui_manager,
gtk_ui_manager_new_merge_id (ui_manager),
"/",
action_name,
action_name,
GTK_UI_MANAGER_ACCELERATOR,
FALSE);
}
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
g_object_unref (action_group); /* owned by ui_manager */
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
g_signal_connect (ui_manager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), window);
/* add the UI */
gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/gnome/nautilus/nautilus-shell-ui.xml", NULL);
nautilus_window_initialize_trash_icon_monitor (window);
nautilus_window_initialize_go_menu (window);
}
int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_quit;
GtkWidget *box;
GtkWidget *box_quit;
GtkWidget *quit;
GtkAccelGroup *accel_group = NULL;
gtk_init (&argc, &argv);
/* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!");
/* It's a good idea to do this for all windows. */
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Create a new button */
button = gtk_button_new ();
button_quit = gtk_button_new ();
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
/* Connect the "clicked" signal of the button to our callback */
g_signal_connect (button, "clicked",
G_CALLBACK (main), (gpointer) "Neues Fenster");
g_signal_connect (button_quit, "clicked",
G_CALLBACK (gtk_main_quit), (gpointer) "Neues Fenster");
/* This calls our box creating function */
box = xpm_label_box ("/usr/share/icons/gnome/24x24/actions/filenew.png", "Neues Fenster");
box_quit = xpm_label_box ("/usr/share/icons/gnome/24x24/actions/gtk-quit.png", "Beenden");
/* Pack and show all our widgets */
gtk_widget_show (box);
gtk_widget_show (box_quit);
gtk_container_add (GTK_CONTAINER (button), box);
gtk_container_add (GTK_CONTAINER (button_quit), box_quit);
gtk_widget_show (button);
gtk_widget_show (button_quit);
gtk_container_add (GTK_CONTAINER (window), button);
gtk_widget_show (window);
/* Rest in gtk_main and wait for the fun to begin! */
gtk_main ();
return 0;
}
// setup_editor_window: Sets up the main editor window
// ------------------------------------------------ >>
void setup_editor_window()
{
// Setup OpenGL
glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGB|GDK_GL_MODE_DEPTH|GDK_GL_MODE_DOUBLE));
if (glconfig == NULL)
{
glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGB|GDK_GL_MODE_DEPTH));
if (glconfig == NULL)
exit(1);
}
editor_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(editor_window), "SLADE");
gtk_widget_set_size_request(editor_window, 800, 600);
gtk_widget_set_double_buffered(editor_window, true);
GtkWidget *main_vbox = gtk_vbox_new(false, 0);
gtk_container_add(GTK_CONTAINER(editor_window), main_vbox);
// Menu and Toolbar
GtkUIManager *ui = gtk_ui_manager_new();
GtkActionGroup *actions = gtk_action_group_new ("Actions");
GError *error = NULL;
gtk_action_group_add_actions(actions, entries, n_entries, NULL);
//gtk_action_group_add_radio_actions(actions, mode_entries, n_mode_entries, 1, G_CALLBACK(menu_mode_select), NULL);
gtk_ui_manager_insert_action_group(ui, actions, 0);
gtk_window_add_accel_group(GTK_WINDOW(editor_window), gtk_ui_manager_get_accel_group(ui));
if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
{
printf("Building menus failed: %s", error->message);
g_error_free(error);
}
gtk_box_pack_start (GTK_BOX(main_vbox), gtk_ui_manager_get_widget(ui, "/MenuBar"), false, false, 0);
GtkWidget *toolbar = gtk_ui_manager_get_widget(ui, "/ToolBar");
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU);
gtk_container_unset_focus_chain(GTK_CONTAINER(toolbar));
GTK_WIDGET_UNSET_FLAGS(toolbar, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS(toolbar, GTK_HAS_FOCUS);
g_signal_connect(G_OBJECT(toolbar), "key-press-event", G_CALLBACK(tbar_keypress), NULL);
gtk_box_pack_start (GTK_BOX(main_vbox), toolbar, false, false, 0);
// Map area
map_area = gtk_drawing_area_new();
gtk_widget_set_gl_capability(map_area, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE);
gtk_widget_set_events(map_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
g_signal_connect(G_OBJECT(map_area), "expose-event", G_CALLBACK(expose_event), NULL);
g_signal_connect(G_OBJECT(map_area), "configure-event", G_CALLBACK(configure_event), NULL);
g_signal_connect(G_OBJECT(map_area), "motion_notify_event", G_CALLBACK(motion_notify_event), NULL);
g_signal_connect(G_OBJECT(map_area), "button_press_event", G_CALLBACK(button_press_event), NULL);
g_signal_connect(G_OBJECT(map_area), "button_release_event", G_CALLBACK(button_release_event), NULL);
g_signal_connect(G_OBJECT(editor_window), "key-press-event", G_CALLBACK(key_press_event), NULL);
g_signal_connect(G_OBJECT(editor_window), "key-release-event", G_CALLBACK(key_release_event), NULL);
g_signal_connect_after(G_OBJECT(map_area), "realize", G_CALLBACK (realize_main), NULL);
g_signal_connect(G_OBJECT(editor_window), "delete_event", G_CALLBACK(destroy), NULL);
g_signal_connect(G_OBJECT(editor_window), "window-state-event", G_CALLBACK(editor_state_event), NULL);
g_signal_connect(G_OBJECT(map_area), "scroll-event", G_CALLBACK(editor_scroll_event), NULL);
gtk_box_pack_start(GTK_BOX(main_vbox), map_area, true, true, 0);
GTK_WIDGET_SET_FLAGS(map_area, GTK_CAN_FOCUS);
// Setup widgets that need to share the context
gtk_widget_realize(map_area);
glcontext = gtk_widget_get_gl_context(map_area);
// Info area
GtkWidget *infobar = get_info_bar();
gtk_widget_set_size_request(infobar, -1, 144);
gtk_box_pack_start(GTK_BOX(main_vbox), infobar, false, false, 0);
change_infobar_page();
if (ew_fullscreen)
gtk_window_maximize(GTK_WINDOW(editor_window));
else
{
gtk_window_move(GTK_WINDOW(editor_window), ew_x, ew_y);
gtk_window_resize(GTK_WINDOW(editor_window), ew_width, ew_height);
}
// Status bar
//GtkWidget *frame = gtk_frame_new(NULL);
//gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW);
gtk_box_pack_start(GTK_BOX(main_vbox), setup_status_bar(), false, false, 0);
//gtk_container_add(GTK_CONTAINER(frame), setup_status_bar());
gtk_widget_show_all(editor_window);
}
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 ();
}
/*!
* \brief GUI thread only create a plot surface and periodically call a
* gui_handler that redraws the plot after a short timeout
*/
static gpointer
gui_thread (gpointer data)
{
GtkWidget *window;
GtkWidget *drawing_area;
/* Create the Widgets */
GtkWidget *vbox, *menubar, *filemenu,*editmenu,*viewmenu,*helpmenu,
*file, *edit, *view, *help,*pref_1,*toolbar,*help_Dialog,*about_Dialog,
*new,*sep1,*sep2, *open,*save,*dialog, *save_as,*export,*export_diag, *quit, *sep, *tog_stat,*statusbar, *tog_tool;
gdk_threads_enter();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* Some nesseary inits */
GtkAccelGroup *accel_group = NULL;
GtkToolItem *test_item;
GtkToolItem *item_1;
GtkToolItem *item_2;
GtkToolItem *item_3;
GtkToolItem *item_4;
/* Set the window title */
gtk_window_set_title(GTK_WINDOW(window), "eStick Control Center V0.0-ecc");
/* Add Window Icon max size 128x128 Pixel current 64x64 used */
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("window_symbol.png"));
/* Default Window size at startup */
gtk_window_set_default_size (GTK_WINDOW(window), xsize+xoff, ysize+yoff);
/* Set Border With of the window in Pixels */
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
/* Create a new Vertical Box, FALSE= WIdgets have not equal space, 0 pixels between widgets */
vbox = gtk_vbox_new(FALSE, 0);
/* Add the Vertical Box to the main window */
gtk_container_add(GTK_CONTAINER(window), vbox);
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, xsize, ysize);
/* Create the Menu Bar */
menubar = gtk_menu_bar_new();
/* Create the Toolbar Bar */
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
/* Create a new Statusbar*/
statusbar = gtk_statusbar_new();
/* Create the Handlers for the submenus*/
filemenu = gtk_menu_new();
editmenu = gtk_menu_new();
viewmenu = gtk_menu_new();
helpmenu = gtk_menu_new();
/* Create new accelerator Group */
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
/* Create the File Drop Down Point in the menu bar with mnemonic character */
file = gtk_menu_item_new_with_mnemonic("_File");
/* Create the Edit Drop Down Point in the menu bar with mnemonic character */
edit = gtk_menu_item_new_with_mnemonic("_Edit");
/* Create the View Drop Down Point in the menu bar with mnemonic character */
view = gtk_menu_item_new_with_mnemonic("_View");
/* Create the Help Drop Down Point in the menu bar with mnemonic character */
help = gtk_menu_item_new_with_mnemonic("_Help");
/* ############################# Items for the Menu Bar################## */
/* Use the open point from the libary and the stock symbol */
open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
g_signal_connect(G_OBJECT(open), "activate",G_CALLBACK(file_open),file_open);
/*Connect signal to display the Message for the Save Menu Item in the statusbar, when the mouse cursors hovers over*/
g_signal_connect (G_OBJECT (open), "enter-notify-event",G_CALLBACK (statusbar_hint), statusbar);
/*Remove Message from the statusbar when the mouse cursors leaves this menu point*/
g_signal_connect (G_OBJECT (open), "leave-notify-event",G_CALLBACK (statusbar_hint), statusbar);
/*Attach the text for the statusbar to the Menu Item*/
g_object_set_data (G_OBJECT (open), "menuhint",(gpointer) "Open a recorded File");
/* Create vertical seperator line in the file menu */
sep1 = gtk_separator_menu_item_new();
/* Use the save point from the libary and the stock symbol */
save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, NULL);
g_signal_connect(G_OBJECT(save), "activate",G_CALLBACK(file_save),(gpointer) window);
/*Connect signal to display the Message for the Save Menu Item in the statusbar, when the mouse cursors hovers over*/
g_signal_connect (G_OBJECT (save), "enter-notify-event",G_CALLBACK (statusbar_hint), statusbar);
/*Remove Message from the statusbar when the mouse cursors leaves this menu point*/
g_signal_connect (G_OBJECT (save), "leave-notify-event",G_CALLBACK (statusbar_hint), statusbar);
/*Attach the text for the statusbar to the Menu Item*/
g_object_set_data (G_OBJECT (save), "menuhint",(gpointer) "Save to specified File");
/* Use the save_as point from the libary and the stock symbol */
save_as = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS, NULL);
g_signal_connect(G_OBJECT(save_as), "activate",G_CALLBACK(file_save_as),(gpointer) window);
/*Connect signal to display the Message for the Save_as Menu Item in the statusbar, when the mouse cursors hovers over*/
g_signal_connect (G_OBJECT (save_as), "enter-notify-event",G_CALLBACK (statusbar_hint), statusbar);
/*Remove Message from the statusbar when the mouse cursors leaves this menu point*/
g_signal_connect (G_OBJECT (save_as), "leave-notify-event",G_CALLBACK (statusbar_hint), statusbar);
/*Attach the text for the statusbar to the Menu Item*/
g_object_set_data (G_OBJECT (save_as), "menuhint",(gpointer) "Save to a new File");
/* Create vertical seperator line in the file menu */
sep2 = gtk_separator_menu_item_new();
/* For the export function, no stock symbol exists, used instead a point with only a label*/
export = gtk_menu_item_new_with_label("Export");
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;
}
int main(int argc, char *argv[])
{
GtkWidget *win = NULL; /* The main window */
GtkWidget *vbox = NULL; /* Packing box for the menu and toolbars */
GtkWidget *menubar = NULL; /* The actual menubar */
GtkWidget *toolbar = NULL; /* The actual toolbar */
GtkActionGroup *action_group = NULL; /* Packing group for our Actions */
GtkUIManager *menu_manager = NULL; /* The magic widget! */
GError *error = NULL; /* For reporting exceptions or errors */
/* Initialize translation text domain */
bindtextdomain(g_config.package_name, g_config.locale_dir);
bind_textdomain_codeset(g_config.package_name, "UTF-8");
textdomain(g_config.package_name);
/* Initialize GTK+ */
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init(&argc, &argv);
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
/* Create the main window */
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win), _("Hello World"));
gtk_window_set_default_size(GTK_WINDOW(win), 400, 300);
gtk_widget_realize(win);
/* Create a vertical box to hold menubar and toolbar */
vbox = gtk_vbox_new(FALSE, 0);
/* Create menus */
action_group = gtk_action_group_new("TestActions");
gtk_action_group_set_translation_domain(action_group, g_config.package_name);
menu_manager = gtk_ui_manager_new();
/* Read in the UI from our XML file */
error = NULL;
gtk_ui_manager_add_ui_from_file(menu_manager, "hello.xml", &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
error = NULL;
}
/* Create a list of entries which are passed to the Action constructor.
* This is a huge convenience over building Actions by hand.
*/
const GtkActionEntry entries[] = {
/**********************************/
{ "FileMenuAction", NULL,
_("_File"), NULL,
_("File operations"),
NULL
},
/**********************************/
{ "SendAction", GTK_STOCK_EXECUTE,
_("_Send"), "<Ctrl>S",
_("Send hello world to console"),
G_CALLBACK(SendHelloWorld)
},
/**********************************/
{ "QuitAction", GTK_STOCK_QUIT,
_("_Quit"), "<Ctrl>Q",
_("Quit"),
G_CALLBACK(gtk_main_quit)
},
/**********************************/
};
/* Pack up our objects:
* vbox -> win
* actions -> action_group
* action_group -> menu_manager
*/
gtk_container_add(GTK_CONTAINER(win), vbox);
gtk_action_group_add_actions(action_group, entries, G_N_ELEMENTS(entries), NULL);
gtk_ui_manager_insert_action_group(menu_manager, action_group, 0);
/* Get the menubar and the toolbar and put them in the vertical packing box */
menubar = gtk_ui_manager_get_widget(menu_manager, "/MainMenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
toolbar = gtk_ui_manager_get_widget(menu_manager, "/MainToolbar");
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* Connect signals */
g_signal_connect(win, "destroy", gtk_main_quit, NULL);
/* Make sure that the accelerators work */
gtk_window_add_accel_group(GTK_WINDOW(win),
gtk_ui_manager_get_accel_group(menu_manager));
/* Enter the main loop */
gtk_widget_show_all(win);
gtk_main();
return (0);
}
/**
* @param ddisp The diagram display object that a window is created for
* @param width Diagram widgth
* @param height Diagram Height
* @param title Window title
* @param use_mbar Flag to indicate whether to add a menubar to the window
*/
void
create_display_shell(DDisplay *ddisp,
int width, int height,
char *title, int use_mbar)
{
GtkWidget *table, *widget;
GtkWidget *status_hbox;
GtkWidget *root_vbox = NULL;
GtkWidget *zoom_hbox, *zoom_label;
int s_width, s_height;
if (app_is_interactive() && is_integrated_ui())
{
use_integrated_ui_for_display_shell(ddisp, title);
return;
}
ddisp->is_standalone_window = TRUE;
ddisp->container = NULL;
s_width = gdk_screen_width ();
s_height = gdk_screen_height ();
if (width > s_width)
width = s_width;
if (height > s_height)
height = s_height;
/* The toplevel shell */
ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (ddisp->shell), title);
gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window");
gtk_window_set_icon_name (GTK_WINDOW (ddisp->shell), "dia");
gtk_window_set_default_size(GTK_WINDOW (ddisp->shell), width, height);
/* set_icon_name needs registered theme icons, not always available: provide fallback */
if (!gtk_window_get_icon (GTK_WINDOW (ddisp->shell))) {
static GdkPixbuf *pixbuf = NULL;
if (!pixbuf)
pixbuf = gdk_pixbuf_new_from_inline(-1, dia_diagram_icon, FALSE, NULL);
if (pixbuf)
gtk_window_set_icon (GTK_WINDOW (ddisp->shell), pixbuf);
}
g_object_set_data (G_OBJECT (ddisp->shell), "user_data", (gpointer) ddisp);
_ddisplay_setup_events (ddisp, ddisp->shell);
/* following two not shared with integrated UI */
g_signal_connect (G_OBJECT (ddisp->shell), "delete_event",
G_CALLBACK (ddisplay_delete), ddisp);
g_signal_connect (G_OBJECT (ddisp->shell), "destroy",
G_CALLBACK (ddisplay_destroy), ddisp);
/* the table containing all widgets */
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
if (use_mbar)
{
root_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox);
gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0);
}
else
{
gtk_container_add (GTK_CONTAINER (ddisp->shell), table);
}
/* scrollbars, rulers, canvas, menu popup button */
if (!use_mbar) {
ddisp->origin = gtk_button_new();
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus (ddisp->origin, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS);
#endif
widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(ddisp->origin), widget);
gtk_widget_set_tooltip_text(widget, _("Diagram menu."));
gtk_widget_show(widget);
g_signal_connect(G_OBJECT(ddisp->origin), "button_press_event",
G_CALLBACK(origin_button_press), ddisp);
}
else {
ddisp->origin = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
}
_ddisplay_setup_rulers (ddisp, ddisp->shell, table);
_ddisplay_setup_scrollbars (ddisp, table, width, height);
_ddisplay_setup_navigation (ddisp, table, FALSE);
ddisp->canvas = create_canvas (ddisp);
/* pack all remaining widgets */
gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
/* TODO rob use per window accel */
ddisp->accel_group = menus_get_display_accels ();
gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group);
if (use_mbar) {
ddisp->menu_bar = menus_create_display_menubar (&ddisp->ui_manager, &ddisp->actions);
g_assert (ddisp->menu_bar);
gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0);
}
/* the statusbars */
status_hbox = gtk_hbox_new (FALSE, 2);
/* Zoom status pseudo-optionmenu */
ddisp->zoom_status = create_zoom_widget(ddisp);
zoom_hbox = gtk_hbox_new(FALSE, 0);
zoom_label = gtk_label_new(_("Zoom"));
gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0);
/* Grid on/off button */
ddisp->grid_status = dia_toggle_button_new_with_icons(dia_on_grid_icon,
dia_off_grid_icon);
g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled",
G_CALLBACK (grid_toggle_snap), ddisp);
gtk_widget_set_tooltip_text(ddisp->grid_status,
_("Toggles snap-to-grid for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status,
FALSE, FALSE, 0);
ddisp->mainpoint_status = dia_toggle_button_new_with_icons(dia_mainpoints_on_icon,
dia_mainpoints_off_icon);
g_signal_connect(G_OBJECT(ddisp->mainpoint_status), "toggled",
G_CALLBACK (interface_toggle_mainpoint_magnetism), ddisp);
gtk_widget_set_tooltip_text(ddisp->mainpoint_status,
_("Toggles object snapping for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->mainpoint_status,
FALSE, FALSE, 0);
/* Statusbar */
ddisp->modified_status = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status,
TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
display_rulers_show (ddisp);
gtk_widget_show (ddisp->zoom_status);
gtk_widget_show (zoom_hbox);
gtk_widget_show (zoom_label);
gtk_widget_show (ddisp->grid_status);
gtk_widget_show (ddisp->mainpoint_status);
gtk_widget_show (ddisp->modified_status);
gtk_widget_show (status_hbox);
gtk_widget_show (table);
if (use_mbar)
{
gtk_widget_show (ddisp->menu_bar);
gtk_widget_show (root_vbox);
}
gtk_widget_show (ddisp->shell);
/* before showing up, checking canvas's REAL size */
if (use_mbar && ddisp->hrule->allocation.width > width)
{
/* The menubar is not shrinkable, so the shell will have at least
* the menubar's width. If the diagram's requested width is smaller,
* the canvas will be enlarged to fit the place. In this case, we
* need to adjust the horizontal scrollbar according to the size
* that will be allocated, which the same as the hrule got.
*/
width = ddisp->hrule->allocation.width;
gtk_adjustment_set_upper (ddisp->hsbdata, width);
gtk_adjustment_set_page_increment (ddisp->hsbdata, (width - 1) / 4);
gtk_adjustment_set_page_size (ddisp->hsbdata, width - 1);
gtk_adjustment_changed (GTK_ADJUSTMENT(ddisp->hsbdata));
}
gtk_widget_show (ddisp->canvas);
/* set the focus to the canvas area */
gtk_widget_grab_focus (ddisp->canvas);
}
void
create_display_shell(DDisplay *ddisp,
int width, int height,
char *title)
{
GtkWidget *table;
GtkWidget *status_hbox;
int s_width, s_height;
s_width = gdk_screen_width ();
s_height = gdk_screen_height ();
if (width > s_width)
width = s_width;
if (height > s_height)
width = s_width;
/* The adjustment datums */
ddisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, 1, width-1));
ddisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, 1, height-1));
/* The toplevel shell */
ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (ddisp->shell), title);
gtk_window_set_wmclass (GTK_WINDOW (ddisp->shell), "diagram_window",
"Dia");
gtk_window_set_policy (GTK_WINDOW (ddisp->shell), TRUE, TRUE, TRUE);
gtk_object_set_user_data (GTK_OBJECT (ddisp->shell), (gpointer) ddisp);
gtk_widget_set_events (ddisp->shell,
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_FOCUS_CHANGE_MASK);
/* GDK_ALL_EVENTS_MASK */
gtk_signal_connect (GTK_OBJECT (ddisp->shell), "delete_event",
GTK_SIGNAL_FUNC (ddisplay_delete),
ddisp);
gtk_signal_connect (GTK_OBJECT (ddisp->shell), "destroy",
GTK_SIGNAL_FUNC (ddisplay_destroy),
ddisp);
/* the table containing all widgets */
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_container_add (GTK_CONTAINER (ddisp->shell), table);
/* scrollbars, rulers, canvas, menu popup button */
ddisp->origin = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
ddisp->hrule = gtk_hruler_new ();
gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event",
(GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ddisp->hrule)->klass)->motion_notify_event,
GTK_OBJECT (ddisp->hrule));
ddisp->vrule = gtk_vruler_new ();
gtk_signal_connect_object (GTK_OBJECT (ddisp->shell), "motion_notify_event",
(GtkSignalFunc) GTK_WIDGET_CLASS (GTK_OBJECT (ddisp->vrule)->klass)->motion_notify_event,
GTK_OBJECT (ddisp->vrule));
ddisp->hsb = gtk_hscrollbar_new (ddisp->hsbdata);
GTK_WIDGET_UNSET_FLAGS (ddisp->hsb, GTK_CAN_FOCUS);
ddisp->vsb = gtk_vscrollbar_new (ddisp->vsbdata);
GTK_WIDGET_UNSET_FLAGS (ddisp->vsb, GTK_CAN_FOCUS);
/* set up the scrollbar observers */
gtk_signal_connect (GTK_OBJECT (ddisp->hsbdata), "value_changed",
(GtkSignalFunc) ddisplay_hsb_update,
ddisp);
gtk_signal_connect (GTK_OBJECT (ddisp->vsbdata), "value_changed",
(GtkSignalFunc) ddisplay_vsb_update,
ddisp);
ddisp->canvas = gtk_drawing_area_new ();
gtk_drawing_area_size (GTK_DRAWING_AREA (ddisp->canvas), width, height);
gtk_widget_set_events (ddisp->canvas, CANVAS_EVENT_MASK);
GTK_WIDGET_SET_FLAGS (ddisp->canvas, GTK_CAN_FOCUS);
gtk_signal_connect (GTK_OBJECT (ddisp->canvas), "event",
(GtkSignalFunc) ddisplay_canvas_events,
ddisp);
gtk_object_set_user_data (GTK_OBJECT (ddisp->canvas), (gpointer) ddisp);
/* pack all the widgets */
gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->hrule, 1, 2, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->vrule, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->hsb, 0, 2, 2, 3,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->vsb, 2, 3, 0, 2,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
/* the popup menu */
#ifdef GNOME
ddisp->popup = gnome_display_menus_create ();
ddisp->accel_group = gnome_popup_menu_get_accel_group(GTK_MENU(ddisp->popup));
#else
menus_get_image_menu (&ddisp->popup, &ddisp->accel_group);
#endif
/* the accelerator table/group for the popup */
gtk_window_add_accel_group (GTK_WINDOW(ddisp->shell), ddisp->accel_group);
/* the statusbars */
status_hbox = gtk_hbox_new (FALSE, 2);
ddisp->zoom_status = gtk_statusbar_new ();
ddisp->modified_status = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->zoom_status,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status,
TRUE, TRUE,
0);
gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ddisp->hsb);
gtk_widget_show (ddisp->vsb);
gtk_widget_show (ddisp->origin);
gtk_widget_show (ddisp->hrule);
gtk_widget_show (ddisp->vrule);
gtk_widget_show (ddisp->canvas);
gtk_widget_show (ddisp->zoom_status);
gtk_widget_show (ddisp->modified_status);
gtk_widget_show (status_hbox);
gtk_widget_show (table);
gtk_widget_show (ddisp->shell);
/* set the focus to the canvas area */
gtk_widget_grab_focus (ddisp->canvas);
}
/**
* Create integrated user interface
*/
void
create_integrated_ui (void)
{
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *wrapbox;
GtkWidget *menubar;
GtkWidget *toolbar;
GtkWidget *notebook;
GtkWidget *statusbar;
GtkAccelGroup *accel_group;
GtkWidget *layer_view;
#ifdef HAVE_GNOME
window = gnome_app_new ("Dia", _("Diagram Editor"));
#else
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_object_ref (window);
gtk_window_set_title (GTK_WINDOW (window), "Dia v" VERSION);
#endif
/* hint to window manager on X so the wm can put the window in the same
as it was when the application shut down */
gtk_window_set_role (GTK_WINDOW (window), DIA_MAIN_WINDOW);
gtk_window_set_default_size (GTK_WINDOW (window), 146, 349);
app_set_icon (GTK_WINDOW (window));
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (toolbox_delete),
window);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (toolbox_destroy),
window);
main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1);
#ifdef HAVE_GNOME
gnome_app_set_contents (GNOME_APP(window), main_vbox);
#else
gtk_container_add (GTK_CONTAINER (window), main_vbox);
#endif
gtk_widget_show (main_vbox);
/* Applicatioon Statusbar */
statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (main_vbox), statusbar, FALSE, TRUE, 0);
/* HBox for everything below the menubar and toolbars */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
/* Layer View */
layer_view = create_layer_view_widget ();
gtk_box_pack_end (GTK_BOX (hbox), layer_view, FALSE, FALSE, 0);
/* Diagram Notebook */
notebook = gtk_notebook_new ();
gtk_box_pack_end (GTK_BOX (hbox), notebook, TRUE, TRUE, 0);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_widget_show (notebook);
/* Toolbox widget */
wrapbox = toolbox_create();
gtk_box_pack_start (GTK_BOX (hbox), wrapbox, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (wrapbox), "drag_data_received",
G_CALLBACK (dia_dnd_file_drag_data_received),
NULL); /* userdata == NULL here intentionally */
/* setup the notebook to receive drops as well */
toolbox_setup_drag_dest (notebook);
g_signal_connect (G_OBJECT (notebook), "drag_data_received",
G_CALLBACK (dia_dnd_file_drag_data_received),
NULL); /* userdata == NULL here intentionally */
/* menus -- initialised afterwards, because initing the display menus
* uses the tool buttons*/
menus_get_integrated_ui_menubar(&menubar, &toolbar, &accel_group);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_widget_show (menubar);
#ifdef HAVE_GNOME
gnome_app_set_menus (GNOME_APP (window), GTK_MENU_BAR (menubar));
#else
# ifdef HAVE_MAC_INTEGRATION
_create_mac_integration (menubar);
# else
gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0);
# endif
#endif
/* Toolbar */
/* TODO: maybe delete set_style(toolbar,ICONS) */
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, TRUE, 0);
gtk_widget_show (toolbar);
persistence_register_window(GTK_WINDOW(window));
ui.main_window = GTK_WINDOW (window);
ui.toolbar = GTK_TOOLBAR (toolbar);
ui.diagram_notebook = GTK_NOTEBOOK (notebook);
ui.statusbar = GTK_STATUSBAR (statusbar);
ui.layer_view = layer_view;
/* NOTE: These functions use ui.xxx assignments above and so must come after
* the user interface components are set. */
integrated_ui_toolbar_show (TRUE);
integrated_ui_statusbar_show (TRUE);
/* For access outside here: */
g_object_set_data (G_OBJECT (ui.main_window), DIA_MAIN_NOTEBOOK, notebook);
/* TODO: Figure out what to do about toolbox_shell for integrated UI */
toolbox_shell = window;
}
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) ;
}
GtkWidget *menubar_new (GtkWidget *Window)
{
GtkWidget *Menu;
GtkItemFactory *ItemFactory;
GtkAccelGroup *AccelGroup;
gchar *AccelRC;
guint NbMenuEntries = sizeof (MenuEntries) / sizeof (MenuEntries[0]);
MsgBarToggleDisplay = FALSE;
ToolBarToggleDisplay = FALSE;
ToggleWordwrap = FALSE;
AccelGroup = gtk_accel_group_new();
ItemFactory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", AccelGroup);
gtk_item_factory_create_items (ItemFactory, NbMenuEntries,
MenuEntries, NULL);
gtk_window_add_accel_group (GTK_WINDOW (Window), AccelGroup);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/File")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/File/Recent Files")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Edit")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Tools")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Tools/Conversions")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings/Doc Tabs")), Menu);
if (MSGBAR_DISPLAY)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Msg Bar")),
TRUE);
if (TOOLBAR_DISPLAY)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Tool Bar")),
TRUE);
if (TOGGLE_WORDWRAP)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Wordwrap")),
TRUE);
if (TAB_POSITION == 1)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Top")),
TRUE);
if (TAB_POSITION == 2)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Bottom")),
TRUE);
if (TAB_POSITION == 3)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Left")),
TRUE);
if (TAB_POSITION == 4)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Doc Tabs/Right")),
TRUE);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Settings/Scroll Bar")),
Menu);
if (SCROLLBAR_POSITION == 1)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Scroll Bar/Left")),
TRUE);
if (SCROLLBAR_POSITION == 2)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM
(gtk_item_factory_get_widget
(ItemFactory,
"<main>/Settings/Scroll Bar/Right")),
TRUE);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Languages")), Menu);
Menu = gtk_tearoff_menu_item_new ();
gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget
(ItemFactory, "<main>/Help")), Menu);
Menu = gtk_item_factory_get_widget (ItemFactory, "<main>");
AccelRC = g_strconcat (g_get_home_dir (), PATH_SEP_STRING, CONF_DIR,
PATH_SEP_STRING, "AccelRC", NULL);
gtk_item_factory_parse_rc (AccelRC);
g_free (AccelRC);
init_recent_files ();
init_languages_menu ();
gtk_menu_bar_set_shadow_type (GTK_MENU_BAR(Menu), GTK_SHADOW_NONE);
return (Menu);
}