gtk_gui::gtk_gui(const char* title, const char* initfile)
:
m_programfilename(NULL),
m_smilfilename(NULL),
m_settings(NULL),
m_toplevelcontainer(NULL),
m_guicontainer(NULL),
m_documentcontainer(NULL),
#if GTK_MAJOR_VERSION >= 3
m_play(NULL),
m_pause(NULL),
m_stop(NULL),
m_reload(NULL),
#else // GTK_MAJOR_VERSION < 3
menubar(NULL),
m_actions(NULL),
#endif // GTK_MAJOR_VERSION < 3
#ifdef LOCK_MESSAGE
m_gui_thread(0),
#endif/*LOCK_MESSAGE*/
m_file_chooser(NULL),
m_settings_chooser(NULL),
m_url_text_entry(NULL),
m_mainloop(NULL)
{
GError *error = NULL;
// Initialization of the Menu Bar Items
// There is a problem in here because the callbacks in Actions go like g_signal_connect (but, we need g_sginal_connect_swapped)
#if GTK_MAJOR_VERSION >= 3
#else // GTK_MAJOR_VERSION < 3
static GtkActionEntry entries[] = {
{ "FileMenu", NULL, gettext_noop("_File")},
{ "open", GTK_STOCK_OPEN, gettext_noop("_Open..."),
"<Control>O", gettext_noop("Open a document from local disk"), NULL},
{ "openurl", NULL, gettext_noop("Open _URL..."),
"<Control>L", gettext_noop("Open a document from the network"), NULL},
{ "reload", GTK_STOCK_REFRESH, gettext_noop("_Reload"),
NULL, gettext_noop("Reload current document"), NULL},
{ "preferences", GTK_STOCK_PREFERENCES , gettext_noop("_Preferences"),
NULL, gettext_noop("Change application preferences"), NULL},
{ "loadsettings", GTK_STOCK_PROPERTIES, gettext_noop("_Load Settings..."),
NULL, gettext_noop("Open SMIL playback settings document"), NULL},
{ "quit", GTK_STOCK_QUIT, gettext_noop("_Quit"),
"<Control>Q", gettext_noop("Quit Ambulant Player"), NULL},
// Play Menu
{ "PlayMenu", NULL, gettext_noop("Pla_y")},
{ "play", GTK_STOCK_MEDIA_PLAY, gettext_noop("Pla_y"),
"<Control>P", gettext_noop("Start document playback"), NULL},
{ "pause", GTK_STOCK_MEDIA_PAUSE, gettext_noop("_Pause"),
"<Control><Shift>P", gettext_noop("Pause document playback"), NULL},
{ "stop", GTK_STOCK_MEDIA_STOP, gettext_noop("_Stop"),
"<Control>S", gettext_noop("Stop document playback"), NULL},
// View Menu
{ "ViewMenu", NULL, gettext_noop("_View")},
{ "fullscreen", NULL, gettext_noop("_Full Screen"),
"<Control>F", gettext_noop("Full Screen"), NULL},
{ "window", NULL, gettext_noop("_Window"),
"<Control><Alt>F", gettext_noop("Normal Screen"), NULL},
{ "logwindow", NULL, gettext_noop("_Log Window..."),
"<Control>L", gettext_noop("Show status output window"), NULL},
// Help Menu
{ "HelpMenu", NULL, gettext_noop("_Help")},
{ "about", GTK_STOCK_ABOUT, gettext_noop("_About AmbulantPlayer"),
NULL, gettext_noop("Information about Ambulant"), NULL},
{ "help", GTK_STOCK_HELP, gettext_noop("AmbulantPlayer _Help..."),
NULL, gettext_noop("Help in AmbulantPlayer Webpage"), NULL},
{ "website", NULL, gettext_noop("AmbulantPlayer _Website..."),
NULL, gettext_noop("Open the Ambulant Webpage"), NULL},
{ "welcome", GTK_STOCK_HOME, gettext_noop("_Play Welcome Document"),
"<Control><shift>H", gettext_noop("Plays a simple SMIL file"), NULL}
};
int n_entries = G_N_ELEMENTS(entries);
#endif // GTK_MAJOR_VERSION < 3
m_programfilename = title;
#ifdef LOCK_MESSAGE
pthread_cond_init(&m_cond_message, NULL);
pthread_mutex_init(&m_lock_message, NULL);
m_gui_thread = pthread_self();
#endif/*LOCK_MESSAGE*/
// If the URL starts with "ambulant:" this is the trick-uri-scheme to
// open URLs in Ambulant from the browser. Remove the trick.
if (strncmp(initfile, "ambulant:", 9) == 0)
initfile += 9;
if (initfile != NULL && initfile != "")
m_smilfilename = strdup(initfile);
/*Initialization of the Main Window */
#if GTK_MAJOR_VERSION >= 3
#else // GTK_MAJOR_VERSION < 3
m_toplevelcontainer = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
gtk_window_set_title(m_toplevelcontainer, initfile);
gtk_window_set_resizable(m_toplevelcontainer, true);
// gtk_widget_set_size_request(GTK_WIDGET (m_toplevelcontainer), 200, 150);
// gtk_widget_set_uposition(GTK_WIDGET (m_toplevelcontainer), 240, 320); deprecated
gtk_window_set_position(GTK_WINDOW (m_toplevelcontainer), GTK_WIN_POS_MOUSE);
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "delete-event", G_CALLBACK (gtk_C_callback_quit), (void *) this);
// Callback for the resize events
// g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "draw", G_CALLBACK (gtk_C_callback_resize), (void *) this);
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "expose-event", G_CALLBACK (gtk_C_callback_resize), (void *) this);
#endif // GTK_MAJOR_VERSION < 3
/* Initialization of the signals */
#if GTK_MAJOR_VERSION >= 3
signal_player_done_id = g_signal_new ("signal-player-done", gtk_window_get_type(), G_SIGNAL_RUN_LAST, 0, 0, 0, 0, G_TYPE_NONE, 0, NULL);
signal_need_redraw_id = g_signal_new ("signal-need-redraw", gtk_window_get_type(), G_SIGNAL_RUN_LAST, 0, 0, 0, 0, G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
signal_internal_message_id = g_signal_new ("signal-internal-message", gtk_window_get_type(), G_SIGNAL_RUN_LAST, 0, 0, 0, 0, G_TYPE_NONE, 1, G_TYPE_POINTER);
#else // GTK_MAJOR_VERSION < 3
signal_player_done_id = g_signal_new ("signal-player-done", gtk_window_get_type(), G_SIGNAL_RUN_LAST, 0, 0, 0, g_cclosure_marshal_VOID__VOID,GTK_TYPE_NONE, 0, NULL);
signal_need_redraw_id = g_signal_new ("signal-need-redraw", gtk_window_get_type(), G_SIGNAL_RUN_LAST, 0, 0, 0, gtk_marshal_NONE__POINTER_POINTER_POINTER,GTK_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
signal_internal_message_id = g_signal_new ("signal-internal-message", gtk_window_get_type(), G_SIGNAL_RUN_LAST, 0, 0, 0, 0, G_TYPE_NONE, 1, G_TYPE_POINTER);
// Signal connections
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "signal-player-done", G_CALLBACK (gtk_C_callback_do_player_done), (void*)this);
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "signal-need-redraw", G_CALLBACK (gtk_C_callback_do_player_done), (void*)this);
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "signal-internal-message", G_CALLBACK (gtk_C_callback_do_internal_message), (void*)this);
/* VBox (m_guicontainer) to place the Menu bar in the correct place */
m_guicontainer = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(m_toplevelcontainer), GTK_WIDGET (m_guicontainer));
#endif // GTK_MAJOR_VERSION < 3
#if GTK_MAJOR_VERSION >= 3
GtkBuilder* builder = gtk_builder_new ();
// The layout of the GUI is made using 'glade'
gtk_builder_add_from_file (builder, AMBULANT_DATADIR "/ambulant-gtk_gui.xml", NULL);
m_toplevelcontainer = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
gtk_builder_connect_signals (builder, NULL);
// The remove window button
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "delete-event", G_CALLBACK (gtk_C_callback_quit), (void *) this);
// The actual activation calls for selected menu items, as found by name in the processed .xml file
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "open_menu_item")), "activate", G_CALLBACK (gtk_C_callback_open), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "url_menu_item")), "activate", G_CALLBACK (gtk_C_callback_open_url), (void *) this );
g_signal_connect_swapped ((GObject*)(m_reload = gtk_builder_find_menu_item(builder, "reload_menu_item")), "activate", G_CALLBACK (gtk_C_callback_reload), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "preferences_menu_item")), "activate", G_CALLBACK (gtk_C_callback_settings_select), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "settings_menu_item")), "activate", G_CALLBACK (gtk_C_callback_load_settings), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "quit_menu_item")), "activate", G_CALLBACK (gtk_C_callback_quit), (void *) this );
g_signal_connect_swapped ((GObject*)(m_play = gtk_builder_find_menu_item(builder, "play_menu_item")), "activate", G_CALLBACK (gtk_C_callback_play), (void *) this );
g_signal_connect_swapped ((GObject*)(m_pause = gtk_builder_find_menu_item(builder, "pause_menu_item")), "activate", G_CALLBACK (gtk_C_callback_pause), (void *) this );
g_signal_connect_swapped ((GObject*)(m_stop = gtk_builder_find_menu_item(builder, "stop_menu_item")), "activate", G_CALLBACK (gtk_C_callback_stop), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "fullscreen_menu_item")), "activate", G_CALLBACK (gtk_C_callback_full_screen), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "normalscreen_menu_item")), "activate", G_CALLBACK (gtk_C_callback_normal_screen), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "logger_window_menu_item")), "activate", G_CALLBACK (gtk_C_callback_logger_window), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "about_menu_item")), "activate", G_CALLBACK (gtk_C_callback_about), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "help_menu_item")), "activate", G_CALLBACK (gtk_C_callback_help), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "homepage_menu_item")), "activate", G_CALLBACK (gtk_C_callback_homepage), (void *) this );
g_signal_connect_swapped (G_OBJECT (gtk_builder_find_menu_item(builder, "play_welcome_menu_item")), "activate", G_CALLBACK (gtk_C_callback_welcome), (void *) this );
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "signal-player-done", G_CALLBACK (gtk_C_callback_do_player_done), (void*)this);
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "signal-need-redraw", G_CALLBACK (gtk_C_callback_do_player_done), (void*)this);
g_signal_connect_swapped (G_OBJECT (m_toplevelcontainer), "signal-internal-message", G_CALLBACK (gtk_C_callback_do_internal_message), (void*)this);
gtk_widget_show (m_toplevelcontainer);
/* VBox (m_guicontainer) to place the Menu bar in the correct place */
m_guicontainer = gtk_builder_find_menu_item (builder, "topbox");
g_object_unref (G_OBJECT (builder));
gtk_box_set_homogeneous ((GtkBox*) m_guicontainer, false);
#else // GTK_MAJOR_VERSION < 3
/* The Action Group that includes the menu bar */
m_actions = gtk_action_group_new("Actions");
gtk_action_group_set_translation_domain(m_actions, PACKAGE);
gtk_action_group_add_actions(m_actions, entries, n_entries, (void*)this);
/* The Gtk UI Manager */
GtkUIManager *ui = gtk_ui_manager_new();
if (!gtk_ui_manager_add_ui_from_string(ui, ui_description, -1, &error))
g_error("Could not merge UI, error was: %s\n", error->message);
gtk_ui_manager_insert_action_group(ui, m_actions, 0);
gtk_window_add_accel_group(m_toplevelcontainer, gtk_ui_manager_get_accel_group(ui));
// The actual activation calls
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "open"), "activate", G_CALLBACK (gtk_C_callback_open), (void *) this );
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "openurl"), "activate", G_CALLBACK (gtk_C_callback_open_url), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "reload"), "activate", G_CALLBACK (gtk_C_callback_reload), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "preferences"), "activate", G_CALLBACK (gtk_C_callback_settings_select), (void *) this );
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "loadsettings"), "activate", G_CALLBACK (gtk_C_callback_load_settings), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "quit"), "activate", G_CALLBACK (gtk_C_callback_quit), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "play"), "activate", G_CALLBACK (gtk_C_callback_play), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "pause"), "activate", G_CALLBACK (gtk_C_callback_pause), (void*)this );
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "stop"), "activate", G_CALLBACK (gtk_C_callback_stop), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "fullscreen"), "activate", G_CALLBACK (gtk_C_callback_full_screen), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "window"), "activate", G_CALLBACK (gtk_C_callback_normal_screen), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "logwindow"), "activate", G_CALLBACK (gtk_C_callback_logger_window), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "about"), "activate", G_CALLBACK (gtk_C_callback_about), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "help"), "activate", G_CALLBACK (gtk_C_callback_help), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "website"), "activate", G_CALLBACK (gtk_C_callback_homepage), (void*)this);
g_signal_connect_swapped (gtk_action_group_get_action (m_actions, "welcome"), "activate", G_CALLBACK (gtk_C_callback_welcome), (void*)this);
/* Creation of the Menubar and Menu Items */
menubar = gtk_ui_manager_get_widget (ui, "/MenuBar");
gtk_box_pack_start (GTK_BOX (m_guicontainer), menubar, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET (m_toplevelcontainer));
#endif // GTK_MAJOR_VERSION < 3
/* Creation of the document area */
m_documentcontainer = gtk_drawing_area_new();
gtk_widget_hide(m_documentcontainer);
gtk_box_pack_start (GTK_BOX (m_guicontainer), m_documentcontainer, TRUE, TRUE, 0);
#if GTK_MAJOR_VERSION >= 3
_update_menus();
#else // GTK_MAJOR_VERSION < 3
// creates the main loop
main_loop = g_main_loop_new(NULL, FALSE);
_update_menus();
#endif // GTK_MAJOR_VERSION < 3
}
void
gui_create_tasks(GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table;
GtkWidget *label;
GtkWidget *top_scrolledwindow;
GtkWidget *hseparator;
GtkWidget *close_button;
GtkCellRenderer *renderer;
GtkWidget *top_viewport;
GtkWidget *bottom_viewport;
GtkTextBuffer *text_buffer;
GError *error = NULL;
GtkActionGroup *action_group = NULL;
gchar tmpbuf[BUFFER_SIZE];
const gchar *ui_info =
" <toolbar name=\"toolbar\">\n"
" <toolitem name=\"add\" action=\"add\" />\n"
" <toolitem name=\"delete\" action=\"delete\" />\n"
" <separator name=\"sep1\" />\n"
" <toolitem name=\"edit\" action=\"edit\" />\n"
" </toolbar>\n";
GtkActionEntry entries[] = {
{ "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL },
{ "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL },
{ "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL },
};
guint n_entries = G_N_ELEMENTS (entries);
appGUI->tsk->filter_index = 0;
label = gtk_label_new(NULL);
gtk_label_set_angle (GTK_LABEL(label), -90.0);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks"));
gtk_label_set_markup (GTK_LABEL (label), tmpbuf);
vbox1 = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
gtk_notebook_append_page(GTK_NOTEBOOK(appGUI->notebook), vbox1, label);
appGUI->tsk->vbox = GTK_BOX(vbox1);
/*-------------------------------------------------------------------------------------*/
action_group = gtk_action_group_new ("_actions");
gtk_action_group_add_actions (action_group, entries, n_entries, NULL);
gtk_action_group_set_sensitive(action_group, TRUE);
appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0);
g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI);
if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) {
g_message ("building toolbar failed: %s", error->message);
g_error_free (error);
}
gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget);
gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips);
/*-------------------------------------------------------------------------------------*/
/* assign callbacks */
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked",
G_CALLBACK(tasks_add_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked",
G_CALLBACK(tasks_edit_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked",
G_CALLBACK(tasks_remove_item_cb), appGUI);
/*-------------------------------------------------------------------------------------*/
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "<b>%s:</b>", _("Category filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
appGUI->tsk->cf_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->cf_combobox);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE);
GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(appGUI->tsk->cf_combobox, "changed",
G_CALLBACK(category_filter_cb), appGUI);
g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus",
G_CALLBACK(category_combo_box_focus_cb), NULL);
appGUI->tsk->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->tsk->n_items_label);
gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
/*-------------------------------------------------------------------------------------*/
appGUI->tsk->tasks_paned = gtk_vpaned_new();
gtk_widget_show (appGUI->tsk->tasks_paned);
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999);
gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0);
top_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (top_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE);
gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE);
top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (top_scrolledwindow);
gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter),
(GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb,
appGUI, NULL);
appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter));
appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint);
gtk_widget_show (appGUI->tsk->tasks_list);
GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT);
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED]));
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event",
G_CALLBACK(list_dbclick_cb), appGUI);
appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed",
G_CALLBACK(tasks_item_selected), appGUI);
/* create columns */
renderer = gtk_cell_renderer_toggle_new();
appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"),
renderer,
"active", COLUMN_DONE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]);
g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"),
renderer,
"text", COLUMN_DUE_DATE,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_DUE_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_START_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"),
renderer,
"text", COLUMN_PRIORITY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"),
renderer,
"text", COLUMN_CATEGORY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_set_fixed_size(renderer, 0, -1);
appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"),
renderer,
"text", COLUMN_SUMMARY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"),
renderer,
"text", COLUMN_DESCRIPTION,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]);
/* configure list options */
gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE);
/* configure sorting */
gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0,
(GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order);
/*----------------------------------------------------------------------------*/
bottom_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (bottom_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE);
gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0);
gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2);
appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0);
gtk_widget_show(appGUI->tsk->panel_hbox);
sprintf(tmpbuf, "%s:", _("Task details"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0);
if (config.default_stock_icons) {
close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE);
} else {
close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL);
gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (panel_close_desc_cb), appGUI);
appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (appGUI->tsk->panel_scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_desc_textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_widget_show (appGUI->tsk->tasks_desc_textview);
gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
gtk_text_buffer_create_tag (text_buffer, "italic",
"style", PANGO_STYLE_ITALIC, NULL);
appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font",
"font", (gchar *) config.task_info_font, NULL);
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *main_hbox;
GtkWidget *vseparator;
GtkWidget *button;
GtkWidget *main_vbox;
GtkWidget *menubar;
GtkWidget *vbox;
GtkWidget *label;
GtkAccelGroup *accel_group;
PangoFontDescription *font_desc;
int i;
char *p;
p = progname = argv[0];
while (*p)
{
if (*p == '/') progname = p+1;
p++;
}
gtk_init (&argc, &argv);
for (i=1; i<argc; i++)
{
if (!strcmp(argv[i], "--data-file") ||
!strcmp(argv[i], "-f"))
{
i++;
if (i < argc)
data_file = argv[i];
else
usage();
}
else
{
usage();
}
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_window_set_default_size (GTK_WINDOW (window), 350, 350);
g_signal_connect (window, "destroy",
G_CALLBACK (exit_callback), NULL);
gtk_window_set_title (GTK_WINDOW(window), "KanjiPad");
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
gtk_widget_show (main_vbox);
/* Menu */
GtkActionGroup *action_group; /* Packing group for our Actions */
GtkUIManager *menu_manager; /* The magic widget! */
GError *error; /* For reporting exceptions or errors */
GtkWidget *toolbar; /* The actual toolbar */
action_group = gtk_action_group_new ("MainMenu");
gtk_action_group_add_actions (action_group, entries, n_entries, NULL);
gtk_action_group_add_toggle_actions (action_group, toggle_entries, n_toggle_entries, NULL);
menu_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (menu_manager, action_group, 0);
error = NULL;
gtk_ui_manager_add_ui_from_file (menu_manager, "ui.xml", &error);
if (error){
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
//Add the menu bar
menubar = gtk_ui_manager_get_widget (menu_manager, "/MainMenu");
gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, FALSE, 0);
/*accel_group = gtk_accel_group_new ();
factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items (factory, nmenu_items, menu_items, NULL);*/
/* create a menubar */
/*menubar = gtk_item_factory_get_widget (factory, "<main>");
gtk_box_pack_start (GTK_BOX (main_vbox), menubar,
FALSE, TRUE, 0);
gtk_widget_show (menubar);*/
/* Install the accelerator table in the main window */
//gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
main_hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER(window), main_hbox);
gtk_box_pack_start (GTK_BOX(main_vbox), main_hbox, TRUE, TRUE, 0);
gtk_widget_show (main_hbox);
/* toolbar = gtk_ui_manager_get_widget (menu_manager, "/MainToolbar");
gtk_box_pack_start (GTK_BOX (main_hbox), toolbar, FALSE, FALSE, 0);
gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (menu_manager));
*/
/* Area for user to draw characters in */
pad_area = pad_area_create ();
gtk_box_pack_start (GTK_BOX (main_hbox), pad_area->widget, TRUE, TRUE, 0);
gtk_widget_show (pad_area->widget);
vseparator = gtk_vseparator_new();
gtk_box_pack_start (GTK_BOX (main_hbox), vseparator, FALSE, FALSE, 0);
gtk_widget_show (vseparator);
/* Area in which to draw guesses */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
karea = gtk_drawing_area_new();
g_signal_connect (karea, "configure_event",
G_CALLBACK (karea_configure_event), NULL);
g_signal_connect (karea, "expose_event",
G_CALLBACK (karea_expose_event), NULL);
g_signal_connect (karea, "button_press_event",
G_CALLBACK (karea_button_press_event), NULL);
gtk_widget_set_events (karea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
#ifdef G_OS_WIN32
font_desc = pango_font_description_from_string ("MS Gothic 18");
#else
font_desc = pango_font_description_from_string ("Sans 18");
#endif
gtk_widget_modify_font (karea, font_desc);
gtk_box_pack_start (GTK_BOX (vbox), karea, TRUE, TRUE, 0);
gtk_widget_show (karea);
/* Buttons */
label = gtk_label_new ("\xe5\xbc\x95");
/* We have to set the alignment here, since GTK+ will fail
* to get the width of the string appropriately...
*/
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_modify_font (label, font_desc);
gtk_widget_show (label);
lookup_button = button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), label);
g_signal_connect (button, "clicked",
G_CALLBACK (look_up_callback), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
label = gtk_label_new ("\xe6\x88\xbb");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_modify_font (label, font_desc);
gtk_widget_show (label);
undo_button = button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), label);
g_signal_connect (button, "clicked",
G_CALLBACK (undo_callback), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
label = gtk_label_new ("\xe6\xb6\x88");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_modify_font (label, font_desc);
gtk_widget_show (label);
clear_button = button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), label);
g_signal_connect (button, "clicked",
G_CALLBACK (clear_callback), NULL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_widget_show(window);
pango_font_description_free (font_desc);
init_engine();
update_sensitivity ();
gtk_main();
return 0;
}
static void
create_window (void)
{
GtkWidget *bar;
GtkWidget *table;
GtkWidget *contents;
GtkUIManager *ui;
GtkWidget *sw;
GtkActionGroup *actions;
GError *error;
GtkWindowGroup *group;
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
group = gtk_window_group_new ();
gtk_window_group_add_window (group, GTK_WINDOW (main_window));
g_object_unref (group);
gtk_window_set_default_size (GTK_WINDOW (main_window),
400, 600);
g_signal_connect (main_window, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
actions = gtk_action_group_new ("Actions");
gtk_action_group_add_actions (actions, entries, n_entries, NULL);
ui = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui, actions, 0);
gtk_window_add_accel_group (GTK_WINDOW (main_window),
gtk_ui_manager_get_accel_group (ui));
gtk_container_set_border_width (GTK_CONTAINER (main_window), 0);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
{
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
table = gtk_table_new (1, 3, FALSE);
gtk_container_add (GTK_CONTAINER (main_window), table);
bar = gtk_ui_manager_get_widget (ui, "/MenuBar");
gtk_widget_show (bar);
gtk_table_attach (GTK_TABLE (table),
bar,
/* X direction */ /* Y direction */
0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Create document */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_table_attach (GTK_TABLE (table),
sw,
/* X direction */ /* Y direction */
0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
contents = gtk_text_view_new ();
gtk_widget_grab_focus (contents);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar */
statusbar = gtk_statusbar_new ();
gtk_table_attach (GTK_TABLE (table),
statusbar,
/* X direction */ /* Y direction */
0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Show text widget info in the statusbar */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
g_signal_connect_object (buffer,
"changed",
G_CALLBACK (buffer_changed_callback),
NULL,
0);
g_signal_connect_object (buffer,
"mark_set", /* cursor moved */
G_CALLBACK (mark_set_callback),
NULL,
0);
g_signal_connect_object (main_window,
"window_state_event",
G_CALLBACK (update_resize_grip),
statusbar,
0);
update_ui ();
gtk_widget_show_all (main_window);
}
void init_ui(int *argcp, char ***argvp)
{
GtkWidget *win;
GtkWidget *notebook;
GtkWidget *nb_page;
GtkWidget *dive_list;
GtkWidget *menubar;
GtkWidget *vbox;
GdkScreen *screen;
GtkIconTheme *icon_theme=NULL;
GtkSettings *settings;
GtkUIManager *ui_manager;
gtk_init(argcp, argvp);
settings = gtk_settings_get_default();
gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "subsurface setting");
g_type_init();
subsurface_open_conf();
if (subsurface_get_conf("feet", PREF_BOOL))
output_units.length = FEET;
if (subsurface_get_conf("psi", PREF_BOOL))
output_units.pressure = PSI;
if (subsurface_get_conf("cuft", PREF_BOOL))
output_units.volume = CUFT;
if (subsurface_get_conf("fahrenheit", PREF_BOOL))
output_units.temperature = FAHRENHEIT;
/* an unset key is FALSE - all these are hidden by default */
visible_cols.cylinder = PTR_TO_BOOL(subsurface_get_conf("CYLINDER", PREF_BOOL));
visible_cols.temperature = PTR_TO_BOOL(subsurface_get_conf("TEMPERATURE", PREF_BOOL));
visible_cols.nitrox = PTR_TO_BOOL(subsurface_get_conf("NITROX", PREF_BOOL));
visible_cols.otu = PTR_TO_BOOL(subsurface_get_conf("OTU", PREF_BOOL));
visible_cols.sac = PTR_TO_BOOL(subsurface_get_conf("SAC", PREF_BOOL));
divelist_font = subsurface_get_conf("divelist_font", PREF_STRING);
error_info_bar = NULL;
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_set_application_name ("subsurface");
/* Let's check if the subsurface icon has been installed or if
* we need to try to load it from the current directory */
screen = gdk_screen_get_default();
if (screen)
icon_theme = gtk_icon_theme_get_for_screen(screen);
if (icon_theme) {
if (gtk_icon_theme_has_icon(icon_theme, "subsurface")) {
need_icon = FALSE;
gtk_window_set_default_icon_name ("subsurface");
}
}
if (need_icon) {
const char *icon_name = subsurface_icon_name();
if (!access(icon_name, R_OK))
gtk_window_set_icon_from_file(GTK_WINDOW(win), icon_name, NULL);
}
g_signal_connect(G_OBJECT(win), "delete-event", G_CALLBACK(on_delete), NULL);
g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(on_destroy), NULL);
main_window = win;
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(win), vbox);
main_vbox = vbox;
ui_manager = gtk_ui_manager_new();
menubar = get_menubar_menu(win, ui_manager);
subsurface_ui_setup(settings, menubar, vbox, ui_manager);
vpane = gtk_vpaned_new();
gtk_box_pack_start(GTK_BOX(vbox), vpane, TRUE, TRUE, 3);
hpane = gtk_hpaned_new();
gtk_paned_add1(GTK_PANED(vpane), hpane);
/* Notebook for dive info vs profile vs .. */
notebook = gtk_notebook_new();
gtk_paned_add1(GTK_PANED(hpane), notebook);
g_signal_connect(notebook, "switch-page", G_CALLBACK(switch_page), NULL);
/* Create the actual divelist */
dive_list = dive_list_create();
gtk_widget_set_name(dive_list, "Dive List");
gtk_paned_add2(GTK_PANED(vpane), dive_list);
/* Frame for dive profile */
dive_profile = dive_profile_widget();
gtk_widget_set_name(dive_profile, "Dive Profile");
gtk_paned_add2(GTK_PANED(hpane), dive_profile);
/* Frame for extended dive info */
nb_page = extended_dive_info_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Dive Notes"));
/* Frame for dive equipment */
nb_page = equipment_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Equipment"));
/* Frame for single dive statistics */
nb_page = single_stats_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Dive Info"));
/* Frame for total dive statistics */
nb_page = total_stats_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), nb_page, gtk_label_new("Overall Stats"));
gtk_widget_set_app_paintable(win, TRUE);
gtk_widget_show_all(win);
return;
}
static void fm_main_win_init(FmMainWin *self)
{
GtkWidget *vbox, *menubar, *toolitem, *next_btn, *scroll;
GtkUIManager* ui;
GtkActionGroup* act_grp;
GtkAction* act;
GtkAccelGroup* accel_grp;
++n_wins;
vbox = gtk_vbox_new(FALSE, 0);
self->hpaned = gtk_hpaned_new();
gtk_paned_set_position(GTK_PANED(self->hpaned), 150);
/* places left pane */
self->places_view = fm_places_view_new();
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scroll), self->places_view);
gtk_paned_add1(GTK_PANED(self->hpaned), scroll);
/* folder view */
self->folder_view = fm_folder_view_new( FM_FV_ICON_VIEW );
fm_folder_view_set_show_hidden(FM_FOLDER_VIEW(self->folder_view), FALSE);
fm_folder_view_sort(FM_FOLDER_VIEW(self->folder_view), GTK_SORT_DESCENDING, COL_FILE_NAME);
fm_folder_view_set_selection_mode(FM_FOLDER_VIEW(self->folder_view), GTK_SELECTION_MULTIPLE);
g_signal_connect(self->folder_view, "clicked", on_file_clicked, self);
g_signal_connect(self->folder_view, "status", on_status, self);
g_signal_connect(self->folder_view, "sel-changed", on_sel_changed, self);
gtk_paned_add2(GTK_PANED(self->hpaned), self->folder_view);
/* link places view with folder view. */
g_signal_connect_swapped(self->places_view, "chdir", G_CALLBACK(fm_main_win_chdir), self);
/* create menu bar and toolbar */
ui = gtk_ui_manager_new();
act_grp = gtk_action_group_new("Main");
gtk_action_group_add_actions(act_grp, main_win_actions, G_N_ELEMENTS(main_win_actions), self);
gtk_action_group_add_toggle_actions(act_grp, main_win_toggle_actions, G_N_ELEMENTS(main_win_toggle_actions), self);
gtk_action_group_add_radio_actions(act_grp, main_win_mode_actions, G_N_ELEMENTS(main_win_mode_actions), FM_FV_ICON_VIEW, on_change_mode, self);
gtk_action_group_add_radio_actions(act_grp, main_win_sort_type_actions, G_N_ELEMENTS(main_win_sort_type_actions), GTK_SORT_ASCENDING, on_sort_type, self);
gtk_action_group_add_radio_actions(act_grp, main_win_sort_by_actions, G_N_ELEMENTS(main_win_sort_by_actions), 0, on_sort_by, self);
accel_grp = gtk_ui_manager_get_accel_group(ui);
gtk_window_add_accel_group(GTK_WINDOW(self), accel_grp);
gtk_ui_manager_insert_action_group(ui, act_grp, 0);
gtk_ui_manager_add_ui_from_string(ui, main_menu_xml, -1, NULL);
menubar = gtk_ui_manager_get_widget(ui, "/menubar");
self->toolbar = gtk_ui_manager_get_widget(ui, "/toolbar");
/* FIXME: should make these optional */
gtk_toolbar_set_icon_size(GTK_TOOLBAR(self->toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_toolbar_set_style(GTK_TOOLBAR(self->toolbar), GTK_TOOLBAR_ICONS);
/* create 'Next' button manually and add a popup menu to it */
toolitem = g_object_new(GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(self->toolbar), toolitem, 2);
gtk_widget_show(GTK_WIDGET(toolitem));
act = gtk_ui_manager_get_action(ui, "/menubar/GoMenu/Next");
gtk_activatable_set_related_action(GTK_ACTIVATABLE(toolitem), act);
/* set up history menu */
self->nav_history = fm_nav_history_new();
self->history_menu = gtk_menu_new();
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolitem), self->history_menu);
g_signal_connect(toolitem, "show-menu", G_CALLBACK(on_show_history_menu), self);
self->popup = gtk_ui_manager_get_widget(ui, "/popup");
gtk_box_pack_start( (GtkBox*)vbox, menubar, FALSE, TRUE, 0 );
gtk_box_pack_start( (GtkBox*)vbox, self->toolbar, FALSE, TRUE, 0 );
/* load bookmarks menu */
load_bookmarks(self, ui);
/* the location bar */
self->location = fm_path_entry_new();
g_signal_connect(self->location, "activate", on_entry_activate, self);
g_signal_connect(self->folder_view, "loaded", G_CALLBACK(on_view_loaded), (gpointer) self);
toolitem = gtk_tool_item_new();
gtk_container_add( GTK_CONTAINER(toolitem), self->location );
gtk_tool_item_set_expand(GTK_TOOL_ITEM(toolitem), TRUE);
gtk_toolbar_insert((GtkToolbar*)self->toolbar, toolitem, gtk_toolbar_get_n_items(GTK_TOOLBAR(self->toolbar)) - 1 );
gtk_box_pack_start( (GtkBox*)vbox, self->hpaned, TRUE, TRUE, 0 );
/* status bar */
self->statusbar = gtk_statusbar_new();
gtk_box_pack_start( (GtkBox*)vbox, self->statusbar, FALSE, TRUE, 0 );
self->statusbar_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(self->statusbar), "status");
self->statusbar_ctx2 = gtk_statusbar_get_context_id(GTK_STATUSBAR(self->statusbar), "status2");
g_object_unref(act_grp);
self->ui = ui;
gtk_container_add( (GtkContainer*)self, vbox );
gtk_widget_show_all(vbox);
fm_folder_view_set_show_hidden(FM_FOLDER_VIEW(self->folder_view), FALSE);
fm_main_win_chdir(self, fm_path_get_home());
gtk_widget_grab_focus(self->folder_view);
}
GtkWidget *gui_build_interface(void)
{
GtkWidget *vbox;
GtkWidget *menubar;
GtkActionGroup *action_group;
GtkAccelGroup *accel_group;
GError *error = NULL;
gchar *icon_file;
player_init();
gmap = guimap_new();
register_pixmaps();
app_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* The name of the application */
gtk_window_set_title(GTK_WINDOW(app_window), _("Pioneers"));
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(app_window), vbox);
action_group = gtk_action_group_new("MenuActions");
gtk_action_group_set_translation_domain(action_group, PACKAGE);
gtk_action_group_add_actions(action_group, entries,
G_N_ELEMENTS(entries), app_window);
gtk_action_group_add_toggle_actions(action_group, toggle_entries,
G_N_ELEMENTS(toggle_entries),
app_window);
ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
accel_group = gtk_ui_manager_get_accel_group(ui_manager);
gtk_window_add_accel_group(GTK_WINDOW(app_window), accel_group);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string
(ui_manager, ui_description, -1, &error)) {
g_message("building menus failed: %s", error->message);
g_error_free(error);
return NULL;
}
icon_file =
g_build_filename(DATADIR, "pixmaps", PIONEERS_ICON_FILE, NULL);
if (g_file_test(icon_file, G_FILE_TEST_EXISTS)) {
gtk_window_set_default_icon_from_file(icon_file, NULL);
} else {
/* Missing pixmap, main icon file */
g_warning("Pixmap not found: %s", icon_file);
}
g_free(icon_file);
color_chat_enabled =
config_get_int_with_default("settings/color_chat", TRUE);
color_messages_enabled =
config_get_int_with_default("settings/color_messages", TRUE);
log_set_func_message_color_enable(color_messages_enabled);
set_color_summary(config_get_int_with_default
("settings/color_summary", TRUE));
set_silent_mode(config_get_int_with_default
("settings/silent_mode", FALSE));
set_announce_player(config_get_int_with_default
("settings/announce_player", TRUE));
legend_page_enabled =
config_get_int_with_default("settings/legend_page", FALSE);
menubar = gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
toolbar = gtk_ui_manager_get_widget(ui_manager, "/MainToolbar");
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), build_main_interface(), TRUE,
TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), build_status_bar(), FALSE, FALSE,
0);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION
(gtk_ui_manager_get_action
(ui_manager,
"ui/MainMenu/SettingsMenu/ShowHideToolbar")),
config_get_int_with_default
("settings/show_toolbar", TRUE));
g_signal_connect(G_OBJECT(app_window), "key_press_event",
G_CALLBACK(hotkeys_handler), NULL);
gtk_widget_show(app_window);
frontend_gui_register_action(getAction(GUI_CONNECT), GUI_CONNECT);
frontend_gui_register_action(getAction(GUI_DISCONNECT),
GUI_DISCONNECT);
#ifdef ADMIN_GTK
/** @todo RC 2005-05-26 Admin interface: Not tested */
frontend_gui_register_action(gtk_ui_manager_get_action
(manager,
"ui/MainMenu/GameMenu/GameAdmin"),
GUI_ADMIN);
#endif
frontend_gui_register_action(getAction(GUI_CHANGE_NAME),
GUI_CHANGE_NAME);
frontend_gui_register_action(getAction(GUI_ROLL), GUI_ROLL);
frontend_gui_register_action(getAction(GUI_TRADE), GUI_TRADE);
frontend_gui_register_action(getAction(GUI_UNDO), GUI_UNDO);
frontend_gui_register_action(getAction(GUI_FINISH), GUI_FINISH);
frontend_gui_register_action(getAction(GUI_ROAD), GUI_ROAD);
frontend_gui_register_action(getAction(GUI_SHIP), GUI_SHIP);
frontend_gui_register_action(getAction(GUI_MOVE_SHIP),
GUI_MOVE_SHIP);
frontend_gui_register_action(getAction(GUI_BRIDGE), GUI_BRIDGE);
frontend_gui_register_action(getAction(GUI_SETTLEMENT),
GUI_SETTLEMENT);
frontend_gui_register_action(getAction(GUI_CITY), GUI_CITY);
frontend_gui_register_action(getAction(GUI_BUY_DEVELOP),
GUI_BUY_DEVELOP);
frontend_gui_register_action(getAction(GUI_CITY_WALL),
GUI_CITY_WALL);
#if 0
frontend_gui_register_destroy(gtk_ui_manager_get_action
(manager, "GameQuit"), GUI_QUIT);
#endif
gui_toolbar_show_button("BuildShip", FALSE);
gui_toolbar_show_button("MoveShip", FALSE);
gui_toolbar_show_button("BuildBridge", FALSE);
gui_toolbar_show_accelerators(config_get_int_with_default
("settings/toolbar_show_accelerators",
TRUE));
gtk_ui_manager_ensure_update(ui_manager);
gtk_widget_show(app_window);
g_signal_connect(G_OBJECT(app_window), "delete_event",
G_CALLBACK(quit_cb), NULL);
return app_window;
}
void create_main_window ()
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
GtkUIManager *ui_manager = gtk_ui_manager_new ();
GtkActionGroup *action_group = create_action_group ();
GError *error = NULL;
gchar *ui_path = rookie_misc_get_ui_path ("AppUI.ui");
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_file (ui_manager, ui_path, &error);
handle_critical_error (error);
g_free (ui_path);
eggicon = gtk_status_icon_new_from_icon_name ("rookie");
init_actions (action_group);
menubar = gtk_ui_manager_get_widget (ui_manager, "/menubar");
toolbar = gtk_ui_manager_get_widget (ui_manager, "/toolbar");
statbar = create_statusbar ();
mainbox = gtk_vbox_new (FALSE, 0);
mainpopup = gtk_ui_manager_get_widget (ui_manager, "/m_popup");
viewpopup = gtk_ui_manager_get_widget (ui_manager, "/v_popup");
statpopup = gtk_ui_manager_get_widget (ui_manager, "/s_popup");
gtk_toolbar_set_icon_size (GTK_TOOLBAR(toolbar),
GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
sw1 = gtk_scrolled_window_new (NULL, NULL);
sw2 = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
sidepane = create_sidepane ();
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(sw1), sidepane);
view = g_download_list_controller_get_view ();
gtk_container_add (GTK_CONTAINER (sw2), view);
bottompane = create_bottom_pane ();
vpaned = gtk_vpaned_new ();
gtk_paned_add1 (GTK_PANED(vpaned), sw2);
gtk_paned_add2 (GTK_PANED(vpaned), bottompane);
hpaned = gtk_hpaned_new ();
gtk_paned_add1 (GTK_PANED(hpaned), sw1);
gtk_paned_add2 (GTK_PANED(hpaned), vpaned);
gtk_paned_set_position (GTK_PANED(hpaned), rookie_settings_get_sidepane_width ());
gtk_paned_set_position (GTK_PANED(vpaned), rookie_settings_get_bottompane_width ());
gtk_window_add_accel_group (GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
gtk_window_set_title (GTK_WINDOW(window), _("Rookie Download Manager"));
gtk_window_set_icon_name (GTK_WINDOW(window), "rookie");
gtk_box_pack_start (GTK_BOX(mainbox), menubar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(mainbox), toolbar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(mainbox), hpaned, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX(mainbox), statbar, FALSE, FALSE, 0);
relayout_mainbox ();
gtk_container_add (GTK_CONTAINER(window), mainbox);
gtk_window_set_geometry_hints (GTK_WINDOW (window), window, NULL,
GDK_HINT_USER_SIZE | GDK_HINT_USER_POS | GDK_HINT_POS);
gtk_window_resize (GTK_WINDOW(window),
rookie_settings_get_window_width (),
rookie_settings_get_window_height());
rookie_settings_bind (ROOKIE_TOOLBAR_VISIBLE, toolbar, "visible");
rookie_settings_bind (ROOKIE_STATUSBAR_VISIBLE, statbar, "visible");
/* Signals */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
g_download_list_foreach ((GFunc)g_downloadable_connect_signals, NULL);
g_signal_connect (eggicon, "activate",
G_CALLBACK(on_egg_icon_activate), NULL);
g_signal_connect (eggicon, "popup-menu",
G_CALLBACK(on_egg_icon_popup_menu), NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK(on_window_delete), NULL);
g_signal_connect (g_download_list_get (), "download-added",
G_CALLBACK (on_download_added), NULL);
g_signal_connect (g_download_list_get (), "download-removed",
G_CALLBACK (on_download_removed), NULL);
g_signal_connect (view, "button-press-event",
G_CALLBACK(on_view_button_press), selection);
g_signal_connect (selection, "changed",
G_CALLBACK(on_selection_change), NULL);
}
gboolean gui_init( gboolean withDebug, gboolean withFullscreen )
{
if( gtk_gui_init_ok ) {
int i;
GError *error = NULL;
dreamcast_register_module( >k_gui_module );
gtk_gui_alloc_resources();
global_action_group = gtk_action_group_new("MenuActions");
gtk_action_group_set_translation_domain( global_action_group, NULL );
gtk_action_group_add_actions( global_action_group, ui_actions, G_N_ELEMENTS(ui_actions), NULL );
gtk_action_group_add_toggle_actions( global_action_group, ui_toggle_actions, G_N_ELEMENTS(ui_toggle_actions), NULL );
for( i=0; i<=MAX_QUICK_STATE; i++ ) {
ui_radio_actions[i].name = g_strdup_printf("QuickState%d", i);
ui_radio_actions[i].stock_id = NULL;
ui_radio_actions[i].label = g_strdup_printf(_("State _%d"), i );
ui_radio_actions[i].accelerator = NULL;
ui_radio_actions[i].tooltip = g_strdup_printf(_("Use quick save state %d"),i);
ui_radio_actions[i].value = i;
}
gtk_action_group_add_radio_actions( global_action_group, ui_radio_actions, G_N_ELEMENTS(ui_radio_actions),
dreamcast_get_quick_state(), G_CALLBACK(quick_state_action_callback), NULL );
gtk_gui_enable_action("AudioSettings", FALSE);
gtk_gui_enable_action("NetworkSettings", FALSE);
gtk_gui_enable_action("VideoSettings", FALSE);
global_ui_manager = gtk_ui_manager_new();
gtk_ui_manager_set_add_tearoffs(global_ui_manager, TRUE);
gtk_ui_manager_insert_action_group( global_ui_manager, global_action_group, 0 );
if (!gtk_ui_manager_add_ui_from_string (global_ui_manager, ui_description, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
exit(1);
}
GtkAccelGroup *accel_group = gtk_ui_manager_get_accel_group (global_ui_manager);
GtkWidget *menubar = gtk_ui_manager_get_widget(global_ui_manager, "/MainMenu");
GtkWidget *toolbar = gtk_ui_manager_get_widget(global_ui_manager, "/MainToolbar");
GtkWidget *gdrommenuitem = gtk_ui_manager_get_widget(global_ui_manager, "/MainMenu/FileMenu/GdromSettings");
GtkWidget *gdrommenu = gdrom_menu_new();
gtk_menu_item_set_submenu( GTK_MENU_ITEM(gdrommenuitem), gdrommenu );
main_win = main_window_new( lxdream_package_name, menubar, toolbar, accel_group );
if( withDebug ) {
gtk_gui_show_debugger();
}
if (withFullscreen) {
main_window_set_fullscreen(main_win, TRUE);
//manually call full-screen state code for non-compliant window managers
main_window_show_gui(main_win, TRUE);
}
register_gdrom_disc_change_hook( gtk_gui_disc_changed, NULL );
return TRUE;
} else {
return FALSE;
}
}
static GtkUIManager *
ui_manager_new (GtkWidget *window)
{
static const GtkActionEntry actions[] =
{
{
"back", GTK_STOCK_GO_BACK,
NULL, "<alt>Left", N_("Go back one page"),
G_CALLBACK (back_callback)
},
{
"forward", GTK_STOCK_GO_FORWARD,
NULL, "<alt>Right", N_("Go forward one page"),
G_CALLBACK (forward_callback)
},
{
"reload", GTK_STOCK_REFRESH,
N_("_Reload"), "<control>R", N_("Reload current page"),
G_CALLBACK (reload_callback)
},
{
"stop", GTK_STOCK_CANCEL,
N_("_Stop"), "Escape", N_("Stop loading this page"),
G_CALLBACK (stop_callback)
},
{
"home", GTK_STOCK_HOME,
NULL, "<alt>Home", N_("Go to the index page"),
G_CALLBACK (home_callback)
},
{
"copy-location", GTK_STOCK_COPY,
N_("C_opy location"), "",
N_("Copy the location of this page to the clipboard"),
G_CALLBACK (copy_location_callback)
},
{
"copy-selection", GTK_STOCK_COPY,
NULL, "<control>C", NULL,
G_CALLBACK (copy_selection_callback)
},
{
"zoom-in", GTK_STOCK_ZOOM_IN,
NULL, "<control>plus", NULL,
G_CALLBACK (zoom_in_callback)
},
{
"zoom-out", GTK_STOCK_ZOOM_OUT,
NULL, "<control>minus", NULL,
G_CALLBACK (zoom_out_callback)
},
{
"find", GTK_STOCK_FIND,
NULL, "<control>F", N_("Find text in current page"),
G_CALLBACK (find_callback)
},
{
"find-again", NULL,
N_("Find _Again"), "<control>G", NULL,
G_CALLBACK (find_again_callback)
},
{
"close", GTK_STOCK_CLOSE,
NULL, "<control>W", NULL,
G_CALLBACK (close_callback)
},
{
"quit", GTK_STOCK_QUIT,
NULL, "<control>Q", NULL,
G_CALLBACK (close_callback)
}
};
static const GtkToggleActionEntry toggle_actions[] =
{
{
"show-index", NULL,
N_("S_how Index"), "<control>I",
N_("Toggle the visibility of the sidebar"),
G_CALLBACK (show_index_callback), FALSE
}
};
GtkUIManager *ui_manager = gtk_ui_manager_new ();
GtkActionGroup *group = gtk_action_group_new ("Actions");
GtkAction *action;
GError *error = NULL;
gtk_action_group_set_translation_domain (group, NULL);
gtk_action_group_add_actions (group,
actions, G_N_ELEMENTS (actions),
NULL);
gtk_action_group_add_toggle_actions (group,
toggle_actions,
G_N_ELEMENTS (toggle_actions),
NULL);
action = gimp_throbber_action_new ("website",
"docs.gimp.org",
_("Visit the GIMP documentation website"),
GIMP_STOCK_USER_MANUAL);
g_signal_connect_closure (action, "activate",
g_cclosure_new (G_CALLBACK (website_callback),
NULL, NULL),
FALSE);
gtk_action_group_add_action (group, action);
g_object_unref (action);
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager));
gtk_ui_manager_insert_action_group (ui_manager, group, -1);
g_object_unref (group);
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <toolbar name=\"help-browser-toolbar\">"
" <toolitem action=\"reload\" />"
" <toolitem action=\"stop\" />"
" <toolitem action=\"home\" />"
" <separator name=\"space\" />"
" <toolitem action=\"website\" />"
" </toolbar>"
" <accelerator action=\"close\" />"
" <accelerator action=\"quit\" />"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <popup name=\"help-browser-popup\">"
" <menuitem action=\"back\" />"
" <menuitem action=\"forward\" />"
" <menuitem action=\"reload\" />"
" <menuitem action=\"stop\" />"
" <separator />"
" <menuitem action=\"home\" />"
" <menuitem action=\"copy-location\" />"
" <menuitem action=\"show-index\" />"
" <separator />"
" <menuitem action=\"find\" />"
" <menuitem action=\"find-again\" />"
" <separator />"
" <menuitem action=\"zoom-in\" />"
" <menuitem action=\"zoom-out\" />"
" <separator />"
" <menuitem action=\"close\" />"
" </popup>"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <popup name=\"help-browser-copy-popup\">"
" <menuitem action=\"copy-selection\" />"
" </popup>"
"</ui>",
-1, &error);
if (error)
{
g_warning ("error parsing ui: %s", error->message);
g_clear_error (&error);
}
return ui_manager;
}
static void
ld_window_main_init (LdWindowMain *self)
{
LdWindowMainPrivate *priv;
GError *error;
self->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE
(self, LD_TYPE_WINDOW_MAIN, LdWindowMainPrivate);
/* Construct menu and toolbar. */
priv->ui_manager = gtk_ui_manager_new ();
g_signal_connect (priv->ui_manager, "connect-proxy",
G_CALLBACK (on_ui_proxy_connected), self);
g_signal_connect (priv->ui_manager, "disconnect-proxy",
G_CALLBACK (on_ui_proxy_disconnected), self);
priv->action_group = gtk_action_group_new ("MainActions");
gtk_action_group_set_translation_domain
(priv->action_group, GETTEXT_DOMAIN);
gtk_action_group_add_actions
(priv->action_group, wm_action_entries,
G_N_ELEMENTS (wm_action_entries), self);
gtk_action_group_add_toggle_actions
(priv->action_group, wm_toggle_action_entries,
G_N_ELEMENTS (wm_toggle_action_entries), self);
gtk_ui_manager_insert_action_group (priv->ui_manager,
priv->action_group, 0);
error = NULL;
gtk_ui_manager_add_ui_from_file
(priv->ui_manager, PROJECT_SHARE_DIR "gui/window-main.ui", &error);
if (error)
{
g_message ("building UI failed: %s", error->message);
g_error_free (error);
}
priv->menu = gtk_ui_manager_get_widget (priv->ui_manager, "/MenuBar");
priv->toolbar = gtk_ui_manager_get_widget (priv->ui_manager, "/Toolbar");
/* Create the remaining widgets. */
priv->library_view = ld_category_tree_view_new (NULL);
priv->view = LD_DIAGRAM_VIEW (ld_diagram_view_new ());
priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (priv->scrolled_window),
GTK_WIDGET (priv->view));
priv->statusbar = gtk_statusbar_new ();
priv->statusbar_menu_context_id = gtk_statusbar_get_context_id
(GTK_STATUSBAR (priv->statusbar), "menu");
priv->statusbar_symbol_context_id = gtk_statusbar_get_context_id
(GTK_STATUSBAR (priv->statusbar), "symbol");
priv->statusbar_hint_context_id = gtk_statusbar_get_context_id
(GTK_STATUSBAR (priv->statusbar), "hint");
priv->lv_viewport = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type
(GTK_VIEWPORT (priv->lv_viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (priv->lv_viewport), priv->library_view);
priv->lv_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->lv_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (priv->lv_window), priv->lv_viewport);
priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack1 (GTK_PANED (priv->paned),
priv->lv_window, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (priv->paned),
priv->scrolled_window, TRUE, TRUE);
gtk_paned_set_position (GTK_PANED (priv->paned), 180);
/* Pack all widgets into the window. */
priv->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (priv->vbox), priv->menu, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (priv->vbox), priv->toolbar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (priv->vbox), priv->paned, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (priv->vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (self), priv->vbox);
/* Configure the window. */
g_signal_connect (self, "delete-event", G_CALLBACK (on_delete), NULL);
gtk_window_add_accel_group (GTK_WINDOW (self),
gtk_ui_manager_get_accel_group (priv->ui_manager));
gtk_window_set_default_size (GTK_WINDOW (self), 640, 440);
gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER);
/* Initialize the backend. */
priv->diagram = ld_diagram_new ();
g_signal_connect_after (priv->diagram, "changed",
G_CALLBACK (on_diagram_changed), self);
g_signal_connect (priv->diagram, "notify::can-undo",
G_CALLBACK (on_diagram_history_changed), self);
g_signal_connect (priv->diagram, "notify::can-redo",
G_CALLBACK (on_diagram_history_changed), self);
g_signal_connect_after (priv->diagram, "selection-changed",
G_CALLBACK (on_diagram_selection_changed), self);
priv->library = ld_library_new ();
load_library_directories (priv->library);
ld_diagram_view_set_diagram (priv->view, priv->diagram);
ld_diagram_view_set_library (priv->view, priv->library);
ld_category_view_set_category (LD_CATEGORY_VIEW (priv->library_view),
ld_library_get_root (priv->library));
g_signal_connect_after (priv->library_view, "symbol-selected",
G_CALLBACK (on_symbol_selected), self);
g_signal_connect_after (priv->library_view, "symbol-deselected",
G_CALLBACK (on_symbol_deselected), self);
diagram_set_filename (self, NULL);
priv->statusbar_hint_drag = gtk_statusbar_push
(GTK_STATUSBAR (priv->statusbar), priv->statusbar_hint_context_id,
_("Drag symbols from the library pane to add them to the diagram."));
priv->zoom_label = gtk_label_new ("");
gtk_label_set_single_line_mode (GTK_LABEL (priv->zoom_label), TRUE);
gtk_box_pack_end (GTK_BOX (gtk_statusbar_get_message_area
(GTK_STATUSBAR (priv->statusbar))), priv->zoom_label, FALSE, FALSE, 0);
g_signal_connect (priv->view, "notify::zoom",
G_CALLBACK (on_view_zoom_changed), self);
g_object_notify (G_OBJECT (priv->view), "zoom");
action_set_sensitive (self, "Undo", FALSE);
action_set_sensitive (self, "Redo", FALSE);
action_set_sensitive (self, "Delete", FALSE);
action_set_sensitive (self, "NormalSize", FALSE);
gtk_widget_grab_focus (GTK_WIDGET (priv->view));
/* Realize the window. */
gtk_widget_show_all (GTK_WIDGET (self));
/* Set up GSettings. */
priv->settings = g_settings_new ("org." PROJECT_NAME);
g_settings_bind (priv->settings, "show-main-toolbar",
gtk_action_group_get_action (priv->action_group,
"MainToolbar"), "active", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (priv->settings, "show-library-pane",
gtk_action_group_get_action (priv->action_group,
"LibraryPane"), "active", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (priv->settings, "show-grid",
gtk_action_group_get_action (priv->action_group,
"ShowGrid"), "active", G_SETTINGS_BIND_DEFAULT);
}
static void
gpinstruct_server_window_init (GPInstructServerWindow *object)
{
object->priv = GPINSTRUCT_SERVER_WINDOW_GET_PRIVATE (object);
GPInstructServerWindowPrivate *priv = object->priv;
g_object_set (object, "icon-name", "gpinstruct-view", NULL);
GError *error = NULL;
GtkActionEntry actions[] =
{
{"file", NULL, _("_File")},
{"file-new", GTK_STOCK_NEW, NULL, "<Control>N", NULL, G_CALLBACK (file_new_action)},
{"file-close", GTK_STOCK_CLOSE, NULL, "<Control>W", NULL, G_CALLBACK (file_close_action)},
{"file-quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK (file_quit_action)},
{"edit", NULL, _("_Edit")},
{"edit-preferences", GTK_STOCK_PREFERENCES, NULL, NULL, NULL, G_CALLBACK (edit_preferences_action)},
{"help", NULL, _("_Help")},
{"help-contents", NULL, _("_Contents"), "F1", NULL, G_CALLBACK (help_contents_action)},
{"help-about", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK (help_about_action)}
};
gchar *ui =
"<ui>"
" <menubar name=\"menubar\">"
" <menu name=\"FileMenu\" action=\"file\">"
" <menuitem name=\"New\" action=\"file-new\" />"
" <separator/>"
" <menuitem name=\"Close\" action=\"file-close\" />"
" <separator/>"
" <menuitem name=\"Quit\" action=\"file-quit\" />"
" <placeholder name=\"FileMenuAdditions\" />"
" </menu>"
" <menu name=\"EditMenu\" action=\"edit\">"
" <placeholder name=\"EditMenuAdditions\" />"
" <separator/>"
" <menuitem name=\"Preferences\" action=\"edit-preferences\"/>"
" </menu>"
" <menu name=\"HelpMenu\" action=\"help\">"
" <menuitem name=\"Contents\" action=\"help-contents\"/>"
" <separator/>"
" <placeholder name=\"HelpMenuAdditions\" />"
" <separator/>"
" <menuitem name=\"About\" action=\"help-about\"/>"
" </menu>"
" </menubar>"
" <toolbar action=\"toolbar\">"
" <placeholder name=\"FileToolItems\">"
" <separator/>"
" <toolitem name=\"New\" action=\"file-new\" />"
" <toolitem name=\"Close\" action=\"file-close\" />"
" <separator/>"
" </placeholder>"
" </toolbar>"
"</ui>";
gtk_window_set_title (GTK_WINDOW (object), _("GPInstruct Server"));
gtk_window_set_default_size (GTK_WINDOW (object), 800, 600);
priv->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (object), priv->main_vbox);
priv->manager = gtk_ui_manager_new ();
gtk_window_add_accel_group (GTK_WINDOW (object), gtk_ui_manager_get_accel_group (priv->manager));
priv->action_group = gtk_action_group_new ("gpinstruct-server-window");
gtk_action_group_add_actions (priv->action_group, actions, G_N_ELEMENTS (actions), object);
gtk_action_set_sensitive (gtk_action_group_get_action (priv->action_group,
"file-close"),
FALSE);
gtk_ui_manager_insert_action_group (priv->manager, priv->action_group, 0);
gtk_ui_manager_add_ui_from_string (priv->manager, ui, -1, &error);
if (error)
{
g_critical ("%s", error->message);
g_error_free (error);
}
GtkWidget *main_menu = gtk_ui_manager_get_widget (priv->manager, "/menubar");
gtk_box_pack_start (GTK_BOX (priv->main_vbox), main_menu, FALSE, TRUE, 0);
GtkWidget *toolbar = gtk_ui_manager_get_widget (priv->manager, "/toolbar");
#if GTK_MAJOR_VERSION >= 3
gtk_style_context_add_class (gtk_widget_get_style_context (toolbar),
GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
gtk_box_pack_start (GTK_BOX (priv->main_vbox), toolbar, FALSE, TRUE, 0);
GtkWidget *info_frame = gtk_frame_new (_("Project Information"));
gtk_box_pack_start (GTK_BOX (priv->main_vbox), info_frame,
FALSE, TRUE, 0);
GtkWidget *info_table = gtk_table_new (2, 2, FALSE);
gtk_container_add (GTK_CONTAINER (info_frame), info_table);
GtkWidget *title_label = gtk_label_new (_("Title:"));
gtk_table_attach (GTK_TABLE (info_table), title_label,
0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL,
0, 0);
priv->title_entry = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (priv->title_entry), FALSE);
gtk_table_attach (GTK_TABLE (info_table), priv->title_entry,
1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_SHRINK | GTK_FILL,
0, 0);
GtkWidget *port_label = gtk_label_new (_("Port:"));
gtk_table_attach (GTK_TABLE (info_table), port_label,
0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL,
0, 0);
priv->port_entry = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (priv->port_entry), FALSE);
gtk_table_attach (GTK_TABLE (info_table), priv->port_entry,
1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_SHRINK | GTK_FILL,
0, 0);
priv->store = gtk_tree_store_new (SERVER_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT);
priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->store));
gtk_box_pack_start (GTK_BOX (priv->main_vbox), priv->tree_view, FALSE, TRUE, 0);
priv->statusbar = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (priv->main_vbox), priv->statusbar, FALSE, TRUE, 0);
}
void
liferea_shell_create (GtkApplication *app, const gchar *overrideWindowState)
{
GtkUIManager *ui_manager;
GtkAccelGroup *accel_group;
GError *error = NULL;
gboolean toggle;
gchar *id;
debug_enter ("liferea_shell_create");
g_object_new (LIFEREA_SHELL_TYPE, NULL);
shell->priv->window = GTK_WINDOW (liferea_shell_lookup ("mainwindow"));
gtk_window_set_application (GTK_WINDOW (shell->priv->window), app);
/* 1.) menu creation */
debug0 (DEBUG_GUI, "Setting up menues");
shell->priv->itemlist = itemlist_create ();
/* Prepare some toggle button states */
conf_get_bool_value (REDUCED_FEEDLIST, &toggle);
liferea_shell_feedlist_toggle_entries[0].is_active = toggle;
ui_manager = gtk_ui_manager_new ();
shell->priv->generalActions = gtk_action_group_new ("GeneralActions");
gtk_action_group_set_translation_domain (shell->priv->generalActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->generalActions, liferea_shell_action_entries, G_N_ELEMENTS (liferea_shell_action_entries), shell->priv);
gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_action_toggle_entries, G_N_ELEMENTS (liferea_shell_action_toggle_entries), shell->priv);
gtk_action_group_add_radio_actions (shell->priv->generalActions, liferea_shell_view_radio_entries, G_N_ELEMENTS (liferea_shell_view_radio_entries), itemlist_get_view_mode (), (GCallback)on_view_activate, (gpointer)TRUE);
gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_feedlist_toggle_entries, G_N_ELEMENTS (liferea_shell_feedlist_toggle_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->generalActions, 0);
shell->priv->addActions = gtk_action_group_new ("AddActions");
gtk_action_group_set_translation_domain (shell->priv->addActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->addActions, liferea_shell_add_action_entries, G_N_ELEMENTS (liferea_shell_add_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->addActions, 0);
shell->priv->feedActions = gtk_action_group_new ("FeedActions");
gtk_action_group_set_translation_domain (shell->priv->feedActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->feedActions, liferea_shell_feed_action_entries, G_N_ELEMENTS (liferea_shell_feed_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->feedActions, 0);
shell->priv->readWriteActions = gtk_action_group_new("ReadWriteActions");
gtk_action_group_set_translation_domain (shell->priv->readWriteActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->readWriteActions, liferea_shell_read_write_action_entries, G_N_ELEMENTS (liferea_shell_read_write_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->readWriteActions, 0);
shell->priv->itemActions = gtk_action_group_new ("ItemActions");
gtk_action_group_set_translation_domain (shell->priv->itemActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->itemActions, liferea_shell_item_action_entries, G_N_ELEMENTS (liferea_shell_item_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->itemActions, 0);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (shell->priv->window), accel_group);
g_object_unref (accel_group);
g_signal_connect (gtk_accel_map_get (), "changed", G_CALLBACK (on_accel_change), NULL);
if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_ui_desc, -1, &error))
g_error ("building menus failed: %s", error->message);
if (gtk_widget_get_default_direction () != GTK_TEXT_DIR_RTL) {
if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_tb_desc, -1, &error))
g_error ("building menus failed: %s", error->message);
} else {
if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_tb_rtl_desc, -1, &error))
g_error ("building menus failed: %s", error->message);
}
shell->priv->menubar = gtk_ui_manager_get_widget (ui_manager, "/MainwindowMenubar");
shell->priv->toolbar = gtk_ui_manager_get_widget (ui_manager, "/maintoolbar");
/* Ensure GTK3 toolbar shadows... */
gtk_style_context_add_class (gtk_widget_get_style_context (shell->priv->toolbar), "primary-toolbar");
/* what a pain, why is there no markup for this option? */
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/newFeedButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/nextUnreadButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/MarkAsReadButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/UpdateAllButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/SearchButton")), "is_important", TRUE, NULL);
/* 2.) setup containers */
debug0 (DEBUG_GUI, "Setting up widget containers");
gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, 0);
gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, 0);
gtk_widget_show_all(GTK_WIDGET(shell->priv->toolbar));
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_press_event",
G_CALLBACK (on_key_press_event_null_cb), NULL);
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_release_event",
G_CALLBACK (on_key_press_event_null_cb), NULL);
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "scroll_event",
G_CALLBACK (on_notebook_scroll_event_null_cb), NULL);
g_signal_connect (G_OBJECT (shell->priv->window), "delete_event", G_CALLBACK(on_close), shell->priv);
g_signal_connect (G_OBJECT (shell->priv->window), "window_state_event", G_CALLBACK(on_window_state_event), shell->priv);
g_signal_connect (G_OBJECT (shell->priv->window), "key_press_event", G_CALLBACK(on_key_press_event), shell->priv);
/* 3.) setup status bar */
debug0 (DEBUG_GUI, "Setting up status bar");
shell->priv->statusbar = GTK_STATUSBAR (liferea_shell_lookup ("statusbar"));
shell->priv->statusbarLocked = FALSE;
shell->priv->statusbarLockTimer = 0;
shell->priv->statusbar_feedsinfo_evbox = gtk_event_box_new ();
shell->priv->statusbar_feedsinfo = gtk_label_new("");
gtk_container_add (GTK_CONTAINER (shell->priv->statusbar_feedsinfo_evbox), shell->priv->statusbar_feedsinfo);
gtk_widget_show_all (shell->priv->statusbar_feedsinfo_evbox);
gtk_box_pack_start (GTK_BOX (shell->priv->statusbar), shell->priv->statusbar_feedsinfo_evbox, FALSE, FALSE, 5);
g_signal_connect (G_OBJECT (shell->priv->statusbar_feedsinfo_evbox), "button_release_event", G_CALLBACK (on_next_unread_item_activate), NULL);
/* 4.) setup tabs */
debug0 (DEBUG_GUI, "Setting up tabbed browsing");
shell->priv->tabs = browser_tabs_create (GTK_NOTEBOOK (liferea_shell_lookup ("browsertabs")));
/* 5.) setup feed list */
debug0 (DEBUG_GUI, "Setting up feed list");
shell->priv->feedlistView = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist"));
feed_list_view_init (shell->priv->feedlistView);
/* 6.) setup menu sensivity */
debug0 (DEBUG_GUI, "Initialising menues");
/* On start, no item or feed is selected, so Item menu should be insensitive: */
liferea_shell_update_item_menu (FALSE);
/* necessary to prevent selection signals when filling the feed list
and setting the 2/3 pane mode view */
gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), FALSE);
/* 7.) setup item view */
debug0 (DEBUG_GUI, "Setting up item view");
shell->priv->itemview = itemview_create (GTK_WIDGET (shell->priv->window));
/* 8.) load icons as required */
debug0 (DEBUG_GUI, "Loading icons");
icons_load ();
/* 9.) update and restore all menu elements */
liferea_shell_update_toolbar ();
liferea_shell_update_history_actions ();
liferea_shell_setup_URL_receiver ();
liferea_shell_restore_state (overrideWindowState);
gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), TRUE);
/* 10.) After main window is realized get theme colors and set up feed
list and tray icon */
render_init_theme_colors (GTK_WIDGET (shell->priv->window));
shell->priv->feedlist = feedlist_create ();
g_signal_connect (shell->priv->feedlist, "new-items",
G_CALLBACK (liferea_shell_update_unread_stats), shell->priv->feedlist);
/* 11.) Restore latest selection */
// FIXME: Move to feed list code
if (conf_get_str_value (LAST_NODE_SELECTED, &id)) {
feed_list_view_select (node_from_id (id));
g_free (id);
}
/* 12. Setup shell plugins */
shell->priv->extensions = peas_extension_set_new (PEAS_ENGINE (liferea_plugins_engine_get_default ()),
LIFEREA_TYPE_SHELL_ACTIVATABLE, "shell", shell, NULL);
liferea_plugins_engine_set_default_signals (shell->priv->extensions, shell);
/* 14. Rebuild search folders if needed */
if (searchFolderRebuild)
vfolder_foreach (vfolder_rebuild);
debug_exit ("liferea_shell_create");
}
static void popup_menu (tilda_window *tw, tilda_term *tt)
{
DEBUG_FUNCTION ("popup_menu");
DEBUG_ASSERT (tw != NULL);
DEBUG_ASSERT (tt != NULL);
GtkAction *action;
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GError *error = NULL;
GtkWidget *menu;
/* Just use a static string here to initialize the GtkUIManager,
* rather than installing and reading from a file all the time. */
static const gchar menu_str[] =
"<ui>"
"<popup name=\"popup-menu\">"
"<menuitem action=\"new-tab\" />"
"<menuitem action=\"close-tab\" />"
"<separator />"
"<menuitem action=\"copy\" />"
"<menuitem action=\"paste\" />"
"<separator />"
"<menuitem action=\"fullscreen\" />"
"<separator />"
"<menuitem action=\"preferences\" />"
"<separator />"
"<menuitem action=\"quit\" />"
"</popup>"
"</ui>";
/* Create the action group */
action_group = gtk_action_group_new ("popup-menu-action-group");
/* Add Actions and connect callbacks */
action = gtk_action_new ("new-tab", _("_New Tab"), NULL, GTK_STOCK_ADD);
gtk_action_group_add_action_with_accel (action_group, action, config_getstr("addtab_key"));
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_add_tab_cb), tw);
action = gtk_action_new ("close-tab", _("_Close Tab"), NULL, GTK_STOCK_CLOSE);
gtk_action_group_add_action_with_accel (action_group, action, config_getstr("closetab_key"));
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_close_tab_cb), tw);
action = gtk_action_new ("copy", NULL, NULL, GTK_STOCK_COPY);
gtk_action_group_add_action_with_accel (action_group, action, config_getstr("copy_key"));
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_copy_cb), tt);
action = gtk_action_new ("paste", NULL, NULL, GTK_STOCK_PASTE);
gtk_action_group_add_action_with_accel (action_group, action, config_getstr("paste_key"));
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_paste_cb), tt);
action = gtk_action_new ("fullscreen", _("Toggle fullscreen"), NULL, NULL);
gtk_action_group_add_action (action_group, action);
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_fullscreen_cb), tw);
action = gtk_action_new ("preferences", NULL, NULL, GTK_STOCK_PREFERENCES);
gtk_action_group_add_action (action_group, action);
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_preferences_cb), tw);
action = gtk_action_new ("quit", NULL, NULL, GTK_STOCK_QUIT);
gtk_action_group_add_action_with_accel (action_group, action, config_getstr("quit_key"));
g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_quit_cb), tw);
/* Create and add actions to the GtkUIManager */
ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_string (ui_manager, menu_str, -1, &error);
/* Check for an error (REALLY REALLY unlikely, unless the developers screwed up */
if (error)
{
DEBUG_ERROR ("GtkUIManager problem\n");
g_printerr ("Error message: %s\n", error->message);
g_error_free (error);
}
/* Get the popup menu out of the GtkUIManager */
menu = gtk_ui_manager_get_widget (ui_manager, "/ui/popup-menu");
/* Disable auto hide */
tw->disable_auto_hide = TRUE;
g_signal_connect (G_OBJECT(menu), "unmap", G_CALLBACK(on_popup_hide), tw);
/* Display the menu */
gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time());
gtk_widget_show_all(menu);
}
int main (int argc, char **argv)
{
/**********************************************************************************/
/* DAEMON SETUP */
/* Our process ID and Session ID */
pid_t pid, sid;
/* Fork off the parent process */
pid = fork();
if (pid < 0)
exit(EXIT_FAILURE);
/* If we got a good PID, then
we can exit the parent process. */
if (pid > 0)
exit(EXIT_SUCCESS);
/* Change the file mode mask */
umask(0);
/* Open any logs here */
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0)
exit(EXIT_FAILURE);
/* Change the current working directory */
if ((chdir("/")) < 0)
exit(EXIT_FAILURE);
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/**********************************************************************************/
/* PROGRAM */
/* define variables gtk*/
GtkWidget *window;
GtkWidget *indicator_menu;
GtkActionGroup *action_group;
GtkUIManager *uim;
GError *error = NULL;
AppIndicator *indicator;
/* define custum variables */
int status = atoi(argv[1]);
/* gtk init with no args */
gtk_init (0, NULL);
/* main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Gnus Indicator");
g_signal_connect (G_OBJECT (window),
"destroy",
G_CALLBACK (gtk_main_quit),
NULL);
/* Menus */
action_group = gtk_action_group_new ("AppActions");
gtk_action_group_add_actions (action_group, entries, n_entries, window);
uim = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (uim, action_group, 0);
if (!gtk_ui_manager_add_ui_from_string (uim, ui_info, -1, &error))
{
g_message ("Failed to build menus: %s\n", error->message);
g_error_free (error);
error = NULL;
}
/* Indicator */
indicator_menu = gtk_ui_manager_get_widget (uim, "/ui/IndicatorPopup");
indicator = app_indicator_new ("example-simple-client",
"/usr/share/pixmaps/gnome-gnus.png",
APP_INDICATOR_CATEGORY_APPLICATION_STATUS);
app_indicator_set_attention_icon(indicator, "/usr/share/pixmaps/gnome-gnus-new.png");
app_indicator_set_menu (indicator, GTK_MENU (indicator_menu));
/* set status */
if(status == 0)
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE);
else if(status == 1)
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ATTENTION);
else
app_indicator_set_status (indicator, APP_INDICATOR_STATUS_PASSIVE);
gtk_main();
return 0;
}
int main ( int argc, char **argv )
{
int k;
GtkWidget *window, *child, *box, *menu, *subMenu;
GtkAction *action[2];
GtkUIManager *manager;
gtk_init ( &argc, &argv );
window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
box = gtk_vbox_new ( 0, 0 );
gtk_container_add ( GTK_CONTAINER ( window ), box );
/*
menuBar = gtk_menu_bar_new();
gtk_container_add( GTK_CONTAINER( box ), menuBar );
menu = gtk_menu_item_new_with_label( "Menu" );
gtk_container_add( GTK_CONTAINER( menuBar ), menu );
subMenu = gtk_menu_new();
gtk_menu_item_set_submenu( menu, subMenu );
*/
{
/*
actionGroup name -entries ... -toggleEntries ... -radioEntries
$name addEntries
$name addToggleEntries
$name addRadioEntries
*/
GtkActionGroup *action_group = gtk_action_group_new ( "MenuActions" );
gtk_action_group_add_actions ( action_group, entries,
G_N_ELEMENTS ( entries ), window );
gtk_action_group_add_toggle_actions ( action_group, toggle_entries,
G_N_ELEMENTS ( toggle_entries ), window );
gtk_action_group_add_radio_actions ( action_group, radio_entries,
G_N_ELEMENTS ( radio_entries ), 0, func1, window );
/*
uiManager addUI ui_description -groups $name
$manager addGroup
*/
manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group ( manager , action_group, 0 );
}
{
/*
$manager setAccelWindow window
*/
GtkAccelGroup *accel_group = gtk_ui_manager_get_accel_group ( manager );
gtk_window_add_accel_group ( GTK_WINDOW ( window ), accel_group );
}
{
/*
$manager setUiDescription xxx
*/
GError *error = NULL;
if ( !gtk_ui_manager_add_ui_from_string ( manager, ui_description, -1, &error ) )
{
g_message ( "building menus failed: %s", error->message );
g_error_free ( error );
exit ( 1 );
}
}
{
/*
$manager getWidget name
*/
GtkWidget *menuBar = gtk_ui_manager_get_widget ( manager, "/MainMenu" );
gtk_box_pack_start ( GTK_BOX ( box ), menuBar, FALSE, FALSE, 0 );
}
gtk_widget_show_all ( window );
/*
action[0] = GTK_ACTION( gtk_action_new( "name", "label", "tooltip", NULL ) );
action[1] = GTK_ACTION( gtk_action_new( "name2", "label2", "tooltip2", "gtk-quit" ) );
g_signal_connect( action[0], "activate", G_CALLBACK( func1 ), NULL);
g_signal_connect( action[1], "activate", G_CALLBACK( func2 ), NULL);
*/
/* accelGroup = gtk_accel_group_new(); */
#if 0
group = gtk_action_group_new ( "global" );
gtk_action_group_add_actions ( group, entries, 1, window );
manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group ( manager, group, 0 );
accelGroup = gtk_ui_manager_get_accel_group ( manager );
gtk_window_add_accel_group ( GTK_WINDOW ( window ), accelGroup );
for ( k = 0; k < 2; ++k )
{
child = gtk_action_create_menu_item ( action[k] );
gtk_container_add ( GTK_CONTAINER ( subMenu ), child );
child = gtk_action_create_tool_item ( action[k] );
gtk_container_add ( GTK_CONTAINER ( box ), child );
}
gtk_action_group_add_action_with_accel ( group, action[0], "<control>w" );
gtk_action_group_add_action_with_accel ( group, action[1], NULL );
#endif
gtk_widget_show_all ( window );
gtk_main();
return 0;
}
void
create_main_window (ProcData *procdata)
{
gint width, height;
GtkWidget *app;
GtkAction *action;
GtkWidget *menubar;
GtkWidget *main_box;
GtkWidget *notebook;
GtkWidget *tab_label1, *tab_label2, *tab_label3;
GtkWidget *vbox1;
GtkWidget *sys_box, *devices_box;
GtkWidget *sysinfo_box, *sysinfo_label;
app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(app), _("System Monitor"));
GdkScreen* screen = gtk_widget_get_screen(app);
GdkColormap* colormap = gdk_screen_get_rgba_colormap(screen);
/* use rgba colormap, if available */
if (colormap)
gtk_widget_set_default_colormap(colormap);
main_box = gtk_vbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(app), main_box);
width = procdata->config.width;
height = procdata->config.height;
gtk_window_set_default_size (GTK_WINDOW (app), width, height);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
/* create the menubar */
procdata->uimanager = gtk_ui_manager_new ();
/* show tooltips in the statusbar */
g_signal_connect (procdata->uimanager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), procdata);
g_signal_connect (procdata->uimanager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), procdata);
gtk_window_add_accel_group (GTK_WINDOW (app),
gtk_ui_manager_get_accel_group (procdata->uimanager));
if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager,
ui_info,
-1,
NULL)) {
g_error("building menus failed");
}
procdata->action_group = gtk_action_group_new ("ProcmanActions");
gtk_action_group_set_translation_domain (procdata->action_group, NULL);
gtk_action_group_add_actions (procdata->action_group,
menu_entries,
G_N_ELEMENTS (menu_entries),
procdata);
gtk_action_group_add_toggle_actions (procdata->action_group,
toggle_menu_entries,
G_N_ELEMENTS (toggle_menu_entries),
procdata);
gtk_action_group_add_radio_actions (procdata->action_group,
radio_menu_entries,
G_N_ELEMENTS (radio_menu_entries),
procdata->config.whose_process,
G_CALLBACK(cb_radio_processes),
procdata);
gtk_ui_manager_insert_action_group (procdata->uimanager,
procdata->action_group,
0);
menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
/* create the main notebook */
procdata->notebook = notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (main_box),
notebook,
TRUE,
TRUE,
0);
sysinfo_box = gtk_hbox_new(TRUE, 0); // procman_create_sysinfo_view();
sysinfo_label = gtk_label_new(_("System"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label);
vbox1 = create_proc_view (procdata);
tab_label1 = gtk_label_new (_("Processes"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1);
sys_box = create_sys_view (procdata);
tab_label2 = gtk_label_new (_("Resources"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2);
devices_box = create_disk_view (procdata);
tab_label3 = gtk_label_new (_("File Systems"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3);
g_signal_connect (G_OBJECT (notebook), "switch-page",
G_CALLBACK (cb_switch_page), procdata);
g_signal_connect (G_OBJECT (notebook), "change-current-page",
G_CALLBACK (cb_change_current_page), procdata);
gtk_widget_show_all(notebook); // need to make page switch work
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab);
cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata);
g_signal_connect (G_OBJECT (app), "delete_event",
G_CALLBACK (cb_app_delete),
procdata);
/* create the statusbar */
procdata->statusbar = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0);
procdata->tip_message_cid = gtk_statusbar_get_context_id
(GTK_STATUSBAR (procdata->statusbar), "tip_message");
action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
procdata->config.show_tree);
gtk_widget_show_all(app);
procdata->app = app;
}
/**
* nemo_window_initialize_menus
*
* Create and install the set of menus for this window.
* @window: A recently-created NemoWindow.
*/
void
nemo_window_initialize_menus (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAction *action;
gint i;
if (window->details->ui_manager == NULL){
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);
gtk_action_group_add_radio_actions (action_group,
main_radio_entries, G_N_ELEMENTS (main_radio_entries),
0, G_CALLBACK (sidebar_radio_entry_changed_cb),
window);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_UP);
g_object_set (action, "short_label", _("_Up"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_HOME);
g_object_set (action, "short_label", _("_Home"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_EDIT_LOCATION);
g_object_set (action, "short_label", _("_Location"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_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 (nemo_preferences, NEMO_PREFERENCES_SHOW_HIDDEN_FILES));
g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window);
g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_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);
g_signal_connect (ui_manager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), window);
/* add the UI */
gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/nemo/nemo-shell-ui.xml", NULL);
nemo_window_initialize_trash_icon_monitor (window);
nemo_window_initialize_go_menu (window);
}
int lassi_tray_init(LassiTrayInfo *i, LassiServer *server) {
GtkActionEntry entries[] =
{
#if GTK_CHECK_VERSION(2,14,0)
{"Help", GTK_STOCK_HELP, NULL,
NULL, NULL,
G_CALLBACK (on_help_activate)},
#endif
{"Preferences", GTK_STOCK_PREFERENCES, NULL,
NULL, NULL,
G_CALLBACK (on_prefs_activate)},
{"Quit", GTK_STOCK_QUIT, NULL,
NULL, NULL,
G_CALLBACK (gtk_main_quit)}
};
GtkActionGroup *actions;
GError *error = NULL;
g_assert(i);
g_assert(server);
memset(i, 0, sizeof(*i));
i->server = server;
notify_init("Mango Lassi");
i->status_icon = gtk_status_icon_new_from_icon_name(ICON_IDLE);
i->ui_manager = gtk_ui_manager_new ();
actions = gtk_action_group_new ("mango-lassi-popup");
gtk_action_group_add_actions (actions,
entries,
G_N_ELEMENTS (entries),
i);
gtk_ui_manager_insert_action_group (i->ui_manager, actions, -1);
gtk_ui_manager_add_ui_from_string (i->ui_manager,
"<popup>"
"<menuitem action='Preferences'/>"
#if GTK_CHECK_VERSION(2,14,0)
"<menuitem action='Help'/>"
#endif
"<separator />"
"<menuitem action='Quit'/>"
"</popup>",
-1,
&error);
if (error) {
GtkWidget* dialog = gtk_message_dialog_new (NULL, 0,
GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
"%s", _("Initialization Error"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("Cannot initialize the user interface: %s"),
error->message);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
return 1;
}
i->menu = gtk_ui_manager_get_widget (i->ui_manager, "/ui/popup");
g_signal_connect(G_OBJECT(i->status_icon), "popup_menu", G_CALLBACK(on_tray_popup_menu), i);
g_signal_connect(G_OBJECT(i->status_icon), "activate", G_CALLBACK(on_tray_activate), i);
lassi_tray_update(i, 0);
return 0;
}
GtkWidget *
alleyoop_new (ValgrindTool tool, const char **argv, const char **srcdir)
{
GtkWidget *menubar, *widget, *vbox;
GtkActionGroup *actions;
GtkAccelGroup *accels;
GError *err = NULL;
Alleyoop *grind;
char *title;
int i;
grind = g_object_new (ALLEYOOP_TYPE, NULL);
if (argv && argv[0] != NULL)
title = g_strdup_printf ("Alleyoop - [%s]", argv[0]);
else
title = g_strdup ("Alleyoop");
//gnome_app_construct ((GnomeApp *) grind, "alleyoop", title);
gtk_window_set_title ((GtkWindow *) grind, title);
gtk_window_set_default_size ((GtkWindow *) grind, 300, 400);
g_free (title);
grind->tool = tool;
grind->argv = argv;
grind->srcdir = srcdir;
vbox = gtk_vbox_new (FALSE, 0);
/* construct the menus */
grind->ui = gtk_ui_manager_new ();
actions = gtk_action_group_new ("MenuActions");
gtk_action_group_add_actions (actions, normal_menu_items, G_N_ELEMENTS (normal_menu_items), grind);
gtk_action_group_add_radio_actions (actions, radio_menu_items, G_N_ELEMENTS (radio_menu_items), tool,
G_CALLBACK (tool_selected_cb), grind);
gtk_ui_manager_insert_action_group (grind->ui, actions, 0);
accels = gtk_ui_manager_get_accel_group (grind->ui);
gtk_window_add_accel_group ((GtkWindow *) grind, accels);
if (!gtk_ui_manager_add_ui_from_string (grind->ui, menu_xml, -1, &err)) {
g_message ("Building menus failed: %s", err->message);
g_error_free (err);
exit (EXIT_FAILURE);
}
menubar = gtk_ui_manager_get_widget (grind->ui, "/MainMenu");
gtk_widget_show (menubar);
/* pack in the menubar */
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
widget = alleyoop_toolbar_new (grind);
gtk_widget_set_sensitive (grind->toolbar_run, TRUE);
gtk_widget_set_sensitive (grind->toolbar_kill, FALSE);
gtk_widget_show (widget);
/* pack in the toolbar */
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
grind->view = widget = vg_default_view_new ();
vg_tool_view_set_argv ((VgToolView *) widget, argv);
vg_tool_view_set_srcdir ((VgToolView *) widget, srcdir);
gtk_widget_show (widget);
/* pack in the view */
gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
/* create the prefs dialog (we just don't display it) */
grind->prefs = alleyoop_prefs_new ();
g_signal_connect (grind->prefs, "response", G_CALLBACK (prefs_response_cb), grind);
g_signal_connect (grind->prefs, "delete-event", G_CALLBACK (prefs_delete_event), grind);
gtk_widget_show (vbox);
gtk_container_add ((GtkContainer *) grind, vbox);
return (GtkWidget *) grind;
}
static void
mail_browser_constructed (GObject *object)
{
EMailBrowser *browser;
EMailReader *reader;
EMailBackend *backend;
EMailSession *session;
EShellBackend *shell_backend;
EShell *shell;
EFocusTracker *focus_tracker;
GtkAccelGroup *accel_group;
GtkActionGroup *action_group;
GtkAction *action;
GtkUIManager *ui_manager;
GtkWidget *container;
GtkWidget *display;
GtkWidget *widget;
const gchar *domain;
const gchar *id;
guint merge_id;
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_mail_browser_parent_class)->constructed (object);
browser = E_MAIL_BROWSER (object);
reader = E_MAIL_READER (object);
backend = e_mail_reader_get_backend (reader);
session = e_mail_backend_get_session (backend);
shell_backend = E_SHELL_BACKEND (backend);
shell = e_shell_backend_get_shell (shell_backend);
ui_manager = gtk_ui_manager_new ();
browser->priv->ui_manager = ui_manager;
domain = GETTEXT_PACKAGE;
gtk_application_add_window (
GTK_APPLICATION (shell), GTK_WINDOW (object));
/* The message list is a widget, but it is not shown in the browser.
* Unfortunately, the widget is inseparable from its model, and the
* model is all we need. */
browser->priv->message_list = message_list_new (session);
g_object_ref_sink (browser->priv->message_list);
g_signal_connect_swapped (
browser->priv->message_list, "message-selected",
G_CALLBACK (mail_browser_message_selected_cb), object);
g_signal_connect_swapped (
browser->priv->message_list, "message-list-built",
G_CALLBACK (mail_browser_message_list_built_cb), object);
display = e_mail_display_new (e_mail_backend_get_remote_content (backend));
e_mail_display_set_mode (
E_MAIL_DISPLAY (display),
browser->priv->display_mode);
g_signal_connect_swapped (
display, "popup-event",
G_CALLBACK (mail_browser_popup_event_cb), object);
g_signal_connect_swapped (
display, "status-message",
G_CALLBACK (mail_browser_status_message_cb), object);
widget = e_preview_pane_new (E_WEB_VIEW (display));
browser->priv->preview_pane = g_object_ref (widget);
gtk_widget_show (widget);
action_group = gtk_action_group_new (ACTION_GROUP_STANDARD);
gtk_action_group_set_translation_domain (action_group, domain);
gtk_action_group_add_actions (
action_group, mail_browser_entries,
G_N_ELEMENTS (mail_browser_entries), object);
e_action_group_add_popup_actions (
action_group, mail_browser_popup_entries,
G_N_ELEMENTS (mail_browser_popup_entries));
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* For easy access. Takes ownership of the reference. */
g_object_set_data_full (
object, ACTION_GROUP_STANDARD,
action_group, (GDestroyNotify) g_object_unref);
action_group = gtk_action_group_new (ACTION_GROUP_SEARCH_FOLDERS);
gtk_action_group_set_translation_domain (action_group, domain);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* For easy access. Takes ownership of the reference. */
g_object_set_data_full (
object, ACTION_GROUP_SEARCH_FOLDERS,
action_group, (GDestroyNotify) g_object_unref);
e_mail_reader_init (reader, TRUE, TRUE);
e_load_ui_manager_definition (ui_manager, E_MAIL_READER_UI_DEFINITION);
gtk_ui_manager_add_ui_from_string (ui_manager, ui, -1, NULL);
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
e_mail_reader_create_charset_menu (reader, ui_manager, merge_id);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (object), accel_group);
g_signal_connect_swapped (
ui_manager, "connect-proxy",
G_CALLBACK (mail_browser_connect_proxy_cb), object);
e_mail_reader_connect_remote_content (reader);
/* Configure an EFocusTracker to manage selection actions. */
focus_tracker = e_focus_tracker_new (GTK_WINDOW (object));
action = e_mail_reader_get_action (reader, "cut-clipboard");
e_focus_tracker_set_cut_clipboard_action (focus_tracker, action);
action = e_mail_reader_get_action (reader, "copy-clipboard");
e_focus_tracker_set_copy_clipboard_action (focus_tracker, action);
action = e_mail_reader_get_action (reader, "paste-clipboard");
e_focus_tracker_set_paste_clipboard_action (focus_tracker, action);
action = e_mail_reader_get_action (reader, "select-all");
e_focus_tracker_set_select_all_action (focus_tracker, action);
browser->priv->focus_tracker = focus_tracker;
/* Construct window widgets. */
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (object), widget);
gtk_widget_show (widget);
container = widget;
widget = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0);
browser->priv->statusbar = g_object_ref (widget);
gtk_widget_show (widget);
widget = gtk_ui_manager_get_widget (ui_manager, "/main-menu");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
browser->priv->main_menu = g_object_ref (widget);
gtk_widget_show (widget);
widget = gtk_ui_manager_get_widget (ui_manager, "/main-toolbar");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
browser->priv->main_toolbar = g_object_ref (widget);
gtk_widget_show (widget);
gtk_style_context_add_class (
gtk_widget_get_style_context (widget),
GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_box_pack_start (
GTK_BOX (container),
browser->priv->preview_pane,
TRUE, TRUE, 0);
id = "org.gnome.evolution.mail.browser";
e_plugin_ui_register_manager (ui_manager, id, object);
e_plugin_ui_enable_manager (ui_manager, id);
e_extensible_load_extensions (E_EXTENSIBLE (object));
}
static VALUE
rg_initialize(VALUE self)
{
G_INITIALIZE(self, gtk_ui_manager_new());
return Qnil;
}
static gboolean
analyzer_ui_init (void)
{
GtkActionGroup *action_group;
char *path;
ui = g_slice_new0 (AnalyzerUI);
path =
g_build_filename (DATADIR, "codecanalyzer", "ui", "mainwindow.xml", NULL);
ui->builder = make_builder (path);
g_free (path);
ui->main_window =
get_widget_from_builder (ui->builder, "Codecanalyzer-main-window");
ui->main_vbox = get_widget_from_builder (ui->builder, "MainVBox");
ui->child_vbox1 = get_widget_from_builder (ui->builder, "child_vbox1");
ui->child_vbox2 = get_widget_from_builder (ui->builder, "child_vbox2");
ui->child_vbox3 = get_widget_from_builder (ui->builder, "child_vbox3");
ui->menubar_vbox = get_widget_from_builder (ui->builder, "menubar_vbox");
ui->stream_chooser = get_widget_from_builder (ui->builder, "StreamChooser");
ui->numframes_chooser =
get_widget_from_builder (ui->builder, "NumFrameEntryButton");
ui->analyze_button = get_widget_from_builder (ui->builder, "AnalyzeButton");
ui->cancel_button = get_widget_from_builder (ui->builder, "CancelButton");
ui->hbox1_in_vbox2 = get_widget_from_builder (ui->builder, "hbox1_in_vbox2");
ui->child_hbox_in_vbox1_2 = get_widget_from_builder (ui->builder,
"child_hbox_in_vbox1_2");
ui->thumbnails_scroll_window =
get_widget_from_builder (ui->builder, "thumbnails_scrolled_window");
ui->thumbnails_view_port =
get_widget_from_builder (ui->builder, "thumbnails_view_port");
ui->general_info_frame =
get_widget_from_builder (ui->builder, "general_info_frame");
ui->general_info_vbox =
get_widget_from_builder (ui->builder, "general_info_vbox");
ui->general_info_treeview =
get_widget_from_builder (ui->builder, "general_info_treeview");
ui->parsed_info_hbox =
get_widget_from_builder (ui->builder, "parsed_info_hbox");
ui->parsed_info_vbox =
get_widget_from_builder (ui->builder, "parsed_info_vbox");
ui->parsed_info_frame =
get_widget_from_builder (ui->builder, "parsed_info_frame");
ui->parsed_info_button_box =
get_widget_from_builder (ui->builder, "parsed_info_button_box");
/* Create menu */
action_group = gtk_action_group_new ("ActionGroup");
gtk_action_group_add_actions (action_group, entries_actiongroup,
G_N_ELEMENTS (entries_actiongroup), NULL);
ui->menu_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui->menu_manager, action_group, 0);
path = g_build_filename (DATADIR, "codecanalyzer", "ui", "menu.xml", NULL);
gtk_ui_manager_add_ui_from_file (ui->menu_manager, path, NULL);
g_free (path);
ui->menubar = gtk_ui_manager_get_widget (ui->menu_manager, "/MainMenu");
gtk_box_pack_start (GTK_BOX (ui->menubar_vbox), ui->menubar, FALSE, FALSE, 0);
gtk_window_add_accel_group (GTK_WINDOW (ui->main_window),
gtk_ui_manager_get_accel_group (ui->menu_manager));
ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal);
ui->prev_page = NULL;
ui->num_frames = 0;
gtk_window_maximize (GTK_WINDOW (ui->main_window));
path =
g_build_filename (DATADIR, "codecanalyzer", "pixmaps",
"codecanalyzer-logo.png", NULL);
if (!gtk_window_set_icon_from_file (GTK_WINDOW (ui->main_window), path, NULL))
g_warning ("Failed to load the icon image.. ");
g_free (path);
return TRUE;
}
static GtkWidget *
normal_contents (void)
{
GtkWidget *grid;
GtkWidget *statusbar;
GtkWidget *contents;
GtkWidget *sw;
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
grid = gtk_grid_new ();
/* Create the menubar
*/
action_group = gtk_action_group_new ("mainmenu");
gtk_action_group_add_actions (action_group,
menu_items,
G_N_ELEMENTS (menu_items),
NULL);
gtk_action_group_add_actions (action_group,
tool_items,
G_N_ELEMENTS (tool_items),
NULL);
ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* create menu items */
gtk_ui_manager_add_ui_from_string (ui_manager, menu_item_string, -1, NULL);
gtk_grid_attach (GTK_GRID (grid),
gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"),
0, 0, 1, 1);
gtk_widget_set_hexpand (gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"),
TRUE);
/* Create the toolbar
*/
gtk_grid_attach (GTK_GRID (grid),
gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar"),
0, 1, 1, 1);
gtk_widget_set_hexpand (gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar"),
TRUE);
/* Create document
*/
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_grid_attach (GTK_GRID (grid),
sw,
0, 2, 1, 1);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
contents = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
PANGO_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar */
statusbar = gtk_statusbar_new ();
gtk_grid_attach (GTK_GRID (grid),
statusbar,
0, 3, 1, 1);
gtk_widget_set_hexpand (statusbar, TRUE);
gtk_widget_show_all (grid);
g_object_unref (ui_manager);
return grid;
}
static void
populate_window(ChmSee *self)
{
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
GladeXML *glade;
glade = glade_xml_new(get_resource_path(GLADE_FILE), "main_vbox", NULL);
if (glade == NULL) {
g_error("Cannot find glade file!");
exit(1);
}
g_object_set_data(G_OBJECT (self), "glade", glade);
GtkWidget *main_vbox;
main_vbox = get_widget(self, "main_vbox");
gtk_container_add(GTK_CONTAINER (self), vbox);
GtkActionGroup* action_group = gtk_action_group_new ("MenuActions");
selfp->action_group = action_group;
gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), self);
gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), self);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "NewTab"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "CloseTab"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Home"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Back"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Forward"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "SidePane"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomIn"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomOut"), FALSE);
gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomReset"), FALSE);
GtkUIManager* ui_manager = gtk_ui_manager_new ();
selfp->ui_manager = ui_manager;
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
GtkAccelGroup* accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (self), accel_group);
GError* error = NULL;
if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, &error))
{
g_message ("building menus failed: %s", error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
GtkWidget* menubar = gtk_handle_box_new();
selfp->menubar = menubar;
gtk_container_add(GTK_CONTAINER(menubar), gtk_ui_manager_get_widget (ui_manager, "/MainMenu"));
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
GtkWidget* toolbar = gtk_handle_box_new();
selfp->toolbar = toolbar;
gtk_container_add(GTK_CONTAINER(toolbar), gtk_ui_manager_get_widget(ui_manager, "/toolbar"));
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
GtkWidget* ui_chmfile = chmsee_ui_chmfile_new();
selfp->ui_chmfile = ui_chmfile;
gtk_box_pack_start(GTK_BOX(vbox), ui_chmfile, TRUE, TRUE, 0);
gtk_container_set_focus_child(GTK_CONTAINER(vbox), ui_chmfile);
g_signal_connect_swapped(ui_chmfile,
"model_changed",
G_CALLBACK(on_ui_chmfile_model_changed),
self);
g_signal_connect_swapped(ui_chmfile,
"html_changed",
G_CALLBACK(on_ui_chmfile_html_changed),
self);
g_signal_connect_swapped(ui_chmfile,
"notify::link-message",
G_CALLBACK(on_ui_chmfile_html_link_message_notify),
self);
gtk_tool_button_set_icon_widget(
GTK_TOOL_BUTTON(gtk_ui_manager_get_widget(ui_manager, "/toolbar/sidepane")),
gtk_image_new_from_file(get_resource_path("show-pane.png")));
gtk_box_pack_start (GTK_BOX (vbox), main_vbox, FALSE, FALSE, 0);
gtk_widget_show_all(vbox);
accel_group = g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW (self), accel_group);
/* status bar */
selfp->statusbar = glade_xml_get_widget(glade, "statusbar");
selfp->scid_default = gtk_statusbar_get_context_id(GTK_STATUSBAR (selfp->statusbar),
"default");
update_status_bar(self, _("Ready!"));
}
/**
* 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);
gtk_action_group_add_radio_actions (action_group,
view_radio_entries, G_N_ELEMENTS (view_radio_entries),
-1, G_CALLBACK (action_view_radio_changed),
window);
action = nautilus_option_menu_action_new ("Zoom Options",
_("Zoom"), _("Zoom Options"), NULL);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
nautilus_window_menus_set_visibility_for_app_menu (window);
window->details->app_menu_visibility_id =
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);
/* 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);
/* set actions for option menu items */
populate_option_menu_items (window);
}
static GtkWidget *
normal_contents (void)
{
GtkWidget *table;
GtkWidget *handlebox;
GtkWidget *statusbar;
GtkWidget *contents;
GtkWidget *sw;
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
table = gtk_table_new (1, 4, FALSE);
/* Create the menubar
*/
action_group = gtk_action_group_new ("mainmenu");
gtk_action_group_add_actions (action_group,
menu_items,
G_N_ELEMENTS (menu_items),
NULL);
gtk_action_group_add_actions (action_group,
tool_items,
G_N_ELEMENTS (tool_items),
NULL);
ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* create menu items */
gtk_ui_manager_add_ui_from_string (ui_manager, menu_item_string, -1, NULL);
gtk_table_attach (GTK_TABLE (table),
gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"),
/* X direction */ /* Y direction */
0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
handlebox = gtk_handle_box_new ();
gtk_container_add (GTK_CONTAINER (handlebox),
gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar"));
gtk_table_attach (GTK_TABLE (table),
handlebox,
/* X direction */ /* Y direction */
0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Create document
*/
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_table_attach (GTK_TABLE (table),
sw,
/* X direction */ /* Y direction */
0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
contents = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
PANGO_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar */
statusbar = gtk_statusbar_new ();
gtk_table_attach (GTK_TABLE (table),
statusbar,
/* X direction */ /* Y direction */
0, 1, 3, 4,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
gtk_widget_show_all (table);
g_object_unref (ui_manager);
return table;
}
void
create_main_window (ProcData *procdata)
{
gint i;
gint width, height, xpos, ypos;
GtkWidget *app;
GtkAction *action;
GtkWidget *menubar;
GtkWidget *main_box;
GtkWidget *notebook;
GtkWidget *tab_label1, *tab_label2, *tab_label3;
GtkWidget *vbox1;
GtkWidget *sys_box, *devices_box;
GtkWidget *sysinfo_box, *sysinfo_label;
app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(app), _("System Monitor"));
GdkScreen* screen = gtk_widget_get_screen(app);
/* use visual, if available */
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
if (visual)
gtk_widget_set_visual(app, visual);
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(app), main_box);
width = procdata->config.width;
height = procdata->config.height;
xpos = procdata->config.xpos;
ypos = procdata->config.ypos;
gtk_window_set_default_size (GTK_WINDOW (app), width, height);
gtk_window_move(GTK_WINDOW (app), xpos, ypos);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
if (procdata->config.maximized) {
gtk_window_maximize(GTK_WINDOW(app));
}
/* create the menubar */
procdata->uimanager = gtk_ui_manager_new ();
/* show tooltips in the statusbar */
g_signal_connect (procdata->uimanager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), procdata);
g_signal_connect (procdata->uimanager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), procdata);
gtk_window_add_accel_group (GTK_WINDOW (app),
gtk_ui_manager_get_accel_group (procdata->uimanager));
if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager,
ui_info,
-1,
NULL)) {
g_error("building menus failed");
}
procdata->action_group = gtk_action_group_new ("ProcmanActions");
gtk_action_group_set_translation_domain (procdata->action_group, NULL);
gtk_action_group_add_actions (procdata->action_group,
menu_entries,
G_N_ELEMENTS (menu_entries),
procdata);
gtk_action_group_add_toggle_actions (procdata->action_group,
toggle_menu_entries,
G_N_ELEMENTS (toggle_menu_entries),
procdata);
gtk_action_group_add_radio_actions (procdata->action_group,
radio_menu_entries,
G_N_ELEMENTS (radio_menu_entries),
procdata->config.whose_process,
G_CALLBACK(cb_radio_processes),
procdata);
gtk_action_group_add_radio_actions (procdata->action_group,
priority_menu_entries,
G_N_ELEMENTS (priority_menu_entries),
NORMAL_PRIORITY,
G_CALLBACK(cb_renice),
procdata);
gtk_ui_manager_insert_action_group (procdata->uimanager,
procdata->action_group,
0);
menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
/* create the main notebook */
procdata->notebook = notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (main_box), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 12);
sysinfo_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); // procman_create_sysinfo_view();
sysinfo_label = gtk_label_new(_("System"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label);
vbox1 = create_proc_view (procdata);
tab_label1 = gtk_label_new (_("Processes"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1);
sys_box = create_sys_view (procdata);
tab_label2 = gtk_label_new (_("Resources"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2);
devices_box = create_disk_view (procdata);
tab_label3 = gtk_label_new (_("File Systems"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3);
g_signal_connect (G_OBJECT (notebook), "switch-page",
G_CALLBACK (cb_switch_page), procdata);
g_signal_connect (G_OBJECT (notebook), "change-current-page",
G_CALLBACK (cb_change_current_page), procdata);
gtk_widget_show_all(notebook); // need to make page switch work
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab);
cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata);
g_signal_connect (G_OBJECT (app), "delete_event",
G_CALLBACK (cb_app_delete),
procdata);
GtkAccelGroup *accel_group;
GClosure *goto_tab_closure[4];
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW(app), accel_group);
for (i = 0; i < 4; ++i) {
goto_tab_closure[i] = g_cclosure_new_swap (G_CALLBACK (cb_proc_goto_tab),
GINT_TO_POINTER (i), NULL);
gtk_accel_group_connect (accel_group, '0'+(i+1),
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE,
goto_tab_closure[i]);
}
/* create the statusbar */
procdata->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0);
procdata->tip_message_cid = gtk_statusbar_get_context_id
(GTK_STATUSBAR (procdata->statusbar), "tip_message");
action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
procdata->config.show_tree);
gtk_widget_show_all(app);
procdata->app = app;
}
GtkWidget *init_menus ( GtkWidget *vbox )
{
GtkWidget *menubar;
GtkActionGroup *actions;
/* remind of GtkActionEntry : name, stock_id, label, accelerator, tooltip, callback */
GtkActionEntry entries[] =
{
/* File menu */
{"FileMenuAction", NULL, _("_File"), NULL, NULL, NULL},
#ifdef GTKOSXAPPLICATION
{ "NewAction", GTK_STOCK_NEW, _("_New account file..."), "<Meta>N", NULL,
G_CALLBACK ( gsb_file_new ) },
{"OpenAction", GTK_STOCK_OPEN, _("_Open..."), "<Meta>O", NULL,
G_CALLBACK ( gsb_file_open_menu ) },
{"RecentFilesAction", NULL, _("_Recently opened files"), NULL, NULL, NULL },
{"SaveAction", GTK_STOCK_SAVE, _("_Save"), "<Meta>S", NULL,
G_CALLBACK ( gsb_file_save ) },
#else
{ "NewAction", GTK_STOCK_NEW, _("_New account file..."), NULL, NULL,
G_CALLBACK ( gsb_file_new ) },
{"OpenAction", GTK_STOCK_OPEN, _("_Open..."), NULL, NULL,
G_CALLBACK ( gsb_file_open_menu ) },
{"RecentFilesAction", NULL, _("_Recently opened files"), NULL, NULL, NULL },
{"SaveAction", GTK_STOCK_SAVE, _("_Save"), NULL, NULL,
G_CALLBACK ( gsb_file_save ) },
#endif
{"SaveAsAction", GTK_STOCK_SAVE_AS, _("_Save as..."), NULL, NULL,
G_CALLBACK ( gsb_file_save_as ) },
{"ImportFileAction", GTK_STOCK_CONVERT, _("_Import file..."), NULL, NULL,
G_CALLBACK ( importer_fichier ) },
{ "ExportFileAction", GTK_STOCK_CONVERT, _("_Export accounts as QIF/CSV file..."), NULL, NULL,
G_CALLBACK ( export_accounts ) },
{"CreateArchiveAction", GTK_STOCK_CLEAR, _("Archive transactions..."), NULL, NULL,
G_CALLBACK ( gsb_assistant_archive_run_by_menu ) },
{"ExportArchiveAction", GTK_STOCK_HARDDISK, _("_Export an archive as GSB/QIF/CSV file..."), NULL, NULL,
G_CALLBACK ( gsb_assistant_archive_export_run ) },
{"DebugFileAction", GTK_STOCK_FIND, _("_Debug account file..."), "", NULL,
G_CALLBACK ( gsb_debug ) },
{"ObfuscateAction", GTK_STOCK_FIND, _("_Obfuscate account file..."), "", NULL,
G_CALLBACK ( file_obfuscate_run ) },
{"ObfuscateQifAction", GTK_STOCK_FIND, _("_Obfuscate QIF file..."), "", NULL,
G_CALLBACK ( file_obfuscate_qif_run ) },
#ifdef GTKOSXAPPLICATION
{"CloseAction", GTK_STOCK_CLOSE, _("_Close"), "<Meta>W", NULL,
G_CALLBACK ( gsb_file_close ) },
#else
{"CloseAction", GTK_STOCK_CLOSE, _("_Close"), NULL, NULL,
G_CALLBACK ( gsb_file_close ) },
#endif
{"QuitAction", GTK_STOCK_QUIT, _("_Quit"), NULL, NULL,
G_CALLBACK ( gsb_main_grisbi_close ) },
/* Editmenu */
{"EditMenuAction", NULL, _("_Edit"), NULL, NULL, NULL },
{"EditTransactionAction", GTK_STOCK_EDIT, _("_Edit transaction"), "", NULL,
G_CALLBACK ( gsb_data_mix_edit_current_transaction ) },
{"NewTransactionAction", GTK_STOCK_NEW, _("_New transaction"), "", NULL,
G_CALLBACK ( gsb_data_mix_new_transaction_by_menu ) },
{"RemoveTransactionAction", GTK_STOCK_DELETE, _("_Remove transaction"), "", NULL,
G_CALLBACK ( gsb_data_mix_delete_current_transaction ) },
{"TemplateTransactionAction", GTK_STOCK_COPY, _("Use selected transaction as a template"), "", NULL,
G_CALLBACK ( gsb_transactions_list_clone_template ) },
{"CloneTransactionAction", GTK_STOCK_COPY, _("_Clone transaction"), "", NULL,
G_CALLBACK ( gsb_data_mix_clone_current_transaction ) },
{"ConvertToScheduledAction", GTK_STOCK_CONVERT, _("Convert to _scheduled transaction"), NULL, NULL,
G_CALLBACK ( schedule_selected_transaction ) },
{"MoveToAnotherAccountAction", NULL, _("_Move transaction to another account"), NULL, NULL, NULL },
{"NewAccountAction", GTK_STOCK_NEW, _("_New account"), "", NULL,
G_CALLBACK ( gsb_assistant_account_run ) },
{"RemoveAccountAction", GTK_STOCK_DELETE, _("_Remove current account"), "", NULL,
G_CALLBACK ( gsb_account_delete ) },
{"PrefsAction", GTK_STOCK_PREFERENCES, _("_Preferences"), NULL, NULL,
G_CALLBACK ( preferences ) },
/* View menu */
{"ViewMenuAction", NULL, _("_View"), NULL, NULL, NULL },
{"InitwidthColAction", NULL, _("Reset the column width"), NULL, NULL,
G_CALLBACK ( gsb_menu_reinit_largeur_col_menu ) },
/* Help menu */
{"HelpMenuAction", NULL, _("_Help"), NULL, NULL, NULL },
#ifdef GTKOSXAPPLICATION
{"ManualAction", GTK_STOCK_HELP, _("_Manual"), "<Meta>H", NULL,
G_CALLBACK ( help_manual ) },
#else
{"ManualAction", GTK_STOCK_HELP, _("_Manual"), NULL, NULL,
G_CALLBACK ( help_manual ) },
#endif
{"QuickStartAction", NULL, _("_Quick start"), NULL, NULL,
G_CALLBACK ( help_quick_start ) },
{"TranslationAction", NULL, _("_Translation"), NULL, NULL,
G_CALLBACK ( help_translation ) },
{"AboutAction", GTK_STOCK_ABOUT, _("_About Grisbi..."), NULL, NULL,
G_CALLBACK ( a_propos ) },
{"GrisbiWebsiteAction", NULL, _("_Grisbi website"), NULL, NULL,
G_CALLBACK ( help_website ) },
{"ReportBugAction", NULL, _("_Report a bug"), NULL, NULL,
G_CALLBACK ( help_bugreport ) },
{"TipAction", GTK_STOCK_DIALOG_INFO, _("_Tip of the day"), NULL, NULL,
G_CALLBACK ( force_display_tip ) },
};
GtkRadioActionEntry radio_entries[] =
{
/* Name, StockID, Label, Accelerator, Tooltip, Value */
{"ShowOneLineAction", NULL, _("Show _one line per transaction"), NULL, NULL,
ONE_LINE_PER_TRANSACTION },
{"ShowTwoLinesAction", NULL, _("Show _two lines per transaction"), NULL, NULL,
TWO_LINES_PER_TRANSACTION },
{"ShowThreeLinesAction", NULL, _("Show _three lines per transaction"), NULL, NULL,
THREE_LINES_PER_TRANSACTION },
{"ShowFourLinesAction", NULL, _("Show _four lines per transaction"), NULL, NULL,
FOUR_LINES_PER_TRANSACTION },
};
GtkToggleActionEntry toggle_entries[] =
{
{"DebugModeAction", NULL, _("Debug mode"), NULL, NULL,
G_CALLBACK ( gsb_debug_start_log ), etat.debug_mode },
{"ShowTransactionFormAction", NULL, _("Show transaction _form"), NULL, NULL,
G_CALLBACK ( gsb_gui_toggle_show_form ), conf.formulaire_toujours_affiche },
#ifdef GTKOSXAPPLICATION
{"ShowReconciledAction", NULL, _("Show _reconciled"), "<Meta>R", NULL,
G_CALLBACK ( gsb_gui_toggle_show_reconciled ), 0 },
{"ShowArchivedAction", NULL, _("Show _lines archives"), "<Meta>L", NULL,
G_CALLBACK ( gsb_gui_toggle_show_archived ), 0 },
#else
{"ShowReconciledAction", NULL, _("Show _reconciled"), "<Alt>R", NULL,
G_CALLBACK ( gsb_gui_toggle_show_reconciled ), 0 },
{"ShowArchivedAction", NULL, _("Show _lines archives"), "<Alt>L", NULL,
G_CALLBACK ( gsb_gui_toggle_show_archived ), 0 },
#endif
{"ShowClosedAction", NULL, _("Show _closed accounts"), NULL, NULL,
G_CALLBACK ( gsb_gui_toggle_show_closed_accounts ), conf.show_closed_accounts }
};
ui_manager = gtk_ui_manager_new ();
actions = gtk_action_group_new ( "Actions" );
gtk_action_group_add_actions (actions,
entries,
G_N_ELEMENTS ( entries ),
(gpointer) run.window );
gtk_action_group_add_radio_actions ( actions,
radio_entries,
G_N_ELEMENTS ( radio_entries ),
-1,
G_CALLBACK ( gsb_gui_toggle_line_view_mode ),
NULL );
gtk_action_group_add_toggle_actions ( actions,
toggle_entries,
G_N_ELEMENTS ( toggle_entries ),
NULL );
gtk_ui_manager_insert_action_group ( ui_manager, actions, 0 );
merge_id = gtk_ui_manager_add_ui_from_string ( ui_manager,
ui_manager_buffer, -1, NULL );
#ifndef GTKOSXAPPLICATION
gtk_window_add_accel_group ( GTK_WINDOW ( run.window ),
gtk_ui_manager_get_accel_group ( ui_manager ) );
#endif /* GTKOSXAPPLICATION */
menubar = gtk_ui_manager_get_widget ( ui_manager, "/menubar" );
gtk_box_pack_start ( GTK_BOX ( vbox ), menubar, FALSE, TRUE, 0 );
/* return */
return menubar;
}
static gboolean
create_app (void)
{
GtkWidget *menubar;
GtkWidget *gridframe;
GtkWidget *grid;
GtkWidget *vpaned;
GtkUIManager *ui_manager;
app = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (app), _(APPNAME_LONG));
gtk_window_set_default_size (GTK_WINDOW (app), DEFAULT_WIDTH, DEFAULT_HEIGHT);
//games_conf_add_window (GTK_WINDOW (app), NULL);
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
g_signal_connect (G_OBJECT (app), "delete_event",
G_CALLBACK (on_game_exit), NULL);
gtk_window_set_default_icon_name ("gnect");
statusbar = gtk_statusbar_new ();
ui_manager = gtk_ui_manager_new ();
games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar);
create_game_menus (ui_manager);
menubar = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_set_hexpand (vpaned, TRUE);
gtk_widget_set_vexpand (vpaned, TRUE);
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gridframe = games_grid_frame_new (7, 7);
gtk_paned_pack1 (GTK_PANED (vpaned), gridframe, TRUE, FALSE);
gtk_container_add (GTK_CONTAINER (grid), menubar);
gtk_container_add (GTK_CONTAINER (grid), vpaned);
gtk_container_add (GTK_CONTAINER (grid), statusbar);
gtk_container_add (GTK_CONTAINER (app), notebook);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), grid, NULL);
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), MAIN_PAGE);
drawarea = gtk_drawing_area_new ();
/* set a min size to avoid pathological behavior of gtk when scaling down */
gtk_widget_set_size_request (drawarea, 200, 200);
gtk_container_add (GTK_CONTAINER (gridframe), drawarea);
gtk_widget_set_events (drawarea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
g_signal_connect (G_OBJECT (drawarea), "configure_event",
G_CALLBACK (on_drawarea_resize), NULL);
g_signal_connect (G_OBJECT (drawarea), "draw",
G_CALLBACK (on_drawarea_draw), NULL);
g_signal_connect (G_OBJECT (drawarea), "button_press_event",
G_CALLBACK (on_button_press), NULL);
g_signal_connect (G_OBJECT (app), "key_press_event",
G_CALLBACK (on_key_press), NULL);
/* We do our own double-buffering. */
gtk_widget_set_double_buffered (GTK_WIDGET (drawarea), FALSE);
gtk_action_set_sensitive (hint_action, FALSE);
gtk_action_set_sensitive (undo_action, FALSE);
gtk_widget_show_all (app);
gfx_refresh_pixmaps ();
gfx_draw_all ();
scorebox_update (); /* update visible player descriptions */
prompt_player ();
return TRUE;
}
