int main(int argc,char **argv)
{
Vnkb *vnkb;
VnkbDocklet *docklet = g_new0(VnkbDocklet,1);
vnkb = g_new0(Vnkb,1);
vnkb->panel = docklet;
gtk_init(&argc,&argv);
vnkb->update_charset = vnkb_docklet_update_charset;
vnkb->update_method = vnkb_docklet_update_method;
vnkb->update_enabled = vnkb_docklet_update_enabled;
vnkb->update_spelling = vnkb_docklet_update_spelling;
vnkb->driver_changed = vnkb_docklet_driver_changed;
docklet->docklet = egg_tray_icon_new("Gaim");
docklet->actions = gtk_action_group_new("MenuActions");
gtk_action_group_set_translation_domain(docklet->actions,GETTEXT_PACKAGE);
gtk_action_group_add_actions(docklet->actions,entries,G_N_ELEMENTS(entries),vnkb);
gtk_action_group_add_radio_actions(docklet->actions,im_entries,G_N_ELEMENTS(im_entries),0,G_CALLBACK(im_change_cb),vnkb);
gtk_action_group_add_radio_actions(docklet->actions,cs_entries,G_N_ELEMENTS(cs_entries),0,G_CALLBACK(cs_change_cb),vnkb);
gtk_action_group_add_toggle_actions(docklet->actions,toggle_entries,G_N_ELEMENTS(toggle_entries),vnkb);
docklet->uim = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(docklet->uim,docklet->actions,0);
gtk_ui_manager_add_ui_from_string(docklet->uim,xml,-1,NULL);
docklet->menu = gtk_ui_manager_get_widget(docklet->uim,"/MainMenu");
vnkb_init(vnkb,GTK_WIDGET(docklet->docklet));
g_signal_connect(G_OBJECT(vnkb->button),
"button-press-event",
G_CALLBACK(button_press_hack),
vnkb);
//signal_connect(G_OBJECT(vnkb->button),"popup-menu",G_CALLBACK(button_popup_cb),NULL);
//g_signal_connect(G_OBJECT(docklet), "embedded", G_CALLBACK(docklet_x11_embedded_cb), NULL);
//g_signal_connect(G_OBJECT(docklet), "destroy", G_CALLBACK(docklet_x11_destroyed_cb), NULL);
//g_signal_connect(G_OBJECT(box), "button-press-event", G_CALLBACK(docklet_x11_clicked_cb), NULL);
/* ref the docklet before we bandy it about the place */
g_object_ref(G_OBJECT(docklet->docklet));
gtk_main();
return 0;
}
Actions::Actions(Window *window):
m_window(window)
{
m_actionGroup = gtk_action_group_new("actions");
gtk_action_group_set_translation_domain(m_actionGroup, NULL);
gtk_action_group_add_actions(m_actionGroup,
actionEntries,
N_ACTIONS,
window);
for (int i = 0; i < N_ACTIONS; ++i)
m_actions[i] = gtk_action_group_get_action(m_actionGroup,
actionEntries[i].name);
gtk_action_group_add_toggle_actions(m_actionGroup,
toggleActionEntries,
N_TOGGLE_ACTIONS,
m_window);
for (int i = 0; i < N_TOGGLE_ACTIONS; ++i)
m_toggleActions[i] = GTK_TOGGLE_ACTION(
gtk_action_group_get_action(m_actionGroup,
toggleActionEntries[i].name));
gtk_action_group_add_radio_actions(m_actionGroup,
windowLayoutEntries,
2,
Window::LAYOUT_TOOLS_PANE_RIGHT,
G_CALLBACK(changeWindowLayout),
m_window);
m_radioActionGroups[RADIO_ACTION_GROUP_WINDOW_LAYOUT] = GTK_RADIO_ACTION(
gtk_action_group_get_action(m_actionGroup,
windowLayoutEntries[0].name));
}
static VALUE
actiongroup_add_radio_actions(int argc, VALUE *argv, VALUE self)
{
VALUE entries, value, proc;
guint i;
guint n_entries;
GtkRadioActionEntry* gentries;
rb_scan_args(argc, argv, "12", &entries, &value, &proc);
if (NIL_P(value)) value = -1;
if (NIL_P(proc) && rb_block_given_p()){
proc = rb_block_proc();
G_RELATIVE(self, proc);
}
n_entries = (guint)RARRAY_LEN(entries);
gentries = g_new0(GtkRadioActionEntry, n_entries);
for (i = 0; i < n_entries; i++){
VALUE entry;
int size;
entry = RARRAY_PTR(entries)[i];
size = RARRAY_LEN(entry);
if (size < 1)
rb_raise(rb_eArgError, "wrong array parameter");
gentries[i].name = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[0]);
if (size < 2) continue;
if (NIL_P(RARRAY_PTR(entry)[1])){
gentries[i].stock_id = NULL;
} else if (SYMBOL_P(RARRAY_PTR(entry)[1])){
gentries[i].stock_id = rb_id2name(SYM2ID(RARRAY_PTR(entry)[1]));
} else if (TYPE(RARRAY_PTR(entry)[1]) == T_STRING){
gentries[i].stock_id = RVAL2CSTR(RARRAY_PTR(entry)[1]);
} else{
rb_raise(rb_eArgError,
"invalid argument %s (expect Symbol or String)",
rb_class2name(CLASS_OF(RARRAY_PTR(entry)[1])));
}
if (size < 3) continue;
gentries[i].label = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[2]);
if (size < 4) continue;
gentries[i].accelerator = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[3]);
if (size < 4) continue;
gentries[i].tooltip = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[4]);
if (size < 5) continue;
gentries[i].value = NUM2INT(RARRAY_PTR(entry)[5]);
}
gtk_action_group_add_radio_actions(_SELF(self), gentries,
n_entries, NUM2INT(value),
G_CALLBACK(activate_radio_action),
(gpointer)proc);
g_free(gentries);
return self;
}
static GtkActionGroup *
create_or_ref_display_actions (gboolean include_common)
{
if (display_actions)
return g_object_ref (display_actions);
display_actions = gtk_action_group_new ("display-actions");
gtk_action_group_set_translation_domain (display_actions, NULL);
gtk_action_group_set_translate_func (display_actions, _dia_translate, NULL, NULL);
if (include_common)
gtk_action_group_add_actions (display_actions, common_entries,
G_N_ELEMENTS (common_entries), NULL);
gtk_action_group_add_actions (display_actions, display_entries,
G_N_ELEMENTS (display_entries), NULL);
gtk_action_group_add_toggle_actions (display_actions, display_toggle_entries,
G_N_ELEMENTS (display_toggle_entries),
NULL);
gtk_action_group_add_radio_actions (display_actions,
display_select_radio_entries,
G_N_ELEMENTS (display_select_radio_entries),
0, /* SELECT_REPLACE - first radio entry */
G_CALLBACK (select_style_callback),
NULL);
/* the initial reference */
return display_actions;
}
static void
gnc_plugin_page_invoice_init (GncPluginPageInvoice *plugin_page)
{
GncPluginPage *parent;
GtkActionGroup *action_group;
gboolean use_new;
/* Init parent declared variables */
parent = GNC_PLUGIN_PAGE(plugin_page);
use_new = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_USE_NEW);
g_object_set(G_OBJECT(plugin_page),
"page-name", _("Invoice"),
"page-uri", "default:",
"ui-description", "gnc-plugin-page-invoice-ui.xml",
"use-new-window", use_new,
(char *)NULL);
/* change me when the system supports multiple books */
gnc_plugin_page_add_book(parent, gnc_get_current_book());
/* Create menu and toolbar information */
action_group =
gnc_plugin_page_create_action_group(parent,
"GncPluginPageInvoiceActions");
gtk_action_group_add_actions (action_group, gnc_plugin_page_invoice_actions,
gnc_plugin_page_invoice_n_actions, plugin_page);
gtk_action_group_add_radio_actions (action_group,
radio_entries, n_radio_entries,
REG_STYLE_LEDGER,
G_CALLBACK(gnc_plugin_page_invoice_cmd_sort_changed),
plugin_page);
gnc_plugin_init_short_names (action_group, toolbar_labels);
}
static VALUE
rg_add_radio_actions(int argc, VALUE *argv, VALUE self)
{
GtkActionGroup *group = _SELF(self);
VALUE rbentries, rbvalue, proc;
long n;
GtkRadioActionEntry *entries;
gint value;
rb_scan_args(argc, argv, "12", &rbentries, &rbvalue, &proc);
value = NIL_P(rbvalue) ? -1 : NUM2INT(rbvalue);
if (NIL_P(proc) && rb_block_given_p()) {
proc = rb_block_proc();
/* TODO: How do we remove this proc when all the radio actions passed
* have been removed? */
G_RELATIVE(self, proc);
}
entries = RVAL2GTKRADIOACTIONENTRIES(rbentries, n);
gtk_action_group_add_radio_actions(group,
entries,
n,
value,
G_CALLBACK(activate_radio_action),
(gpointer)proc);
g_free(entries);
return self;
}
int
clip_GTK_ACTIONGROUPADDRADIOACTIONS(ClipMachine * ClipMachineMemory)
{
C_object *cagroup = _fetch_co_arg(ClipMachineMemory);
ClipArrVar *carr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 2));
guint n_actions = _clip_parni(ClipMachineMemory, 3);
gint value = _clip_parni(ClipMachineMemory, 4);
ClipVar *cfunc = _clip_spar(ClipMachineMemory, 5);
C_var *c = NEW(C_var);
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object));
CHECKARG(2, ARRAY_type_of_ClipVarType);
CHECKARG(3, NUMERIC_type_of_ClipVarType);
CHECKARG(4, NUMERIC_type_of_ClipVarType);
CHECKARG2(5, PCODE_type_of_ClipVarType, CCODE_type_of_ClipVarType);
if (carr)
{
GtkRadioActionEntry *acts;
gint i;
acts = malloc(carr->count_of_ClipArrVar * sizeof(GtkRadioActionEntry));
memset(acts, 0, sizeof(GtkRadioActionEntry) * carr->count_of_ClipArrVar);
for (i = 0; i < n_actions; i++)
_map_to_radio_action_entry(ClipMachineMemory, &carr->ClipVar_items_of_ClipArrVar[i], &acts[i]);
c->ClipMachineMemory = ClipMachineMemory;
c->co = cagroup;
_clip_mclone(ClipMachineMemory, &c->cfunc, cfunc);
gtk_action_group_add_radio_actions(GTK_ACTION_GROUP(cagroup->object), acts, n_actions, value, (GCallback) call_b, c);
free(acts);
}
return 0;
err:
return 1;
}
static void workrave_applet_fill(WorkraveApplet *applet)
{
mate_panel_applet_set_flags(applet->applet,
MATE_PANEL_APPLET_HAS_HANDLE);
mate_panel_applet_set_background_widget(applet->applet, GTK_WIDGET(applet->applet));
applet->timerbox_control = g_object_new(WORKRAVE_TIMERBOX_CONTROL_TYPE, NULL);
applet->image = workrave_timerbox_control_get_image(applet->timerbox_control);
g_signal_connect(G_OBJECT(applet->timerbox_control), "menu-changed", G_CALLBACK(on_menu_changed), applet);
g_signal_connect(G_OBJECT(applet->timerbox_control), "alive-changed", G_CALLBACK(on_alive_changed), applet);
workrave_timerbox_control_set_tray_icon_visible_when_not_running(applet->timerbox_control, TRUE);
workrave_timerbox_control_set_tray_icon_mode(applet->timerbox_control, WORKRAVE_TIMERBOX_CONTROL_TRAY_ICON_MODE_ALWAYS);
applet->action_group = gtk_action_group_new("WorkraveAppletActions");
gtk_action_group_set_translation_domain(applet->action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions(applet->action_group,
menu_actions,
G_N_ELEMENTS (menu_actions),
applet);
gtk_action_group_add_toggle_actions(applet->action_group,
toggle_actions,
G_N_ELEMENTS (toggle_actions),
applet);
gtk_action_group_add_radio_actions (applet->action_group,
mode_actions,
G_N_ELEMENTS(mode_actions),
0,
G_CALLBACK(on_menu_radio_changed),
applet);
gchar *ui_path = g_build_filename(WORKRAVE_MENU_UI_DIR, "workrave-menu.xml", NULL);
mate_panel_applet_setup_menu_from_file(applet->applet, ui_path, applet->action_group);
g_free(ui_path);
gtk_container_add(GTK_CONTAINER(applet->applet), GTK_WIDGET(applet->image));
gtk_widget_show_all(GTK_WIDGET(applet->applet));
}
int vwin_menu_add_radios (windata_t *vwin, const gchar *path,
GtkRadioActionEntry *entries, int n,
int deflt, GCallback callback)
{
guint id = gtk_ui_manager_new_merge_id(vwin->ui);
GtkActionGroup *actions;
int i;
actions = gtk_action_group_new("Radios");
gtk_action_group_set_translation_domain(actions, "gretl");
gtk_action_group_add_radio_actions(actions, entries, n,
deflt, callback,
vwin);
for (i=0; i<n; i++) {
gtk_ui_manager_add_ui(vwin->ui, id, path,
entries[i].name, entries[i].name,
GTK_UI_MANAGER_MENUITEM, FALSE);
}
gtk_ui_manager_insert_action_group(vwin->ui, actions, 0);
g_object_unref(actions);
return id;
}
static void remmina_main_init(RemminaMain *remminamain)
{
RemminaMainPriv *priv;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *hbox;
GtkWidget *quickconnect;
GtkWidget *tool_item;
GtkUIManager *uimanager;
GtkActionGroup *action_group;
GtkWidget *scrolledwindow;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GError *error;
priv = g_new0(RemminaMainPriv, 1);
remminamain->priv = priv;
remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group);
/* Create main window */
g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL);
g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL);
g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0);
gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client"));
gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height);
gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER);
if (remmina_pref.main_maximize)
{
gtk_window_maximize(GTK_WINDOW(remminamain));
}
/* Create the main container */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_container_add(GTK_CONTAINER(remminamain), vbox);
gtk_widget_show(vbox);
/* Create the menubar and toolbar */
uimanager = gtk_ui_manager_new();
priv->uimanager = uimanager;
action_group = gtk_action_group_new("RemminaMainActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries),
remminamain);
gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries,
G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain);
gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries,
G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode,
G_CALLBACK(remmina_main_action_view_file_mode), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->main_group = action_group;
action_group = gtk_action_group_new("RemminaMainFileSensitiveActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries,
G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->file_sensitive_group = action_group;
error = NULL;
gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
}
remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain);
menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar");
#if GTK_VERSION == 3
gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
remmina_main_create_quick_search(remminamain);
gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager));
gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE);
/* Add a Fast Connection box */
#if GTK_VERSION == 3
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif GTK_VERSION == 2
hbox = gtk_hbox_new(FALSE, 0);
#endif
priv->quickconnect_protocol = gtk_combo_box_text_new();
#if GTK_VERSION == 3
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH");
#elif GTK_VERSION == 2
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0);
gtk_widget_show(priv->quickconnect_protocol);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0);
priv->quickconnect_server = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25);
gtk_widget_show(priv->quickconnect_server);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain);
quickconnect = gtk_button_new_with_label("Connect !");
gtk_widget_show(quickconnect);
gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
gtk_widget_show(hbox);
/* Create the scrolled window for the file list */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
/* Create the remmina file list */
tree = gtk_tree_view_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "icon-name", PROTOCOL_COLUMN);
g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
priv->group_column = column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
gtk_widget_show(tree);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func,
remminamain, NULL);
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain);
priv->file_list = tree;
/* Create statusbar */
priv->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_widget_show(priv->statusbar);
/* Prepare the data */
remmina_main_load_files(remminamain, FALSE);
/* Load the preferences */
if (remmina_pref.hide_toolbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")),
FALSE);
}
if (remmina_pref.hide_statusbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")),
FALSE);
}
if (remmina_pref.show_quick_search)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE);
}
if (remmina_pref.small_toolbutton)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE);
}
/* Drag-n-drop support */
gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL);
priv->initialized = TRUE;
remmina_widget_pool_register(GTK_WIDGET(remminamain));
}
void
e_book_shell_view_actions_init (EBookShellView *book_shell_view)
{
EBookShellContent *book_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EPreviewPane *preview_pane;
EWebView *web_view;
GtkActionGroup *action_group;
GConfBridge *bridge;
GtkAction *action;
GObject *object;
const gchar *key;
shell_view = E_SHELL_VIEW (book_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
book_shell_content = book_shell_view->priv->book_shell_content;
searchbar = e_book_shell_content_get_searchbar (book_shell_content);
preview_pane = e_book_shell_content_get_preview_pane (book_shell_content);
web_view = e_preview_pane_get_web_view (preview_pane);
/* Contact Actions */
action_group = ACTION_GROUP (CONTACTS);
gtk_action_group_add_actions (
action_group, contact_entries,
G_N_ELEMENTS (contact_entries), book_shell_view);
e_action_group_add_popup_actions (
action_group, contact_popup_entries,
G_N_ELEMENTS (contact_popup_entries));
gtk_action_group_add_toggle_actions (
action_group, contact_toggle_entries,
G_N_ELEMENTS (contact_toggle_entries), book_shell_view);
gtk_action_group_add_radio_actions (
action_group, contact_view_entries,
G_N_ELEMENTS (contact_view_entries), -1,
G_CALLBACK (action_contact_view_cb), book_shell_view);
gtk_action_group_add_radio_actions (
action_group, contact_search_entries,
G_N_ELEMENTS (contact_search_entries),
-1, NULL, NULL);
/* Advanced Search Action */
action = ACTION (CONTACT_SEARCH_ADVANCED_HIDDEN);
gtk_action_set_visible (action, FALSE);
e_shell_searchbar_set_search_option (
searchbar, GTK_RADIO_ACTION (action));
/* Lockdown Printing Actions */
action_group = ACTION_GROUP (LOCKDOWN_PRINTING);
gtk_action_group_add_actions (
action_group, lockdown_printing_entries,
G_N_ELEMENTS (lockdown_printing_entries),
book_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_printing_popup_entries,
G_N_ELEMENTS (lockdown_printing_popup_entries));
/* Lockdown Save-to-Disk Actions */
action_group = ACTION_GROUP (LOCKDOWN_SAVE_TO_DISK);
gtk_action_group_add_actions (
action_group, lockdown_save_to_disk_entries,
G_N_ELEMENTS (lockdown_save_to_disk_entries),
book_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_save_to_disk_popup_entries,
G_N_ELEMENTS (lockdown_save_to_disk_popup_entries));
/* Bind GObject properties to GConf keys. */
bridge = gconf_bridge_get ();
object = G_OBJECT (ACTION (CONTACT_PREVIEW));
key = "/apps/evolution/addressbook/display/show_preview";
gconf_bridge_bind_property (bridge, key, object, "active");
object = G_OBJECT (ACTION (CONTACT_VIEW_VERTICAL));
key = "/apps/evolution/addressbook/display/layout";
gconf_bridge_bind_property (bridge, key, object, "current-value");
object = G_OBJECT (ACTION (CONTACT_PREVIEW_SHOW_MAPS));
key = "/apps/evolution/addressbook/display/preview_show_maps";
gconf_bridge_bind_property (bridge, key, object, "active");
/* Fine tuning. */
g_signal_connect (
ACTION (GAL_SAVE_CUSTOM_VIEW), "activate",
G_CALLBACK (action_gal_save_custom_view_cb), book_shell_view);
g_object_bind_property (
ACTION (CONTACT_PREVIEW), "active",
ACTION (CONTACT_VIEW_CLASSIC), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
ACTION (CONTACT_PREVIEW), "active",
ACTION (CONTACT_VIEW_VERTICAL), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
ACTION (CONTACT_PREVIEW), "active",
ACTION (CONTACT_PREVIEW_SHOW_MAPS), "sensitive",
G_BINDING_SYNC_CREATE);
e_web_view_set_open_proxy (web_view, ACTION (CONTACT_OPEN));
e_web_view_set_print_proxy (web_view, ACTION (CONTACT_PRINT));
e_web_view_set_save_as_proxy (web_view, ACTION (CONTACT_SAVE_AS));
#ifndef WITH_CONTACT_MAPS
gtk_action_set_visible (ACTION (CONTACT_PREVIEW_SHOW_MAPS), FALSE);
gtk_action_set_visible (ACTION (ADDRESS_BOOK_MAP), FALSE);
gtk_action_set_visible (ACTION (ADDRESS_BOOK_POPUP_MAP), FALSE);
#endif
}
static void
build_ui (EmerillonWindow *self)
{
GtkAction *action;
GtkWidget *vbox;
GtkWidget *menubar;
GtkToolItem *throbber;
GtkWidget *viewport;
GtkWidget *hpaned;
GtkWidget *embed_view;
ClutterActor *scale;
GError *error = NULL;
/* Action entries. */
self->priv->main_actions = gtk_action_group_new ("MenuActionsWindow");
gtk_action_group_set_translation_domain (self->priv->main_actions,
GETTEXT_PACKAGE);
gtk_action_group_add_actions (self->priv->main_actions, action_entries,
G_N_ELEMENTS (action_entries), self);
/* Toggle entries. */
gtk_action_group_add_toggle_actions (self->priv->main_actions,
toggle_entries, G_N_ELEMENTS (toggle_entries), self);
/* Radio entries. */
gtk_action_group_add_radio_actions (self->priv->main_actions,
radio_entries, G_N_ELEMENTS (radio_entries), 0,
G_CALLBACK (cmd_map_change_map), self);
/* Short labels. */
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewZoomIn");
g_object_set (action, "short_label", _("In"), NULL);
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewZoomOut");
g_object_set (action, "short_label", _("Out"), NULL);
/* UI manager. */
self->priv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (self->priv->ui_manager,
self->priv->main_actions, 0);
if (!gtk_ui_manager_add_ui_from_file (self->priv->ui_manager,
EMERILLON_DATADIR "/emerillon-ui.xml", &error))
{
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
return;
}
g_signal_connect (self->priv->ui_manager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), self);
g_signal_connect (self->priv->ui_manager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), self);
gtk_window_add_accel_group (GTK_WINDOW (self),
gtk_ui_manager_get_accel_group (self->priv->ui_manager));
/* Main box. */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (self), vbox);
gtk_widget_show (vbox);
/* Menu. */
menubar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/MainMenu");
g_assert (GTK_IS_WIDGET (menubar));
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* Toolbar. */
self->priv->toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager,
"/Toolbar");
gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->toolbar),
"primary-toolbar");
self->priv->throbber = gtk_spinner_new ();
throbber = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (throbber), self->priv->throbber);
gtk_widget_show (GTK_WIDGET (self->priv->throbber));
gtk_widget_show (GTK_WIDGET (throbber));
gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), throbber,
-1);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->toolbar,
FALSE, FALSE, 0);
gtk_widget_show (self->priv->toolbar);
/* Statusbar. */
self->priv->statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (vbox),
GTK_WIDGET (self->priv->statusbar), FALSE, FALSE, 0);
gtk_widget_show (self->priv->statusbar);
self->priv->tooltip_message_context_id = gtk_statusbar_get_context_id (
GTK_STATUSBAR (self->priv->statusbar), "tooltip-message");
/* Viewport. */
viewport = gtk_frame_new (NULL);
/* Map. */
embed_view = gtk_champlain_embed_new ();
gtk_container_add (GTK_CONTAINER (viewport), embed_view);
/* FIXME: workaround for a champlain-gtk bug, replace with _show(). */
gtk_widget_show_all (embed_view);
self->priv->view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (embed_view));
g_signal_connect (self->priv->view, "notify::zoom-level",
G_CALLBACK (zoom_changed_cb), self);
g_signal_connect (self->priv->view, "notify::map-source",
G_CALLBACK (zoom_changed_cb), self);
g_signal_connect (self->priv->view, "notify::state",
G_CALLBACK (state_changed_cb), self);
g_object_set (self->priv->view, "zoom-level", 1,
"kinetic-mode", TRUE,
NULL);
champlain_view_center_on (self->priv->view, 40, 0);
scale = champlain_scale_new ();
champlain_scale_connect_view (CHAMPLAIN_SCALE (scale), self->priv->view);
/* align to the bottom left */
champlain_view_bin_layout_add (self->priv->view, scale,
CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_END);
/* Sidebar. */
self->priv->sidebar = emerillon_sidebar_new ();
gtk_widget_set_size_request (self->priv->sidebar, 200, -1);
/* Horizontal pane. */
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack1 (GTK_PANED (hpaned), self->priv->sidebar, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (hpaned), viewport, TRUE, FALSE);
gtk_widget_show (self->priv->sidebar);
gtk_widget_show (viewport);
g_signal_connect_after (self->priv->sidebar, "show",
G_CALLBACK (sidebar_visibility_changed_cb), self);
g_signal_connect_after (self->priv->sidebar, "hide",
G_CALLBACK (sidebar_visibility_changed_cb), self);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
update_ui_visibility (self);
}
static void
rb_static_playlist_source_constructed (GObject *object)
{
RBStaticPlaylistSource *source;
RBStaticPlaylistSourcePrivate *priv;
RBPlaylistSource *psource;
RBEntryView *songs;
RBShell *shell;
RhythmDBEntryType *entry_type;
RB_CHAIN_GOBJECT_METHOD (rb_static_playlist_source_parent_class, constructed, object);
source = RB_STATIC_PLAYLIST_SOURCE (object);
priv = RB_STATIC_PLAYLIST_SOURCE_GET_PRIVATE (source);
psource = RB_PLAYLIST_SOURCE (source);
priv->base_model = rb_playlist_source_get_query_model (RB_PLAYLIST_SOURCE (psource));
g_object_set (priv->base_model, "show-hidden", TRUE, NULL);
g_object_ref (priv->base_model);
g_signal_connect_object (priv->base_model,
"filter-entry-drop",
G_CALLBACK (rb_static_playlist_source_filter_entry_drop),
source, 0);
priv->paned = gtk_vpaned_new ();
g_object_get (source, "shell", &shell, NULL);
priv->action_group = _rb_display_page_register_action_group (RB_DISPLAY_PAGE (source),
"StaticPlaylistActions",
NULL, 0,
shell);
if (gtk_action_group_get_action (priv->action_group,
rb_static_playlist_source_radio_actions[0].name) == NULL) {
gtk_action_group_add_radio_actions (priv->action_group,
rb_static_playlist_source_radio_actions,
G_N_ELEMENTS (rb_static_playlist_source_radio_actions),
0,
NULL,
NULL);
rb_source_search_basic_create_for_actions (priv->action_group,
rb_static_playlist_source_radio_actions,
G_N_ELEMENTS (rb_static_playlist_source_radio_actions));
}
priv->default_search = rb_source_search_basic_new (RHYTHMDB_PROP_SEARCH_MATCH);
g_object_unref (shell);
g_object_get (source, "entry-type", &entry_type, NULL);
priv->browser = rb_library_browser_new (rb_playlist_source_get_db (RB_PLAYLIST_SOURCE (source)),
entry_type);
if (entry_type != NULL) {
g_object_unref (entry_type);
}
gtk_paned_pack1 (GTK_PANED (priv->paned), GTK_WIDGET (priv->browser), TRUE, FALSE);
g_signal_connect_object (priv->browser, "notify::output-model",
G_CALLBACK (rb_static_playlist_source_browser_changed_cb),
source, 0);
rb_library_browser_set_model (priv->browser, priv->base_model, FALSE);
rb_static_playlist_source_do_query (source);
/* reparent the entry view */
songs = rb_source_get_entry_view (RB_SOURCE (source));
g_object_ref (songs);
gtk_container_remove (GTK_CONTAINER (source), GTK_WIDGET (songs));
gtk_paned_pack2 (GTK_PANED (priv->paned), GTK_WIDGET (songs), TRUE, FALSE);
gtk_container_add (GTK_CONTAINER (source), priv->paned);
rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (songs), priv->paned, GTK_WIDGET (priv->browser));
g_object_unref (songs);
/* watch these to find out when things are dropped into the entry view */
g_signal_connect_object (priv->base_model, "row-inserted",
G_CALLBACK (rb_static_playlist_source_row_inserted),
source, 0);
g_signal_connect_object (priv->base_model, "non-entry-dropped",
G_CALLBACK (rb_static_playlist_source_non_entry_dropped),
source, 0);
g_signal_connect_object (priv->base_model, "rows-reordered",
G_CALLBACK (rb_static_playlist_source_rows_reordered),
source, 0);
gtk_widget_show_all (GTK_WIDGET (source));
}
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
e_task_shell_view_actions_init (ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EPreviewPane *preview_pane;
EWebView *web_view;
GtkActionGroup *action_group;
GSettings *settings;
GtkAction *action;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
task_shell_content = task_shell_view->priv->task_shell_content;
searchbar = e_task_shell_content_get_searchbar (task_shell_content);
preview_pane = e_task_shell_content_get_preview_pane (task_shell_content);
web_view = e_preview_pane_get_web_view (preview_pane);
/* Task Actions */
action_group = ACTION_GROUP (TASKS);
gtk_action_group_add_actions (
action_group, task_entries,
G_N_ELEMENTS (task_entries), task_shell_view);
e_action_group_add_popup_actions (
action_group, task_popup_entries,
G_N_ELEMENTS (task_popup_entries));
gtk_action_group_add_toggle_actions (
action_group, task_toggle_entries,
G_N_ELEMENTS (task_toggle_entries), task_shell_view);
gtk_action_group_add_radio_actions (
action_group, task_view_entries,
G_N_ELEMENTS (task_view_entries), -1,
G_CALLBACK (action_task_view_cb), task_shell_view);
gtk_action_group_add_radio_actions (
action_group, task_search_entries,
G_N_ELEMENTS (task_search_entries),
-1, NULL, NULL);
/* Advanced Search Action */
action = ACTION (TASK_SEARCH_ADVANCED_HIDDEN);
gtk_action_set_visible (action, FALSE);
e_shell_searchbar_set_search_option (
searchbar, GTK_RADIO_ACTION (action));
/* Lockdown Printing Actions */
action_group = ACTION_GROUP (LOCKDOWN_PRINTING);
gtk_action_group_add_actions (
action_group, lockdown_printing_entries,
G_N_ELEMENTS (lockdown_printing_entries),
task_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_printing_popup_entries,
G_N_ELEMENTS (lockdown_printing_popup_entries));
/* Lockdown Save-to-Disk Actions */
action_group = ACTION_GROUP (LOCKDOWN_SAVE_TO_DISK);
gtk_action_group_add_actions (
action_group, lockdown_save_to_disk_entries,
G_N_ELEMENTS (lockdown_save_to_disk_entries),
task_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_save_to_disk_popup_entries,
G_N_ELEMENTS (lockdown_save_to_disk_popup_entries));
/* Bind GObject properties to settings keys. */
settings = g_settings_new ("org.gnome.evolution.calendar");
g_settings_bind (
settings, "show-task-preview",
ACTION (TASK_PREVIEW), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (
settings, "task-layout",
ACTION (TASK_VIEW_VERTICAL), "current-value",
G_SETTINGS_BIND_DEFAULT);
g_object_unref (settings);
/* Fine tuning. */
g_object_bind_property (
ACTION (TASK_PREVIEW), "active",
ACTION (TASK_VIEW_CLASSIC), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
ACTION (TASK_PREVIEW), "active",
ACTION (TASK_VIEW_VERTICAL), "sensitive",
G_BINDING_SYNC_CREATE);
e_web_view_set_open_proxy (web_view, ACTION (TASK_OPEN));
e_web_view_set_print_proxy (web_view, ACTION (TASK_PRINT));
e_web_view_set_save_as_proxy (web_view, ACTION (TASK_SAVE_AS));
}
/**
* nemo_window_initialize_menus
*
* Create and install the set of menus for this window.
* @window: A recently-created NemoWindow.
*/
void
nemo_window_initialize_menus (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAction *action;
gint i;
if (window->details->ui_manager == NULL){
window->details->ui_manager = gtk_ui_manager_new ();
}
ui_manager = window->details->ui_manager;
/* shell actions */
action_group = gtk_action_group_new ("ShellActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
window->details->main_action_group = action_group;
gtk_action_group_add_actions (action_group,
main_entries, G_N_ELEMENTS (main_entries),
window);
gtk_action_group_add_toggle_actions (action_group,
main_toggle_entries, G_N_ELEMENTS (main_toggle_entries),
window);
gtk_action_group_add_radio_actions (action_group,
main_radio_entries, G_N_ELEMENTS (main_radio_entries),
0, G_CALLBACK (sidebar_radio_entry_changed_cb),
window);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_UP);
g_object_set (action, "short_label", _("_Up"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_HOME);
g_object_set (action, "short_label", _("_Home"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_EDIT_LOCATION);
g_object_set (action, "short_label", _("_Location"), NULL);
action = gtk_action_group_get_action (action_group, NEMO_ACTION_SHOW_HIDDEN_FILES);
g_signal_handlers_block_by_func (action, action_show_hidden_files_callback, window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_HIDDEN_FILES));
g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window);
g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_HIDDEN_FILES,
G_CALLBACK(show_hidden_files_preference_callback),
window);
/* Alt+N for the first 10 tabs */
for (i = 0; i < 10; ++i) {
gchar action_name[80];
gchar accelerator[80];
snprintf(action_name, sizeof (action_name), "Tab%d", i);
action = gtk_action_new (action_name, NULL, NULL, NULL);
g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i));
g_signal_connect (action, "activate",
G_CALLBACK (action_tab_change_action_activate_callback), window);
snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10);
gtk_action_group_add_action_with_accel (action_group, action, accelerator);
g_object_unref (action);
gtk_ui_manager_add_ui (ui_manager,
gtk_ui_manager_new_merge_id (ui_manager),
"/",
action_name,
action_name,
GTK_UI_MANAGER_ACCELERATOR,
FALSE);
}
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
g_object_unref (action_group); /* owned by ui_manager */
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
g_signal_connect (ui_manager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), window);
g_signal_connect (ui_manager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), window);
/* add the UI */
gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/nemo/nemo-shell-ui.xml", NULL);
nemo_window_initialize_trash_icon_monitor (window);
nemo_window_initialize_go_menu (window);
}
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);
}
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;
}
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;
}
/**
* nautilus_window_initialize_menus
*
* Create and install the set of menus for this window.
* @window: A recently-created NautilusWindow.
*/
void
nautilus_window_initialize_menus (NautilusWindow *window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAction *action;
gint i;
window->details->ui_manager = gtk_ui_manager_new ();
ui_manager = window->details->ui_manager;
/* shell actions */
action_group = gtk_action_group_new ("ShellActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
window->details->main_action_group = action_group;
gtk_action_group_add_actions (action_group,
main_entries, G_N_ELEMENTS (main_entries),
window);
gtk_action_group_add_toggle_actions (action_group,
main_toggle_entries, G_N_ELEMENTS (main_toggle_entries),
window);
gtk_action_group_add_radio_actions (action_group,
view_radio_entries, G_N_ELEMENTS (view_radio_entries),
-1, G_CALLBACK (action_view_radio_changed),
window);
action = nautilus_option_menu_action_new ("Zoom Options",
_("Zoom"), _("Zoom Options"), NULL);
gtk_action_group_add_action (action_group, action);
g_object_unref (action);
nautilus_window_menus_set_visibility_for_app_menu (window);
window->details->app_menu_visibility_id =
g_signal_connect_swapped (gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window))),
"notify::gtk-shell-shows-app-menu",
G_CALLBACK (nautilus_window_menus_set_visibility_for_app_menu), window);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_UP);
g_object_set (action, "short_label", _("_Up"), NULL);
action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_HOME);
g_object_set (action, "short_label", _("_Home"), NULL);
/* Alt+N for the first 10 tabs */
for (i = 0; i < 10; ++i) {
gchar action_name[80];
gchar accelerator[80];
snprintf(action_name, sizeof (action_name), "Tab%d", i);
action = gtk_action_new (action_name, NULL, NULL, NULL);
g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i));
g_signal_connect (action, "activate",
G_CALLBACK (action_tab_change_action_activate_callback), window);
snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10);
gtk_action_group_add_action_with_accel (action_group, action, accelerator);
g_object_unref (action);
gtk_ui_manager_add_ui (ui_manager,
gtk_ui_manager_new_merge_id (ui_manager),
"/",
action_name,
action_name,
GTK_UI_MANAGER_ACCELERATOR,
FALSE);
}
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
g_object_unref (action_group); /* owned by ui_manager */
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
g_signal_connect (ui_manager, "connect-proxy",
G_CALLBACK (connect_proxy_cb), window);
/* add the UI */
gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/gnome/nautilus/nautilus-shell-ui.xml", NULL);
/* set actions for option menu items */
populate_option_menu_items (window);
}
int
main(int argc, char **argv)
{
GtkWidget *menubar,
*pri_vbox,
*tabla,
*scroll;
GtkAccelGroup *accel_group;
GtkUIManager *ui_manager;
GtkAction *action;
LIBXML_TEST_VERSION
karakter_betoltes("ruin.xml");
//return 0;
gtk_init(&argc, &argv);
action_group = gtk_action_group_new("main_menu");
action = gtk_action_new("uj-karakter", "Új karakter", "Új karakter létrehozása", GTK_STOCK_NEW);
gtk_action_group_add_action_with_accel(action_group, action, "<Control>N");
action = gtk_action_new("karakter-megnyitas", "Karakter megnyitása", "Elmentett karakter megnyitása", GTK_STOCK_OPEN);
gtk_action_group_add_action_with_accel(action_group, action, "<Control>O");
action = gtk_action_new("karakter-mentes", "Karakter mentése", "Karakter adatainak mentése", GTK_STOCK_SAVE);
gtk_action_group_add_action_with_accel(action_group, action, "<Control>S");
action = gtk_action_new("kilepes", "Kilépés", "Kilépés a programból", GTK_STOCK_QUIT);
gtk_action_group_add_action_with_accel(action_group, action, "<Control>Q");
g_signal_connect(G_OBJECT(action), "activate", G_CALLBACK(kilepes_func), NULL);
action = gtk_action_new("karakter-menu", "Karakter", "Karakter", NULL);
gtk_action_group_add_action(action_group, action);
gtk_action_group_add_radio_actions(action_group, menu_items, nezet_menu_szama, 0, G_CALLBACK(nezet_menu), NULL);
action = gtk_action_new("nezet-menu", "Nézet", "Nézet", NULL);
gtk_action_group_add_action(action_group, action);
ui_manager = gtk_ui_manager_new();
gtk_ui_manager_set_add_tearoffs(ui_manager, FALSE);
gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
gtk_ui_manager_add_ui_from_file(ui_manager, "magus_kargen_res.ui", NULL);
accel_group = gtk_accel_group_new();
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(main_window), "destroy", G_SIGNAL_FUNC(main_window_destroy), NULL);
gtk_window_add_accel_group(GTK_WINDOW(main_window), accel_group);
gtk_window_set_title(GTK_WINDOW(main_window), "M.A.G.U.S. - Reneszánsz karakternyilvántartó");
menubar = gtk_ui_manager_get_widget(ui_manager, "/menu");
book = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(book), TRUE);
gtk_notebook_popup_enable(GTK_NOTEBOOK(book));
g_signal_connect(GTK_OBJECT(book), "change-current-page", G_SIGNAL_FUNC(lapvaltas), NULL);
/* Azonnal látható és hallható dolgok */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(18, 2, FALSE);
azonnal_lathato_dolgok_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(EGYBOL_LATHATO_HALLHATO_DOLGOK));
/* A játékos és a karakter adatai */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(4, 2, FALSE);
jatekos_es_karakter_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(A_JATEKOS_ES_A_KARAKTER_ADATAI));
/* Képességek */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(10, 2, FALSE);
kepessegek_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(KEPESSEGEK));
/* Főbb adatok */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(26, 4, FALSE);
fobb_adatok_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(A_KARAKTER_FOBB_ADATAI));
/* Megjelenés */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(10, 4, FALSE);
megjelenes_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(MEGJELENES));
/* Állandó érzelmek */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(15, 2, FALSE);
erzelmek_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(ALLANDO_ERZELMEK));
/* Szimpatikus viszonyok. Ide majd egy TableView kene */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(SZIMPATIKUS_VISZONYOK));
/* Kapcsolatok, ismertseg. Ide majd egy TableView kene */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ISMERTSEG));
/* Kulonleges kepessegek, hatranyok. Ide is TableView kene */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KULONLEGES_KEPESSEGEK));
/* Tapasztalati pontok, átváltás */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(3, 2, FALSE);
tapasztalat_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(TAPASZTALATI_PONTOK));
/* Képzettségek. Ide majd egy TableView kell */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KEPZETTSEGEK));
/* Nyelvek. Ide is TableView */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(NYELVEK));
/* Harcértékek */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(5, 4, FALSE);
harcertekek_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(HARCERTEKEK));
/* Életerő */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(3, 4, FALSE);
eletero_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(ELETERO));
/* Pszi */
scroll = gtk_scrolled_window_new(NULL, NULL);
tabla = gtk_table_new(5, 2, FALSE);
pszi_lap(GTK_TABLE(tabla));
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla);
gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(PSZI));
/* Mágia */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MAGIA));
/* Fegyverek és pajzsok. Ide két TableView kell. */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(FEGYVEREK_PAJZS));
/* Állatok, csatlósok, szolgák. Ide sok TableView kell */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ALLATOK_CSATLOSOK));
/* Mesterek és tanítók. Ide két TableView kell */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MESTEREK));
/* Földbirtokok. Ide is TableView kell */
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(BIRTOKOK_BEFEKTETESEK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ALAKULATOK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ISKOLAK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MUVEK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ERTEKEK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(RUHAK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(VARAZSTARGYAK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(FELSZERELES));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(VARAZSLATOK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(TANULAS));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(SEBESULESEK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(BETEGSEGEK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(VARAZSLAT_KUTATAS));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KULONLEGES_DOLGOK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MEGJEGYZESEK));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(TORTENET));
gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KEPEK));
pri_vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(pri_vbox), menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(pri_vbox), book, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(main_window), pri_vbox);
gtk_widget_show_all(main_window);
gtk_window_maximize(GTK_WINDOW(main_window));
gtk_main();
xmlCleanupParser();
return 0;
}
GtkWidget *
build_root_selection_frame(ASFileBrowserRootSelFrame *data, GtkWidget *dirlist)
{
GtkTable *table;
GtkWidget *btn ;
GtkActionGroup *action_group ;
GtkWidget *path_combo ;
GtkWidget *path_entry = NULL;
GtkWidget* file_chooser_btn ;
#define ROOT_SELECTION_ENTRIES_NUM 6
static GtkRadioActionEntry root_sel_entries[ROOT_SELECTION_ENTRIES_NUM] = {
{"root_PrivateAfterStep", NULL, "Private AfterStep", NULL,
"Private directory conmtaining AfterStep files. Typically ~/.afterstep",
root_PrivateAfterStep},
{"root_SharedAfterStep", NULL, "Shared AfterStep" , NULL,
"System-wide shared directory conmtaining AfterStep files. Typically /usr/local/share/afterstep",
root_SharedAfterStep},
{"root_Home", NULL, "Home" , NULL,
"Private Home directory",
root_Home},
{"root_UsrShare", NULL, "/usr/share" , NULL,
"System-wide shared files directory /usr/share",
root_UsrShare},
{"root_UsrLocalShare", NULL, "/usr/local/share" , NULL,
"System-wide shared files directory /usr/local/share",
root_UsrLocalShare},
{"root_Other", NULL, "Other : " , NULL,
"Custom location in the filesystem tree",
root_Other},
} ;
int root_sel_cells[ROOT_SELECTION_ENTRIES_NUM][4] =
{ {0, 1, 0, 1},
{1, 2, 0, 1},
{2, 3, 0, 1},
{3, 4, 0, 1},
{4, 5, 0, 1},
{0, 1, 1, 2}
};
int i ;
GtkWidget *frame = gtk_frame_new( NULL );
GtkWidget *hbox = gtk_hbox_new( FALSE, 0 );
GtkWidget *label = gtk_label_new( "Select directory tree to browse : ");
GtkWidget *checkbox = gtk_check_button_new_with_label( "( hide and show entire filesystem )" );
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 5);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, TRUE, TRUE, 5);
gtk_widget_show_all (hbox);
gtk_widget_show (hbox);
gtk_frame_set_label_widget( GTK_FRAME(frame), hbox );
table = GTK_TABLE(gtk_table_new( 5, 2, FALSE ));
g_signal_connect ((gpointer) checkbox, "clicked", G_CALLBACK (on_hide_contents_toggle), data);
gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET(table));
gtk_container_set_border_width( GTK_CONTAINER (frame), 5 );
gtk_container_set_border_width( GTK_CONTAINER (table), 5 );
gtk_table_set_row_spacings( table, 5 );
gtk_table_set_col_spacings( table, 5 );
action_group = gtk_action_group_new( "RootSelection" );
gtk_action_group_add_radio_actions( action_group, root_sel_entries, ROOT_SELECTION_ENTRIES_NUM,
root_PrivateAfterStep, G_CALLBACK(root_selection_changed), data );
for( i = 0 ; i < ROOT_SELECTION_ENTRIES_NUM ; ++i )
{
btn = gtk_toggle_button_new_with_label(root_sel_entries[i].name);
gtk_table_attach_defaults (table, btn, root_sel_cells[i][0], root_sel_cells[i][1],
root_sel_cells[i][2], root_sel_cells[i][3]);
gtk_action_connect_proxy(gtk_action_group_get_action(action_group,root_sel_entries[i].name), btn );
}
path_combo = gtk_combo_box_entry_new_text();
colorize_gtk_edit(path_combo);
file_chooser_btn = gtk_button_new_with_label( "Browse" );
colorize_gtk_edit(path_combo);
hbox = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start (GTK_BOX (hbox), path_combo, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), file_chooser_btn, FALSE, FALSE, 0);
gtk_widget_show_all (hbox);
gtk_table_attach_defaults (table, hbox, 1, 5, 1, 2 );
if( GTK_IS_CONTAINER(path_combo) )
gtk_container_forall( GTK_CONTAINER(path_combo), find_combobox_entry, &path_entry );
/* if above succeeded then path_entry should be not NULL here : */
/* TODO : insert proper change handlers and data pointers here : */
if( path_entry )
g_signal_connect ( G_OBJECT (path_entry), "activate",
G_CALLBACK (NULL), (gpointer) NULL);
g_signal_connect (G_OBJECT(path_combo), "changed",
G_CALLBACK (NULL), (gpointer) NULL);
gtk_widget_show_all (GTK_WIDGET(table));
gtk_widget_show (GTK_WIDGET(table));
gtk_widget_set_size_request ( frame, -1, -1);
colorize_gtk_widget( frame, get_colorschemed_style_normal() );
data->table = GTK_WIDGET(table) ;
data->action_group = action_group ;
data->path_combo = path_combo ;
data->path_entry = path_entry ;
data->file_chooser_btn = file_chooser_btn ;
data->target_dirlist = dirlist ;
return frame;
}
/* Returns a menubar widget made from the above menu */
static GtkWidget *_get_menubar_menu(GtkWidget *window, GtkWidget *notebook)
{
GtkAccelGroup *accel_group = NULL;
GError *error = NULL;
char *ui_description;
GtkActionEntry entries[] = {
{"actions", NULL, "_Actions", "<alt>a"},
{"options", NULL, "_Options", "<alt>o"},
{"displays", NULL, "_Query", "<alt>q"},
{"batch_job", NULL, "Batch Job", "", "Submit batch job",
G_CALLBACK(create_create_popup)},
{"partition", NULL, "Partition", "", "Create partition",
G_CALLBACK(create_create_popup)},
{"reservation", NULL, "Reservation", "", "Create reservation",
G_CALLBACK(create_create_popup)},
{"search", GTK_STOCK_FIND, "Search", ""},
{"jobid", NULL, "Job ID",
"", "Search for jobid",
G_CALLBACK(create_search_popup)},
{"user_jobs", NULL, "Specific User's Job(s)",
"", "Search for a specific users job(s)",
G_CALLBACK(create_search_popup)},
{"state_jobs", NULL, "Job(s) in a Specific State",
"", "Search for job(s) in a specific state",
G_CALLBACK(create_search_popup)},
{"partition_name", NULL, "Slurm Partition Name",
"", "Search for a specific SLURM partition",
G_CALLBACK(create_search_popup)},
{"partition_state", NULL, "Slurm Partition State",
"", "Search for SLURM partitions in a given state",
G_CALLBACK(create_search_popup)},
{"reservation_name", NULL, "Reservation Name",
"", "Search for reservation",
G_CALLBACK(create_search_popup)},
{"tab_pos", NULL, "_Tab Position"},
{"create", GTK_STOCK_ADD, "Create"},
{"interval", GTK_STOCK_REFRESH, "Set Refresh _Interval",
"<control>i", "Change Refresh Interval",
G_CALLBACK(change_refresh_popup)},
{"refresh", GTK_STOCK_REFRESH, "Refresh",
"F5", "Refreshes page", G_CALLBACK(refresh_main)},
{"config", GTK_STOCK_INFO, "_Config Info",
"<control>c", "Displays info from slurm.conf file",
G_CALLBACK(create_config_popup)},
{"dbconfig", GTK_STOCK_INFO, "_Database Config Info",
"<control>d",
"Displays info relevant to the "
"configuration of the Slurm Database.",
G_CALLBACK(create_dbconfig_popup)},
{"exit", GTK_STOCK_QUIT, "E_xit",
"<control>x", "Exits Program", G_CALLBACK(_delete)},
{"help", NULL, "_Help", "<alt>h"},
{"about", GTK_STOCK_ABOUT, "Ab_out", "<control>o",
"About", G_CALLBACK(about_popup)},
{"usage", GTK_STOCK_HELP, "Usage", "",
"Usage", G_CALLBACK(usage_popup)},
//{"manual", GTK_STOCK_HELP, "_Manual", "<control>m"},
{"grid_specs", GTK_STOCK_EDIT, "Set Grid _Properties",
"<control>p", "Change Grid Properties",
G_CALLBACK(change_grid_popup)},
{"defaults", GTK_STOCK_EDIT, "_Set Default Settings",
"<control>s", "Change Default Settings",
G_CALLBACK(configure_defaults)},
};
GtkActionEntry bg_entries[] = {
{"bg_block_name", NULL, "BG Block Name",
"", "Search for a specific BG Block",
G_CALLBACK(create_search_popup)},
{"bg_block_size", NULL, "BG Block Size",
"",
"Search for BG Blocks having given size in cnodes",
G_CALLBACK(create_search_popup)},
{"bg_block_state", NULL, "BG Block State",
"",
"Search for BG Blocks having given state",
G_CALLBACK(create_search_popup)},
{"node_name_bg", NULL,
"Midplane(s) Name",
"", "Search for a specific Midplane(s)",
G_CALLBACK(create_search_popup)},
{"node_state_bg", NULL,
"Midplane State",
"", "Search for a Midplane in a given state",
G_CALLBACK(create_search_popup)},
};
GtkActionEntry nonbg_entries[] = {
{"node_name", NULL,
"Node(s) Name",
"", "Search for a specific Node(s)",
G_CALLBACK(create_search_popup)},
{"node_state", NULL,
"Node State",
"", "Search for a Node in a given state",
G_CALLBACK(create_search_popup)},
};
GtkActionEntry admin_entries[] = {
{"reconfig", GTK_STOCK_REDO, "SLUR_M Reconfigure",
"<control>m", "Reconfigures System",
G_CALLBACK(_reconfigure)},
{"debugflags", GTK_STOCK_DIALOG_WARNING,
"Slurmctld DebugFlags",
"", "Set slurmctld DebugFlags",
G_CALLBACK(_get_current_debug_flags)},
{"debuglevel", GTK_STOCK_DIALOG_WARNING,
"Slurmctld Debug Level",
"", "Set slurmctld debug level",
G_CALLBACK(_get_current_debug)},
};
GtkRadioActionEntry radio_entries[] = {
{"tab_top", GTK_STOCK_GOTO_TOP, "_Top",
"<control>T", "Move tabs to top", GTK_POS_TOP},
{"tab_bottom", GTK_STOCK_GOTO_BOTTOM, "_Bottom",
"<control>B", "Move tabs to the bottom", GTK_POS_BOTTOM},
{"tab_left", GTK_STOCK_GOTO_FIRST, "_Left",
"<control>L", "Move tabs to the Left", GTK_POS_LEFT},
{"tab_right", GTK_STOCK_GOTO_LAST, "_Right",
"<control>R", "Move tabs to the Right", GTK_POS_RIGHT}
};
GtkToggleActionEntry toggle_entries[] = {
{"grid", GTK_STOCK_SELECT_COLOR, "Show _Grid",
"<control>g", "Visual display of cluster",
G_CALLBACK(_set_grid), working_sview_config.show_grid},
{"hidden", GTK_STOCK_SELECT_COLOR, "Show _Hidden",
"<control>h", "Display Hidden Partitions/Jobs",
G_CALLBACK(_set_hidden), working_sview_config.show_hidden},
{"page_opts", GTK_STOCK_SELECT_COLOR, "Save Page Options",
"<control>w", "Save Page Options",
G_CALLBACK(_set_page_opts),
working_sview_config.save_page_opts},
#ifdef WANT_TOPO_ON_MAIN_OPTIONS
{"topoorder", GTK_STOCK_SELECT_COLOR, "Set Topology Grid",
"<control>t", "Set Topology Grid",
G_CALLBACK(_set_topogrid),
working_sview_config.grid_topological},
#endif
{"ruled", GTK_STOCK_SELECT_COLOR, "R_uled Tables",
"<control>u", "Have ruled tables or not",
G_CALLBACK(_set_ruled), working_sview_config.ruled_treeview},
{"admin", GTK_STOCK_PREFERENCES,
"_Admin Mode", "<control>a",
"Allows user to change or update information",
G_CALLBACK(_set_admin_mode),
working_sview_config.admin_mode}
};
GtkRadioActionEntry debug_entries[] = {
{"debug_quiet", NULL, "quiet(0)", "", "Quiet level", 0},
{"debug_fatal", NULL, "fatal(1)", "", "Fatal level", 1},
{"debug_error", NULL, "error(2)", "", "Error level", 2},
{"debug_info", NULL, "info(3)", "", "Info level", 3},
{"debug_verbose", NULL, "verbose(4)", "", "Verbose level", 4},
{"debug_debug", NULL, "debug(5)", "", "Debug debug level", 5},
{"debug_debug2", NULL, "debug2(6)", "", "Debug2 level", 6},
{"debug_debug3", NULL, "debug3(7)", "", "Debug3 level", 7},
{"debug_debug4", NULL, "debug4(8)", "", "Debug4 level", 8},
{"debug_debug5", NULL, "debug5(9)", "", "Debug5 level", 9},
};
char *all_debug_flags = debug_flags2str(0xFFFFFFFFFFFFFFFF);
char *last = NULL;
char *tok = strtok_r(all_debug_flags, ",", &last);
/* set up the global debug_actions */
debug_actions = xmalloc(sizeof(GtkToggleActionEntry));
while (tok) {
xrealloc(debug_actions,
(debug_action_entries + 1)
* sizeof(GtkToggleActionEntry));
debug_actions[debug_action_entries].name =
debug_actions[debug_action_entries].label =
debug_actions[debug_action_entries].tooltip =
xstrdup(tok);
debug_actions[debug_action_entries].callback =
G_CALLBACK(_set_flags);
debug_action_entries++;
tok = strtok_r(NULL, ",", &last);
}
xfree(all_debug_flags);
/* Make an accelerator group (shortcut keys) */
menu_action_group = gtk_action_group_new ("MenuActions");
gtk_action_group_add_actions(menu_action_group, entries,
G_N_ELEMENTS(entries), window);
gtk_action_group_add_actions(menu_action_group, bg_entries,
G_N_ELEMENTS(bg_entries), window);
gtk_action_group_add_actions(menu_action_group, nonbg_entries,
G_N_ELEMENTS(nonbg_entries),
window);
gtk_action_group_add_radio_actions(menu_action_group, radio_entries,
G_N_ELEMENTS(radio_entries),
working_sview_config.tab_pos,
G_CALLBACK(_tab_pos), notebook);
gtk_action_group_add_toggle_actions(menu_action_group, debug_actions,
debug_action_entries, NULL);
gtk_action_group_add_radio_actions(menu_action_group, debug_entries,
G_N_ELEMENTS(debug_entries),
-1, G_CALLBACK(_set_debug),
notebook);
gtk_action_group_add_toggle_actions(menu_action_group, toggle_entries,
G_N_ELEMENTS(toggle_entries),
NULL);
admin_action_group = gtk_action_group_new ("MenuAdminActions");
gtk_action_group_add_actions(admin_action_group, admin_entries,
G_N_ELEMENTS(admin_entries),
window);
gtk_action_group_set_sensitive(admin_action_group,
working_sview_config.admin_mode);
g_ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(g_ui_manager, menu_action_group, 0);
gtk_ui_manager_insert_action_group(g_ui_manager, admin_action_group, 1);
accel_group = gtk_ui_manager_get_accel_group(g_ui_manager);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
ui_description = _get_ui_description();
if (!(g_menu_id = gtk_ui_manager_add_ui_from_string(
g_ui_manager, ui_description, -1, &error))) {
xfree(ui_description);
g_error("building menus failed: %s", error->message);
g_error_free (error);
exit (0);
}
xfree(ui_description);
/* GList *action_list = */
/* gtk_action_group_list_actions(menu_action_group); */
/* GtkAction *action = NULL; */
/* int i=0; */
/* while ((action = g_list_nth_data(action_list, i++))) { */
/* g_print("got %s and %x\n", gtk_action_get_name(action), */
/* action); */
/* } */
/* Get the pointers to the correct action so if we ever need
to change it we can effect the action directly so
everything stays in sync.
*/
default_sview_config.action_admin =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "admin");
default_sview_config.action_grid =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "grid");
default_sview_config.action_hidden =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "hidden");
default_sview_config.action_page_opts =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "page_opts");
// default_sview_config.action_gridtopo =
// (GtkToggleAction *)gtk_action_group_get_action(
// menu_action_group, "topoorder");
default_sview_config.action_ruled =
(GtkToggleAction *)gtk_action_group_get_action(
menu_action_group, "ruled");
/* Pick the first one of the Radio, it is how GTK references
the group in the future.
*/
default_sview_config.action_tab =
(GtkRadioAction *)gtk_action_group_get_action(
menu_action_group, "tab_top");
/* g_print("action grid is %x\n", default_sview_config.action_grid); */
/* Finally, return the actual menu bar created by the item factory. */
return gtk_ui_manager_get_widget (g_ui_manager, "/main");
}
void
e_book_shell_view_actions_init (EBookShellView *book_shell_view)
{
EBookShellContent *book_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EPreviewPane *preview_pane;
EWebView *web_view;
GtkActionGroup *action_group;
GSettings *settings;
GtkAction *action;
shell_view = E_SHELL_VIEW (book_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
book_shell_content = book_shell_view->priv->book_shell_content;
searchbar = e_book_shell_content_get_searchbar (book_shell_content);
preview_pane = e_book_shell_content_get_preview_pane (book_shell_content);
web_view = e_preview_pane_get_web_view (preview_pane);
/* Contact Actions */
action_group = ACTION_GROUP (CONTACTS);
gtk_action_group_add_actions (
action_group, contact_entries,
G_N_ELEMENTS (contact_entries), book_shell_view);
e_action_group_add_popup_actions (
action_group, contact_popup_entries,
G_N_ELEMENTS (contact_popup_entries));
gtk_action_group_add_toggle_actions (
action_group, contact_toggle_entries,
G_N_ELEMENTS (contact_toggle_entries), book_shell_view);
gtk_action_group_add_radio_actions (
action_group, contact_view_entries,
G_N_ELEMENTS (contact_view_entries), -1,
G_CALLBACK (action_contact_view_cb), book_shell_view);
gtk_action_group_add_radio_actions (
action_group, contact_search_entries,
G_N_ELEMENTS (contact_search_entries),
-1, NULL, NULL);
/* Advanced Search Action */
action = ACTION (CONTACT_SEARCH_ADVANCED_HIDDEN);
gtk_action_set_visible (action, FALSE);
e_shell_searchbar_set_search_option (
searchbar, GTK_RADIO_ACTION (action));
/* Lockdown Printing Actions */
action_group = ACTION_GROUP (LOCKDOWN_PRINTING);
gtk_action_group_add_actions (
action_group, lockdown_printing_entries,
G_N_ELEMENTS (lockdown_printing_entries),
book_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_printing_popup_entries,
G_N_ELEMENTS (lockdown_printing_popup_entries));
/* Lockdown Save-to-Disk Actions */
action_group = ACTION_GROUP (LOCKDOWN_SAVE_TO_DISK);
gtk_action_group_add_actions (
action_group, lockdown_save_to_disk_entries,
G_N_ELEMENTS (lockdown_save_to_disk_entries),
book_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_save_to_disk_popup_entries,
G_N_ELEMENTS (lockdown_save_to_disk_popup_entries));
/* Bind GObject properties to GSettings keys. */
settings = e_util_ref_settings ("org.gnome.evolution.addressbook");
g_settings_bind (
settings, "show-preview",
ACTION (CONTACT_PREVIEW), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (
settings, "layout",
ACTION (CONTACT_VIEW_VERTICAL), "current-value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (
settings, "preview-show-maps",
ACTION (CONTACT_PREVIEW_SHOW_MAPS), "active",
G_SETTINGS_BIND_DEFAULT);
g_object_unref (settings);
/* Fine tuning. */
e_binding_bind_property (
ACTION (CONTACT_PREVIEW), "active",
ACTION (CONTACT_VIEW_CLASSIC), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
ACTION (CONTACT_PREVIEW), "active",
ACTION (CONTACT_VIEW_VERTICAL), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
ACTION (CONTACT_PREVIEW), "active",
ACTION (CONTACT_PREVIEW_SHOW_MAPS), "sensitive",
G_BINDING_SYNC_CREATE);
e_web_view_set_open_proxy (web_view, ACTION (CONTACT_OPEN));
e_web_view_set_print_proxy (web_view, ACTION (CONTACT_PRINT));
e_web_view_set_save_as_proxy (web_view, ACTION (CONTACT_SAVE_AS));
#ifndef WITH_CONTACT_MAPS
gtk_action_set_visible (ACTION (CONTACT_PREVIEW_SHOW_MAPS), FALSE);
gtk_action_set_visible (ACTION (ADDRESS_BOOK_MAP), FALSE);
gtk_action_set_visible (ACTION (ADDRESS_BOOK_POPUP_MAP), FALSE);
#endif
}
void
e_task_shell_view_update_search_filter (ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EActionComboBox *combo_box;
GtkActionGroup *action_group;
GtkRadioAction *radio_action;
GList *list, *iter;
GSList *group;
gint ii;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
action_group = ACTION_GROUP (TASKS_FILTER);
e_action_group_remove_all_actions (action_group);
/* Add the standard filter actions. No callback is needed
* because changes in the EActionComboBox are detected and
* handled by EShellSearchbar. */
gtk_action_group_add_radio_actions (
action_group, task_filter_entries,
G_N_ELEMENTS (task_filter_entries),
TASK_FILTER_ANY_CATEGORY, NULL, NULL);
/* Retrieve the radio group from an action we just added. */
list = gtk_action_group_list_actions (action_group);
radio_action = GTK_RADIO_ACTION (list->data);
group = gtk_radio_action_get_group (radio_action);
g_list_free (list);
/* Build the category actions. */
list = e_util_dup_searchable_categories ();
for (iter = list, ii = 0; iter != NULL; iter = iter->next, ii++) {
const gchar *category_name = iter->data;
gchar *filename;
GtkAction *action;
gchar *action_name;
action_name = g_strdup_printf (
"task-filter-category-%d", ii);
radio_action = gtk_radio_action_new (
action_name, category_name, NULL, NULL, ii);
g_free (action_name);
/* Convert the category icon file to a themed icon name. */
filename = e_categories_dup_icon_file_for (category_name);
if (filename != NULL && *filename != '\0') {
gchar *basename;
gchar *cp;
basename = g_path_get_basename (filename);
/* Lose the file extension. */
if ((cp = strrchr (basename, '.')) != NULL)
*cp = '\0';
g_object_set (
radio_action, "icon-name", basename, NULL);
g_free (basename);
}
g_free (filename);
gtk_radio_action_set_group (radio_action, group);
group = gtk_radio_action_get_group (radio_action);
/* The action group takes ownership of the action. */
action = GTK_ACTION (radio_action);
gtk_action_group_add_action (action_group, action);
g_object_unref (radio_action);
}
g_list_free_full (list, g_free);
task_shell_content = task_shell_view->priv->task_shell_content;
searchbar = e_task_shell_content_get_searchbar (task_shell_content);
combo_box = e_shell_searchbar_get_filter_combo_box (searchbar);
e_shell_view_block_execute_search (shell_view);
/* Use any action in the group; doesn't matter which. */
e_action_combo_box_set_action (combo_box, radio_action);
ii = TASK_FILTER_UNMATCHED;
e_action_combo_box_add_separator_after (combo_box, ii);
ii = TASK_FILTER_TASKS_WITH_ATTACHMENTS;
e_action_combo_box_add_separator_after (combo_box, ii);
e_shell_view_unblock_execute_search (shell_view);
}
static GObject *
gam_app_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
GamApp *gam_app;
GamAppPrivate *priv;
GtkWidget *main_box, *mixer, *label;
GError *error;
snd_ctl_t *ctl_handle;
gint result, index = 0;
gchar *card;
object = (* G_OBJECT_CLASS (parent_class)->constructor) (type,
n_construct_properties,
construct_params);
gam_app = GAM_APP (object);
priv = GAM_APP_GET_PRIVATE (gam_app);
g_signal_connect (G_OBJECT (gam_app), "delete_event",
G_CALLBACK (gam_app_delete), NULL);
gtk_window_set_icon_from_file (GTK_WINDOW (gam_app), PIXMAP_ICONDIR"/gnome-alsamixer-icon.png", NULL);
// Build the main menu and toolbar
gtk_action_group_add_actions (priv->main_action_group, action_entries,
G_N_ELEMENTS (action_entries), gam_app);
gtk_action_group_add_radio_actions (priv->main_action_group,
radio_action_entries,
G_N_ELEMENTS (radio_action_entries),
VIEW_ALL,
G_CALLBACK (gam_app_view_mixers_cb),
gam_app);
gtk_ui_manager_insert_action_group (priv->ui_manager, priv->main_action_group, 0);
gtk_window_add_accel_group (GTK_WINDOW (gam_app), priv->ui_accel_group);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string (priv->ui_manager, ui_description, -1, &error)) {
g_message ("building ui failed: %s", error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
g_signal_connect (G_OBJECT (priv->ui_manager), "connect_proxy",
G_CALLBACK (gam_app_ui_connect_proxy_cb), gam_app);
g_signal_connect (G_OBJECT (priv->ui_manager), "disconnect_proxy",
G_CALLBACK (gam_app_ui_disconnect_proxy_cb), gam_app);
do {
card = g_strdup_printf ("hw:%d", index++);
result = snd_ctl_open (&ctl_handle, card, 0);
if (result == 0) {
snd_ctl_close(ctl_handle);
mixer = gam_mixer_new (gam_app, card);
if (gam_mixer_get_visible (GAM_MIXER (mixer)))
gtk_widget_show (mixer);
g_signal_connect (G_OBJECT (mixer), "display_name_changed",
G_CALLBACK (gam_app_mixer_display_name_changed_cb), gam_app);
g_signal_connect (G_OBJECT (mixer), "visibility_changed",
G_CALLBACK (gam_app_mixer_visibility_changed_cb), gam_app);
label = gtk_label_new (gam_mixer_get_display_name (GAM_MIXER (mixer)));
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), mixer, label);
gam_mixer_update_visibility(mixer);
}
g_free (card);
} while (result == 0);
priv->num_cards = index - 1;
// Pack widgets into window
main_box = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (gam_app), main_box);
gtk_box_pack_start (GTK_BOX (main_box), gtk_ui_manager_get_widget (priv->ui_manager, "/MainMenu"),
FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (main_box), priv->status_bar,
FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (main_box));
gtk_box_pack_start (GTK_BOX (main_box), priv->notebook, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (priv->notebook), "switch-page",
G_CALLBACK (gam_app_notebook_switch_page_cb), gam_app);
gam_app_notebook_switch_page_cb(NULL, NULL, 0, gam_app);
gtk_widget_show (priv->notebook);
gam_app_load_prefs (gam_app);
/*gconf_client_notify_add (priv->gconf_client,
"/apps/gnomealsamixer/preferences/tab_position",
(GConfClientNotifyFunc) pawed_app_gconf_notify_func,
pawed_app,
NULL,
NULL);*/
return object;
}
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;
}
}
void
liferea_shell_create (GtkApplication *app, const gchar *overrideWindowState)
{
GtkUIManager *ui_manager;
GtkAccelGroup *accel_group;
GError *error = NULL;
gboolean toggle;
gchar *id;
debug_enter ("liferea_shell_create");
g_object_new (LIFEREA_SHELL_TYPE, NULL);
shell->priv->window = GTK_WINDOW (liferea_shell_lookup ("mainwindow"));
gtk_window_set_application (GTK_WINDOW (shell->priv->window), app);
/* 1.) menu creation */
debug0 (DEBUG_GUI, "Setting up menues");
shell->priv->itemlist = itemlist_create ();
/* Prepare some toggle button states */
conf_get_bool_value (REDUCED_FEEDLIST, &toggle);
liferea_shell_feedlist_toggle_entries[0].is_active = toggle;
ui_manager = gtk_ui_manager_new ();
shell->priv->generalActions = gtk_action_group_new ("GeneralActions");
gtk_action_group_set_translation_domain (shell->priv->generalActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->generalActions, liferea_shell_action_entries, G_N_ELEMENTS (liferea_shell_action_entries), shell->priv);
gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_action_toggle_entries, G_N_ELEMENTS (liferea_shell_action_toggle_entries), shell->priv);
gtk_action_group_add_radio_actions (shell->priv->generalActions, liferea_shell_view_radio_entries, G_N_ELEMENTS (liferea_shell_view_radio_entries), itemlist_get_view_mode (), (GCallback)on_view_activate, (gpointer)TRUE);
gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_feedlist_toggle_entries, G_N_ELEMENTS (liferea_shell_feedlist_toggle_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->generalActions, 0);
shell->priv->addActions = gtk_action_group_new ("AddActions");
gtk_action_group_set_translation_domain (shell->priv->addActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->addActions, liferea_shell_add_action_entries, G_N_ELEMENTS (liferea_shell_add_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->addActions, 0);
shell->priv->feedActions = gtk_action_group_new ("FeedActions");
gtk_action_group_set_translation_domain (shell->priv->feedActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->feedActions, liferea_shell_feed_action_entries, G_N_ELEMENTS (liferea_shell_feed_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->feedActions, 0);
shell->priv->readWriteActions = gtk_action_group_new("ReadWriteActions");
gtk_action_group_set_translation_domain (shell->priv->readWriteActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->readWriteActions, liferea_shell_read_write_action_entries, G_N_ELEMENTS (liferea_shell_read_write_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->readWriteActions, 0);
shell->priv->itemActions = gtk_action_group_new ("ItemActions");
gtk_action_group_set_translation_domain (shell->priv->itemActions, PACKAGE);
gtk_action_group_add_actions (shell->priv->itemActions, liferea_shell_item_action_entries, G_N_ELEMENTS (liferea_shell_item_action_entries), shell->priv);
gtk_ui_manager_insert_action_group (ui_manager, shell->priv->itemActions, 0);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (shell->priv->window), accel_group);
g_object_unref (accel_group);
g_signal_connect (gtk_accel_map_get (), "changed", G_CALLBACK (on_accel_change), NULL);
if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_ui_desc, -1, &error))
g_error ("building menus failed: %s", error->message);
shell->priv->menubar = gtk_ui_manager_get_widget (ui_manager, "/MainwindowMenubar");
shell->priv->toolbar = gtk_ui_manager_get_widget (ui_manager, "/maintoolbar");
/* Ensure GTK3 toolbar shadows... */
gtk_style_context_add_class (gtk_widget_get_style_context (shell->priv->toolbar), "primary-toolbar");
/* what a pain, why is there no markup for this option? */
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/newFeedButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/nextUnreadButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/MarkAsReadButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/UpdateAllButton")), "is_important", TRUE, NULL);
g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/SearchButton")), "is_important", TRUE, NULL);
/* 2.) setup containers */
debug0 (DEBUG_GUI, "Setting up widget containers");
gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, 0);
gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, 0);
gtk_widget_show_all(GTK_WIDGET(shell->priv->toolbar));
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_press_event",
G_CALLBACK (on_key_press_event_null_cb), NULL);
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_release_event",
G_CALLBACK (on_key_press_event_null_cb), NULL);
g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "scroll_event",
G_CALLBACK (on_notebook_scroll_event_null_cb), NULL);
g_signal_connect (G_OBJECT (shell->priv->window), "delete_event", G_CALLBACK(on_close), shell->priv);
g_signal_connect (G_OBJECT (shell->priv->window), "window_state_event", G_CALLBACK(on_window_state_event), shell->priv);
g_signal_connect (G_OBJECT (shell->priv->window), "key_press_event", G_CALLBACK(on_key_press_event), shell->priv);
/* 3.) setup status bar */
debug0 (DEBUG_GUI, "Setting up status bar");
shell->priv->statusbar = GTK_STATUSBAR (liferea_shell_lookup ("statusbar"));
shell->priv->statusbarLocked = FALSE;
shell->priv->statusbarLockTimer = 0;
shell->priv->statusbar_feedsinfo = gtk_label_new("");
gtk_widget_show(shell->priv->statusbar_feedsinfo);
gtk_box_pack_start (GTK_BOX (shell->priv->statusbar), shell->priv->statusbar_feedsinfo, FALSE, FALSE, 5);
/* 4.) setup tabs */
debug0 (DEBUG_GUI, "Setting up tabbed browsing");
shell->priv->tabs = browser_tabs_create (GTK_NOTEBOOK (liferea_shell_lookup ("browsertabs")));
/* 5.) setup feed list */
debug0 (DEBUG_GUI, "Setting up feed list");
shell->priv->feedlistView = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist"));
feed_list_view_init (shell->priv->feedlistView);
/* 6.) setup menu sensivity */
debug0 (DEBUG_GUI, "Initialising menues");
/* On start, no item or feed is selected, so Item menu should be insensitive: */
liferea_shell_update_item_menu (FALSE);
/* necessary to prevent selection signals when filling the feed list
and setting the 2/3 pane mode view */
gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), FALSE);
/* 7.) setup item view */
debug0 (DEBUG_GUI, "Setting up item view");
shell->priv->itemview = itemview_create (GTK_WIDGET (shell->priv->window));
/* 8.) load icons as required */
debug0 (DEBUG_GUI, "Loading icons");
icons_load ();
/* 9.) update and restore all menu elements */
liferea_shell_update_toolbar ();
liferea_shell_update_history_actions ();
liferea_shell_setup_URL_receiver ();
liferea_shell_restore_state (overrideWindowState);
gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), TRUE);
/* 10.) After main window is realized get theme colors and set up feed
list and tray icon */
render_init_theme_colors (GTK_WIDGET (shell->priv->window));
shell->priv->feedlist = feedlist_create ();
g_signal_connect (shell->priv->feedlist, "new-items",
G_CALLBACK (liferea_shell_update_unread_stats), shell->priv->feedlist);
/* 11.) Restore latest selection */
// FIXME: Move to feed list code
if (conf_get_str_value (LAST_NODE_SELECTED, &id)) {
feed_list_view_select (node_from_id (id));
g_free (id);
}
/* 12. Setup shell plugins */
shell->priv->extensions = peas_extension_set_new (PEAS_ENGINE (liferea_plugins_engine_get_default ()),
LIFEREA_TYPE_SHELL_ACTIVATABLE, "shell", shell, NULL);
g_signal_connect (shell->priv->extensions, "extension-added", G_CALLBACK (on_extension_added), shell);
g_signal_connect (shell->priv->extensions, "extension-removed", G_CALLBACK (on_extension_removed), shell);
peas_extension_set_call (shell->priv->extensions, "activate");
/* 14. Rebuild search folders if needed */
if (searchFolderRebuild)
vfolder_foreach (vfolder_rebuild);
debug_exit ("liferea_shell_create");
}
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;
}
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;
}
