GtkWidget *
empathy_main_window_show (void)
{
EmpathyMainWindow *window;
EmpathyContactList *list_iface;
EmpathyContactMonitor *monitor;
GtkBuilder *gui;
EmpathyConf *conf;
GtkWidget *sw;
GtkToggleAction *show_offline_widget;
GtkWidget *ebox;
GtkAction *show_map_widget;
GtkToolItem *item;
gboolean show_offline;
gchar *filename;
GSList *l;
if (main_window) {
empathy_window_present (GTK_WINDOW (main_window->window));
return main_window->window;
}
main_window = g_new0 (EmpathyMainWindow, 1);
window = main_window;
/* Set up interface */
filename = empathy_file_lookup ("empathy-main-window.ui", "src");
gui = empathy_builder_get_file (filename,
"main_window", &window->window,
"main_vbox", &window->main_vbox,
"errors_vbox", &window->errors_vbox,
"ui_manager", &window->ui_manager,
"view_show_offline", &show_offline_widget,
"view_show_protocols", &window->show_protocols,
"view_sort_by_name", &window->sort_by_name,
"view_sort_by_status", &window->sort_by_status,
"view_normal_size_with_avatars", &window->normal_with_avatars,
"view_normal_size", &window->normal_size,
"view_compact_size", &window->compact_size,
"view_history", &window->view_history,
"view_show_map", &show_map_widget,
"room_join_favorites", &window->room_join_favorites,
"presence_toolbar", &window->presence_toolbar,
"roster_scrolledwindow", &sw,
NULL);
g_free (filename);
empathy_builder_connect (gui, window,
"main_window", "destroy", main_window_destroy_cb,
"main_window", "key-press-event", main_window_key_press_event_cb,
"chat_quit", "activate", main_window_chat_quit_cb,
"chat_new_message", "activate", main_window_chat_new_message_cb,
"chat_new_call", "activate", main_window_chat_new_call_cb,
"view_history", "activate", main_window_view_history_cb,
"room_join_new", "activate", main_window_room_join_new_cb,
"room_join_favorites", "activate", main_window_room_join_favorites_cb,
"room_manage_favorites", "activate", main_window_room_manage_favorites_cb,
"chat_add_contact", "activate", main_window_chat_add_contact_cb,
"view_show_ft_manager", "activate", main_window_view_show_ft_manager,
"view_show_offline", "toggled", main_window_view_show_offline_cb,
"view_show_protocols", "toggled", main_window_view_show_protocols_cb,
"view_sort_by_name", "changed", main_window_view_sort_contacts_cb,
"view_normal_size_with_avatars", "changed", main_window_view_contacts_list_size_cb,
"view_show_map", "activate", main_window_view_show_map_cb,
"edit", "activate", main_window_edit_cb,
"edit_accounts", "activate", main_window_edit_accounts_cb,
"edit_personal_information", "activate", main_window_edit_personal_information_cb,
"edit_preferences", "activate", main_window_edit_preferences_cb,
"help_about", "activate", main_window_help_about_cb,
"help_debug", "activate", main_window_help_debug_cb,
"help_contents", "activate", main_window_help_contents_cb,
NULL);
/* Set up connection related widgets. */
main_window_connection_items_setup (window, gui);
g_object_ref (window->ui_manager);
g_object_unref (gui);
#if !HAVE_LIBCHAMPLAIN
gtk_action_set_visible (show_map_widget, FALSE);
#endif
window->account_manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (window->account_manager, NULL,
account_manager_prepared_cb, window);
window->errors = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
g_object_unref,
NULL);
window->status_changed_handlers = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
NULL);
/* Set up menu */
main_window_favorite_chatroom_menu_setup (window);
window->edit_context = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/edit/edit_context");
window->edit_context_separator = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/edit/edit_context_separator");
gtk_widget_hide (window->edit_context);
gtk_widget_hide (window->edit_context_separator);
/* Set up contact list. */
empathy_status_presets_get_all ();
/* Set up presence chooser */
window->presence_chooser = empathy_presence_chooser_new ();
gtk_widget_show (window->presence_chooser);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), window->presence_chooser);
gtk_tool_item_set_is_important (item, TRUE);
gtk_tool_item_set_expand (item, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1);
/* Set up the throbber */
ebox = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), FALSE);
gtk_widget_set_tooltip_text (ebox, _("Show and edit accounts"));
g_signal_connect (ebox,
"button-press-event",
G_CALLBACK (main_window_throbber_button_press_event_cb),
window);
gtk_widget_show (ebox);
window->throbber = ephy_spinner_new ();
ephy_spinner_set_size (EPHY_SPINNER (window->throbber), GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (ebox), window->throbber);
gtk_widget_show (window->throbber);
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), ebox);
gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1);
gtk_widget_show (GTK_WIDGET (item));
list_iface = EMPATHY_CONTACT_LIST (empathy_contact_manager_dup_singleton ());
monitor = empathy_contact_list_get_monitor (list_iface);
window->list_store = empathy_contact_list_store_new (list_iface);
window->list_view = empathy_contact_list_view_new (window->list_store,
EMPATHY_CONTACT_LIST_FEATURE_ALL,
EMPATHY_CONTACT_FEATURE_ALL);
g_signal_connect (monitor, "contact-presence-changed",
G_CALLBACK (main_window_contact_presence_changed_cb), window);
window->butterfly_log_migration_contact_added_id = g_signal_connect (monitor, "contact-added",
G_CALLBACK (main_window_contact_added_cb), window);
g_object_unref (list_iface);
gtk_widget_show (GTK_WIDGET (window->list_view));
gtk_container_add (GTK_CONTAINER (sw),
GTK_WIDGET (window->list_view));
g_signal_connect (window->list_view, "row-activated",
G_CALLBACK (main_window_row_activated_cb),
window);
/* Load user-defined accelerators. */
main_window_accels_load ();
/* Set window size. */
empathy_geometry_bind (GTK_WINDOW (window->window), GEOMETRY_NAME);
/* Enable event handling */
window->event_manager = empathy_event_manager_dup_singleton ();
g_signal_connect (window->event_manager, "event-added",
G_CALLBACK (main_window_event_added_cb),
window);
g_signal_connect (window->event_manager, "event-removed",
G_CALLBACK (main_window_event_removed_cb),
window);
g_signal_connect (window->account_manager, "account-validity-changed",
G_CALLBACK (main_window_account_validity_changed_cb),
window);
g_signal_connect (window->account_manager, "account-removed",
G_CALLBACK (main_window_account_removed_cb),
window);
g_signal_connect (window->account_manager, "account-disabled",
G_CALLBACK (main_window_account_disabled_cb),
window);
l = empathy_event_manager_get_events (window->event_manager);
while (l) {
main_window_event_added_cb (window->event_manager,
l->data, window);
l = l->next;
}
conf = empathy_conf_get ();
/* Show offline ? */
empathy_conf_get_bool (conf,
EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE,
&show_offline);
empathy_conf_notify_add (conf,
EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE,
main_window_notify_show_offline_cb,
show_offline_widget);
gtk_toggle_action_set_active (show_offline_widget, show_offline);
/* Show protocol ? */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_SHOW_PROTOCOLS,
(EmpathyConfNotifyFunc) main_window_notify_show_protocols_cb,
window);
main_window_notify_show_protocols_cb (conf,
EMPATHY_PREFS_UI_SHOW_PROTOCOLS,
window);
/* Sort by name / by status ? */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
(EmpathyConfNotifyFunc) main_window_notify_sort_contact_cb,
window);
main_window_notify_sort_contact_cb (conf,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
window);
/* Contacts list size */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
(EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb,
window);
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_SHOW_AVATARS,
(EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb,
window);
main_window_notify_contact_list_size_cb (conf,
EMPATHY_PREFS_UI_SHOW_AVATARS,
window);
return window->window;
}
void
e_composer_private_constructed (EMsgComposer *composer)
{
EMsgComposerPrivate *priv = composer->priv;
EFocusTracker *focus_tracker;
EComposerHeader *header;
EShell *shell;
EClientCache *client_cache;
EHTMLEditor *editor;
EHTMLEditorView *view;
GtkUIManager *ui_manager;
GtkAction *action;
GtkWidget *container;
GtkWidget *widget;
GtkWidget *send_widget;
GtkWindow *window;
GSettings *settings;
const gchar *path;
gchar *filename, *gallery_path;
gint ii;
GError *error = NULL;
editor = e_msg_composer_get_editor (composer);
ui_manager = e_html_editor_get_ui_manager (editor);
view = e_html_editor_get_view (editor);
settings = e_util_ref_settings ("org.gnome.evolution.mail");
shell = e_msg_composer_get_shell (composer);
client_cache = e_shell_get_client_cache (shell);
/* Each composer window gets its own window group. */
window = GTK_WINDOW (composer);
priv->window_group = gtk_window_group_new ();
gtk_window_group_add_window (priv->window_group, window);
priv->async_actions = gtk_action_group_new ("async");
priv->charset_actions = gtk_action_group_new ("charset");
priv->composer_actions = gtk_action_group_new ("composer");
priv->extra_hdr_names = g_ptr_array_new ();
priv->extra_hdr_values = g_ptr_array_new ();
priv->charset = e_composer_get_default_charset ();
priv->is_from_new_message = FALSE;
priv->set_signature_from_message = FALSE;
priv->disable_signature = FALSE;
priv->busy = FALSE;
priv->saved_editable = FALSE;
priv->drop_occured = FALSE;
priv->dnd_is_uri = FALSE;
priv->check_if_signature_is_changed = FALSE;
priv->ignore_next_signature_change = FALSE;
priv->dnd_history_saved = FALSE;
priv->focused_entry = NULL;
e_composer_actions_init (composer);
filename = e_composer_find_data_file ("evolution-composer.ui");
gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error);
g_free (filename);
/* We set the send button as important to have a label */
path = "/main-toolbar/pre-main-toolbar/send";
send_widget = gtk_ui_manager_get_widget (ui_manager, path);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE);
composer_setup_charset_menu (composer);
if (error != NULL) {
/* Henceforth, bad things start happening. */
g_critical ("%s", error->message);
g_clear_error (&error);
}
/* Configure an EFocusTracker to manage selection actions. */
focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer));
action = e_html_editor_get_action (editor, "cut");
e_focus_tracker_set_cut_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "copy");
e_focus_tracker_set_copy_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "paste");
e_focus_tracker_set_paste_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "select-all");
e_focus_tracker_set_select_all_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "undo");
e_focus_tracker_set_undo_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "redo");
e_focus_tracker_set_redo_action (focus_tracker, action);
priv->focus_tracker = focus_tracker;
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (composer), widget);
gtk_widget_show (widget);
container = widget;
/* Construct the main menu and toolbar. */
widget = e_html_editor_get_managed_widget (editor, "/main-menu");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = e_html_editor_get_managed_widget (editor, "/main-toolbar");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the header table. */
widget = e_composer_header_table_new (client_cache);
gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
priv->header_table = g_object_ref (widget);
gtk_widget_show (widget);
header = e_composer_header_table_get_header (
E_COMPOSER_HEADER_TABLE (widget),
E_COMPOSER_HEADER_SUBJECT);
e_binding_bind_property (
view, "spell-checker",
header->input_widget, "spell-checker",
G_BINDING_SYNC_CREATE);
/* Construct the editing toolbars. We'll have to reparent
* the embedded EHTMLEditorView a little further down. */
widget = GTK_WIDGET (editor);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the attachment paned. */
widget = e_attachment_paned_new ();
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
priv->attachment_paned = g_object_ref_sink (widget);
gtk_widget_show (widget);
e_binding_bind_property (
view, "editable",
widget, "sensitive",
G_BINDING_SYNC_CREATE);
container = e_attachment_paned_get_content_area (
E_ATTACHMENT_PANED (priv->attachment_paned));
widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT);
gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE);
priv->gallery_scrolled_window = g_object_ref (widget);
gtk_widget_show (widget);
/* Reparent the scrolled window containing the web view
* widget into the content area of the top attachment pane. */
widget = GTK_WIDGET (view);
widget = gtk_widget_get_parent (widget);
gtk_widget_reparent (widget, container);
/* Construct the picture gallery. */
container = priv->gallery_scrolled_window;
/* FIXME This should be an EMsgComposer property. */
gallery_path = g_settings_get_string (
settings, "composer-gallery-path");
widget = e_picture_gallery_new (gallery_path);
gtk_container_add (GTK_CONTAINER (container), widget);
priv->gallery_icon_view = g_object_ref_sink (widget);
g_free (gallery_path);
e_signal_connect_notify_swapped (
view, "notify::mode",
G_CALLBACK (composer_update_gallery_visibility), composer);
g_signal_connect_swapped (
ACTION (PICTURE_GALLERY), "toggled",
G_CALLBACK (composer_update_gallery_visibility), composer);
/* Initial sync */
composer_update_gallery_visibility (composer);
/* Bind headers to their corresponding actions. */
for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) {
EComposerHeaderTable *table;
EComposerHeader *header;
GtkAction *action;
table = E_COMPOSER_HEADER_TABLE (priv->header_table);
header = e_composer_header_table_get_header (table, ii);
switch (ii) {
case E_COMPOSER_HEADER_FROM:
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
action = ACTION (VIEW_FROM_OVERRIDE);
e_binding_bind_property (
header, "override-visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
continue;
case E_COMPOSER_HEADER_BCC:
action = ACTION (VIEW_BCC);
break;
case E_COMPOSER_HEADER_CC:
action = ACTION (VIEW_CC);
break;
case E_COMPOSER_HEADER_REPLY_TO:
action = ACTION (VIEW_REPLY_TO);
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
break;
case E_COMPOSER_HEADER_SUBJECT:
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
continue;
default:
continue;
}
e_binding_bind_property (
header, "sensitive",
action, "sensitive",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
header, "visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
}
/* Disable actions that start asynchronous activities while an
* asynchronous activity is in progress. We enforce this with
* a simple inverted binding to EMsgComposer's "busy" property. */
e_binding_bind_property (
composer, "busy",
priv->async_actions, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
e_binding_bind_property (
composer, "busy",
priv->header_table, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
g_object_unref (settings);
}
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 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 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!"));
}
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;
}
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));
}
void dev_select_rescan(GtkAction *action, GtkWindow *parent)
{
GtkComboBox *devbox = g_object_get_data(G_OBJECT(parent), "devcombo");
g_return_if_fail(devbox != NULL);
GtkListStore *devlist = GTK_LIST_STORE(gtk_combo_box_get_model(devbox));
GtkTreeIter iter;
struct sr_dev *dev;
const struct sr_dev_inst *sdi;
gchar *sdevname = NULL;
GSList *devs, *l;
GtkUIManager *ui = g_object_get_data(G_OBJECT(parent), "ui_manager");
GtkWidget *menuitem = gtk_ui_manager_get_widget(ui,
"/menubar/DevMenu/DevSelectMenu");
GtkMenuShell *devmenu = GTK_MENU_SHELL(gtk_menu_item_get_submenu(GTK_MENU_ITEM(menuitem)));
GSList *radiolist = NULL;
(void)action;
/* Make a copy of the selected device's short name for comparison.
* We wish to select the same device after the refresh if possible.
*/
if (gtk_combo_box_get_active_iter(devbox, &iter)) {
gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 1, &dev, -1);
/* FIXME: Use something other than dev->driver->name */
sdevname = g_strdup(dev->driver->name);
}
/* Destroy the old menu items */
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) do {
GtkMenuItem *item;
gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 2, &item, -1);
gtk_object_destroy(GTK_OBJECT(item));
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter));
gtk_list_store_clear(devlist);
/* Scan for new devices and update our list */
/* TODO: Fix this in libsigrok first. */
/*sr_dev_scan();*/
devs = sr_dev_list();
for (l = devs; l; l = l->next) {
dev = l->data;
sdi = GET_DEV_INST(dev);
gchar *name = sdi->model ? sdi->model : sdi->vendor;
if (!name)
name = "(unknown)";
menuitem = gtk_radio_menu_item_new_with_label(radiolist, name);
gtk_widget_show(GTK_WIDGET(menuitem));
if (!radiolist)
radiolist = gtk_radio_menu_item_get_group(
GTK_RADIO_MENU_ITEM(menuitem));
g_signal_connect(menuitem, "toggled",
G_CALLBACK(dev_menuitem_toggled), devbox);
gtk_menu_shell_prepend(devmenu, menuitem);
gtk_list_store_append(devlist, &iter);
gtk_list_store_set(devlist, &iter,
0, name,
1, dev,
2, menuitem,
-1);
if (sdevname && g_str_equal(sdevname, dev->driver->name))
gtk_combo_box_set_active_iter(devbox, &iter);
}
if (sdevname)
g_free(sdevname);
/* Select a default if nothing selected */
if (!gtk_combo_box_get_active_iter(devbox, &iter)) {
if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter))
return;
/* Skip demo if there's another available */
GtkTreeIter first = iter;
if (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter))
gtk_combo_box_set_active_iter(devbox, &iter);
else
gtk_combo_box_set_active_iter(devbox, &first);
}
}
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;
}
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;
}
}
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 ()
{
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);
}
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);
}
void
browser_dialog_open (const gchar *plug_in_binary)
{
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *paned;
GtkWidget *scrolled;
GtkWidget *button;
GtkToolItem *item;
GtkAction *action;
DialogData data = { 720, 560, 240, TRUE, 1.0 };
gimp_ui_init (plug_in_binary, TRUE);
gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data);
/* the dialog window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser"));
gtk_window_set_role (GTK_WINDOW (window), plug_in_binary);
gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
window_set_icons (window);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
ui_manager = ui_manager_new (window);
toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/forward");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_next = GTK_WIDGET (item);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/back");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_prev = GTK_WIDGET (item);
item =
GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager,
"/help-browser-toolbar/space"));
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
gtk_tool_item_set_expand (item, TRUE);
button = gtk_ui_manager_get_widget (ui_manager,
"/help-browser-toolbar/website");
/* the horizontal paned */
paned = gtk_hpaned_new ();
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
gtk_widget_show (paned);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
gtk_paned_set_position (GTK_PANED (paned), data.paned_position);
sidebar = scrolled;
if (data.show_index)
gtk_widget_show (sidebar);
tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled), tree_view);
gtk_widget_show (tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1,
NULL,
gtk_cell_renderer_text_new (),
"text", 1,
NULL);
g_signal_connect (tree_view, "row-activated",
G_CALLBACK (row_activated),
NULL);
/* HTML view */
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (main_vbox);
gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled, 300, 200);
gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
view = webkit_web_view_new ();
webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view),
TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), view);
gtk_widget_show (view);
g_signal_connect (view, "realize",
G_CALLBACK (view_realize),
NULL);
g_signal_connect (view, "unrealize",
G_CALLBACK (view_unrealize),
NULL);
g_signal_connect (view, "popup-menu",
G_CALLBACK (view_popup_menu),
NULL);
g_signal_connect (view, "button-press-event",
G_CALLBACK (view_button_press),
NULL);
g_signal_connect (view, "key-press-event",
G_CALLBACK (view_key_press),
NULL);
webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom);
g_signal_connect (view, "title-changed",
G_CALLBACK (title_changed),
window);
g_signal_connect (view, "load-started",
G_CALLBACK (load_started),
NULL);
g_signal_connect (view, "load-finished",
G_CALLBACK (load_finished),
NULL);
gtk_widget_grab_focus (view);
g_signal_connect (window, "unmap",
G_CALLBACK (dialog_unmap),
paned);
update_actions ();
/* Searchbar */
searchbar = build_searchbar ();
gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0);
}
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);
}
static void
gui_restore_after_callback (Gimp *gimp,
GimpInitStatusFunc status_callback)
{
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (gimp->config);
GimpDisplay *display;
if (gimp->be_verbose)
g_print ("INIT: %s\n", G_STRFUNC);
gimp->message_handler = GIMP_MESSAGE_BOX;
if (gui_config->restore_accels)
menus_restore (gimp);
ui_configurer = g_object_new (GIMP_TYPE_UI_CONFIGURER,
"gimp", gimp,
NULL);
image_ui_manager = gimp_menu_factory_manager_new (global_menu_factory,
"<Image>",
gimp,
gui_config->tearoff_menus);
gimp_ui_manager_update (image_ui_manager, gimp);
#ifdef GDK_WINDOWING_QUARTZ
{
GtkosxApplication *osx_app;
GtkWidget *menu;
GtkWidget *item;
osx_app = gtkosx_application_get ();
menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager),
"/image-menubar");
if (GTK_IS_MENU_ITEM (menu))
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu));
gtkosx_application_set_menu_bar (osx_app, GTK_MENU_SHELL (menu));
gtkosx_application_set_use_quartz_accelerators (osx_app, FALSE);
gui_add_to_app_menu (image_ui_manager, osx_app,
"/image-menubar/Help/dialogs-about", 0);
#define PREFERENCES "/image-menubar/Edit/Preferences/"
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-preferences", 2);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-input-devices", 3);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-keyboard-shortcuts", 4);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "dialogs-module-dialog", 5);
gui_add_to_app_menu (image_ui_manager, osx_app,
PREFERENCES "plug-in-unit-editor", 6);
#undef PREFERENCES
item = gtk_separator_menu_item_new ();
gtkosx_application_insert_app_menu_item (osx_app, item, 7);
item = gtk_ui_manager_get_widget (GTK_UI_MANAGER (image_ui_manager),
"/image-menubar/File/file-quit");
gtk_widget_hide (item);
g_signal_connect (osx_app, "NSApplicationBlockTermination",
G_CALLBACK (gui_quartz_quit_callback),
image_ui_manager);
gtkosx_application_ready (osx_app);
}
#endif /* GDK_WINDOWING_QUARTZ */
g_signal_connect_object (gui_config, "notify::single-window-mode",
G_CALLBACK (gui_single_window_mode_notify),
ui_configurer, 0);
g_signal_connect_object (gui_config, "notify::tearoff-menus",
G_CALLBACK (gui_tearoff_menus_notify),
image_ui_manager, 0);
g_signal_connect (image_ui_manager, "show-tooltip",
G_CALLBACK (gui_menu_show_tooltip),
gimp);
g_signal_connect (image_ui_manager, "hide-tooltip",
G_CALLBACK (gui_menu_hide_tooltip),
gimp);
gimp_devices_restore (gimp);
gimp_controllers_restore (gimp, image_ui_manager);
if (status_callback == splash_update)
splash_destroy ();
color_history_restore (gimp);
if (gimp_get_show_gui (gimp))
{
GimpDisplayShell *shell;
/* create the empty display */
display = GIMP_DISPLAY (gimp_create_display (gimp,
NULL,
GIMP_UNIT_PIXEL,
1.0));
shell = gimp_display_get_shell (display);
if (gui_config->restore_session)
session_restore (gimp);
/* move keyboard focus to the display */
gtk_window_present (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (shell))));
}
/* indicate that the application has finished loading */
gdk_notify_startup_complete ();
}
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;
}
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;
}
void
caja_menus_append_bookmark_to_menu (CajaWindow *window,
CajaBookmark *bookmark,
const char *parent_path,
const char *parent_id,
guint index_in_parent,
GtkActionGroup *action_group,
guint merge_id,
GCallback refresh_callback,
CajaBookmarkFailedCallback failed_callback)
{
BookmarkHolder *bookmark_holder;
char action_name[128];
char *name;
char *path;
GdkPixbuf *pixbuf;
GtkAction *action;
GtkWidget *menuitem;
g_assert (CAJA_IS_WINDOW (window));
g_assert (CAJA_IS_BOOKMARK (bookmark));
bookmark_holder = bookmark_holder_new (bookmark, window, refresh_callback, failed_callback);
name = caja_bookmark_get_name (bookmark);
/* Create menu item with pixbuf */
pixbuf = caja_bookmark_get_pixbuf (bookmark, GTK_ICON_SIZE_MENU);
g_snprintf (action_name, sizeof (action_name), "%s%d", parent_id, index_in_parent);
action = gtk_action_new (action_name,
name,
_("Go to the location specified by this bookmark"),
NULL);
g_object_set_data_full (G_OBJECT (action), "menu-icon",
g_object_ref (pixbuf),
g_object_unref);
g_signal_connect_data (action, "activate",
G_CALLBACK (activate_bookmark_in_menu_item),
bookmark_holder,
bookmark_holder_free_cover, 0);
gtk_action_group_add_action (action_group,
GTK_ACTION (action));
g_object_unref (action);
gtk_ui_manager_add_ui (window->details->ui_manager,
merge_id,
parent_path,
action_name,
action_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
path = g_strdup_printf ("%s/%s", parent_path, action_name);
menuitem = gtk_ui_manager_get_widget (window->details->ui_manager,
path);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (menuitem),
TRUE);
g_object_unref (pixbuf);
g_free (path);
g_free (name);
}
GtkWidget *Create_Log_Area (void)
{
GtkWidget *Frame;
GtkWidget *ScrollWindowLogList;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *PopupMenu;
Frame = gtk_frame_new(_("Log"));
gtk_container_set_border_width(GTK_CONTAINER(Frame), 2);
/*
* The ScrollWindow and the List
*/
ScrollWindowLogList = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowLogList),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(Frame),ScrollWindowLogList);
/* The file list */
logListModel = gtk_list_store_new(LOG_COLUMN_COUNT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
LogList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(logListModel));
g_object_unref (logListModel);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(LogList), FALSE);
gtk_container_add(GTK_CONTAINER(ScrollWindowLogList), LogList);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(LogList), FALSE);
gtk_widget_set_size_request(LogList, 0, 0);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(LogList), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(LogList)),GTK_SELECTION_MULTIPLE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(LogList), column);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"stock-id", LOG_PIXBUF,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", LOG_TIME_TEXT,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", LOG_TEXT,
NULL);
// Create Popup Menu on browser album list
PopupMenu = gtk_ui_manager_get_widget(UIManager, "/LogPopup");
gtk_menu_attach_to_widget (GTK_MENU (PopupMenu), LogList, NULL);
g_signal_connect (G_OBJECT (LogList), "button-press-event",
G_CALLBACK (Log_Popup_Menu_Handler), PopupMenu);
// Load pending messages in the Log list
Log_Print_Tmp_List();
if (SHOW_LOG_VIEW)
//gtk_widget_show_all(ScrollWindowLogList);
gtk_widget_show_all(Frame);
//return ScrollWindowLogList;
return Frame;
}
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);
}
GtkWidget *
gimp_text_editor_new (const gchar *title,
GtkWindow *parent,
Gimp *gimp,
GimpMenuFactory *menu_factory,
GimpText *text,
GimpTextBuffer *text_buffer,
gdouble xres,
gdouble yres)
{
GimpTextEditor *editor;
GtkWidget *content_area;
GtkWidget *toolbar;
GtkWidget *style_editor;
GtkWidget *scrolled_window;
gboolean use_header_bar;
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), NULL);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
g_return_val_if_fail (GIMP_IS_TEXT_BUFFER (text_buffer), NULL);
g_object_get (gtk_settings_get_default (),
"gtk-dialogs-use-header", &use_header_bar,
NULL);
editor = g_object_new (GIMP_TYPE_TEXT_EDITOR,
"title", title,
"role", "gimp-text-editor",
"transient-for", parent,
"help-func", gimp_standard_help_func,
"help-id", GIMP_HELP_TEXT_EDITOR_DIALOG,
"use-header-bar", use_header_bar,
NULL);
gtk_dialog_add_button (GTK_DIALOG (editor),
_("_Close"), GTK_RESPONSE_CLOSE);
g_signal_connect (editor, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
g_signal_connect_object (text_buffer, "changed",
G_CALLBACK (gimp_text_editor_text_changed),
editor, 0);
editor->ui_manager = gimp_menu_factory_manager_new (menu_factory,
"<TextEditor>",
editor);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (editor));
toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (editor->ui_manager),
"/text-editor-toolbar");
if (toolbar)
{
gtk_box_pack_start (GTK_BOX (content_area), toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
}
style_editor = gimp_text_style_editor_new (gimp, text, text_buffer,
gimp_data_factory_get_container (gimp->font_factory),
xres, yres);
gtk_box_pack_start (GTK_BOX (content_area), style_editor, FALSE, FALSE, 0);
gtk_widget_show (style_editor);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 2);
gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
editor->view = gtk_text_view_new_with_buffer (GTK_TEXT_BUFFER (text_buffer));
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (editor->view),
GTK_WRAP_WORD_CHAR);
gtk_container_add (GTK_CONTAINER (scrolled_window), editor->view);
gtk_widget_show (editor->view);
switch (editor->base_dir)
{
case GIMP_TEXT_DIRECTION_LTR:
case GIMP_TEXT_DIRECTION_TTB_RTL:
case GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT:
case GIMP_TEXT_DIRECTION_TTB_LTR:
case GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT:
gtk_widget_set_direction (editor->view, GTK_TEXT_DIR_LTR);
break;
case GIMP_TEXT_DIRECTION_RTL:
gtk_widget_set_direction (editor->view, GTK_TEXT_DIR_RTL);
break;
}
gtk_widget_set_size_request (editor->view, 200, 64);
editor->font_toggle =
gtk_check_button_new_with_mnemonic (_("_Use selected font"));
gtk_box_pack_start (GTK_BOX (content_area), editor->font_toggle,
FALSE, FALSE, 0);
gtk_widget_show (editor->font_toggle);
g_signal_connect (editor->font_toggle, "toggled",
G_CALLBACK (gimp_text_editor_font_toggled),
editor);
gtk_widget_grab_focus (editor->view);
gimp_ui_manager_update (editor->ui_manager, editor);
return GTK_WIDGET (editor);
}
static gchar *
plug_in_menus_build_path (GimpUIManager *manager,
const gchar *ui_path,
guint merge_id,
const gchar *menu_path,
gboolean for_menu)
{
gchar *action_path;
if (! strchr (menu_path, '/'))
{
action_path = g_strdup (ui_path);
goto make_placeholder;
}
action_path = g_strdup_printf ("%s%s", ui_path, strchr (menu_path, '/'));
if (! gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), action_path))
{
gchar *parent_menu_path = g_strdup (menu_path);
gchar *parent_action_path = NULL;
gchar *menu_item_name;
menu_item_name = strrchr (parent_menu_path, '/');
*menu_item_name++ = '\0';
if (menu_item_name)
parent_action_path = plug_in_menus_build_path (manager,
ui_path, merge_id,
parent_menu_path, TRUE);
if (parent_action_path)
{
g_free (action_path);
action_path = g_strdup_printf ("%s/%s",
parent_action_path, menu_item_name);
if (! gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
action_path))
{
GIMP_LOG (MENUS, "adding menu '%s' at path '%s' for action '%s'",
menu_item_name, action_path, menu_path);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
parent_action_path, menu_item_name,
menu_path,
GTK_UI_MANAGER_MENU,
FALSE);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, "Menus", NULL,
GTK_UI_MANAGER_PLACEHOLDER,
FALSE);
gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id,
action_path, "Separator", NULL,
GTK_UI_MANAGER_SEPARATOR,
FALSE);
}
g_free (parent_action_path);
}
else
{
g_free (action_path);
action_path = NULL;
}
g_free (parent_menu_path);
}
make_placeholder:
if (action_path && for_menu)
{
gchar *placeholder_path = g_strdup_printf ("%s/%s", action_path, "Menus");
if (gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
placeholder_path))
{
g_free (action_path);
return placeholder_path;
}
g_free (placeholder_path);
}
return action_path;
}
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;
}
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)
{
/**********************************************************************************/
/* 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;
}
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 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;
}
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 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);
}
