void MainWindow::on_btn_menu_clicked()
{
QMenu menu(ui->btn_menu);
PlaylistNode *node = mp_self->player()->current();
while (node)
{
if (node->hasProperty("video_menu"))
{
if (node != mp_self->player()->current())
menu.addSection(node->displayName());
populate_menu(menu, node, "video_menu");
}
else if (node->hasProperty("menu"))
{
if (node != mp_self->player()->current())
menu.addSection(node->displayName());
populate_menu(menu, node, "menu");
}
node = node->parent();
}
if (menu.isEmpty())
menu.addSection("No Actions available for video.");
ui->btn_menu->setMenu(&menu);
ui->btn_menu->showMenu();
ui->btn_menu->setMenu(nullptr);
}
void MainWindow::onLibraryContextMenu(const QPoint &point)
{
QMenu menu(ui->treeView);
if (ui->treeView->selectionModel()->selectedRows().length() < 2)
{
PlaylistNode *node = mp_self->player()->model().getNodeFromIndex(ui->treeView->indexAt(point));
if (node->hasFailed())
{
QAction *a = menu.addAction("Retry");
connect(a, &QAction::triggered, [node, this] () {});
}
if (node->hasProperty("library_context_menu"))
{
populate_menu(menu, node, "library_context_menu");
menu.addSeparator();
}
else if (node->hasProperty("menu"))
{
populate_menu(menu, node, "menu");
menu.addSeparator();
}
}
QAction *a = menu.addAction("Remove");
connect(a, &QAction::triggered, [this](){
for (QModelIndex index : ui->treeView->selectionModel()->selectedIndexes())
mp_self->player()->remove(index);
});
a = menu.addAction("Clear Playlist", mp_self->player(), SLOT(clearPlaylist()));
menu.exec(ui->treeView->mapToGlobal(point));
}
static void
on_bank_added (Ekiga::BankPtr bank,
gpointer data)
{
bank->visit_accounts (boost::bind (&visit_accounts, _1, data));
populate_menu (GTK_WIDGET (data));
}
void
gm_accounts_window_update_account (GtkWidget *accounts_window,
Ekiga::AccountPtr account)
{
std::string presence_icon;
GtkTreeModel *model = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeIter iter;
Ekiga::Account *caccount = NULL;
g_return_if_fail (accounts_window != NULL);
AccountsWindow *self = ACCOUNTS_WINDOW (accounts_window);
/* on the one end we update the view */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->accounts_list));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter)){
do {
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
COLUMN_ACCOUNT, &caccount, -1);
if (caccount == account.get ()) {
presence_icon = account->is_enabled () ? ("user-" + self->priv->presence) : "user-offline";
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COLUMN_ACCOUNT, account.get (),
COLUMN_ACCOUNT_ICON, presence_icon.c_str (),
COLUMN_ACCOUNT_IS_ENABLED, account->is_enabled (),
COLUMN_ACCOUNT_WEIGHT, account->is_enabled () ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL,
COLUMN_ACCOUNT_ACCOUNT_NAME, account->get_name ().c_str (),
COLUMN_ACCOUNT_STATUS, account->get_status ().c_str (),
-1);
break;
}
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
}
/* on the other end, if the updated account is the one which is selected,
* we update the actions on it
*/
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->accounts_list));
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gtk_tree_model_get (model, &iter,
COLUMN_ACCOUNT, &caccount,
-1);
if (caccount == account.get ()) {
self->priv->toolbar.reset ();
account->populate_menu (self->priv->toolbar);
populate_menu (accounts_window);
}
}
}
static gboolean
charpicker_applet_fill (MatePanelApplet *applet)
{
MatePanelAppletOrient orientation;
charpick_data *curr_data;
GdkAtom utf8_atom;
GList *list;
gchar *string;
GtkActionGroup *action_group;
gchar *ui_path;
g_set_application_name (_("Character Palette"));
gtk_window_set_default_icon_name ("accessories-character-map");
mate_panel_applet_set_background_widget (applet, GTK_WIDGET (applet));
mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
curr_data = g_new0 (charpick_data, 1);
curr_data->last_index = NO_LAST_INDEX;
curr_data->applet = GTK_WIDGET (applet);
curr_data->about_dialog = NULL;
curr_data->add_edit_dialog = NULL;
curr_data->settings = mate_panel_applet_settings_new (applet, "org.mate.panel.applet.charpick");
get_chartable (curr_data);
string = g_settings_get_string (curr_data->settings, "current-list");
if (string) {
list = curr_data->chartable;
while (list) {
if (g_ascii_strcasecmp (list->data, string) == 0)
curr_data->charlist = list->data;
list = g_list_next (list);
}
/* FIXME: yeah leak, but this code is full of leaks and evil
point shuffling. This should really be rewritten
-George */
if (curr_data->charlist == NULL)
curr_data->charlist = string;
else
g_free (string);
} else {
curr_data->charlist = curr_data->chartable->data;
}
curr_data->panel_size = mate_panel_applet_get_size (applet);
orientation = mate_panel_applet_get_orient (applet);
curr_data->panel_vertical = (orientation == MATE_PANEL_APPLET_ORIENT_LEFT)
|| (orientation == MATE_PANEL_APPLET_ORIENT_RIGHT);
build_table (curr_data);
g_signal_connect (G_OBJECT (curr_data->applet), "key_press_event",
G_CALLBACK (key_press_event), curr_data);
utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE);
gtk_selection_add_target (curr_data->applet,
GDK_SELECTION_PRIMARY,
utf8_atom,
0);
gtk_selection_add_target (curr_data->applet,
GDK_SELECTION_CLIPBOARD,
utf8_atom,
0);
g_signal_connect (G_OBJECT (curr_data->applet), "selection_get",
G_CALLBACK (charpick_selection_handler),
curr_data);
g_signal_connect (G_OBJECT (curr_data->applet), "selection_clear_event",
G_CALLBACK (selection_clear_cb),
curr_data);
make_applet_accessible (GTK_WIDGET (applet));
/* session save signal */
g_signal_connect (G_OBJECT (applet), "change_orient",
G_CALLBACK (applet_change_orient), curr_data);
g_signal_connect (G_OBJECT (applet), "size_allocate",
G_CALLBACK (applet_size_allocate), curr_data);
g_signal_connect (G_OBJECT (applet), "destroy",
G_CALLBACK (applet_destroy), curr_data);
gtk_widget_show_all (GTK_WIDGET (applet));
action_group = gtk_action_group_new ("Charpicker Applet Actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group,
charpick_applet_menu_actions,
G_N_ELEMENTS (charpick_applet_menu_actions),
curr_data);
ui_path = g_build_filename (CHARPICK_MENU_UI_DIR, "charpick-applet-menu.xml", NULL);
mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (applet),
ui_path, action_group);
g_free (ui_path);
if (mate_panel_applet_get_locked_down (MATE_PANEL_APPLET (applet))) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "Preferences");
gtk_action_set_visible (action, FALSE);
}
g_object_unref (action_group);
register_stock_for_edit ();
populate_menu (curr_data);
return TRUE;
}
/* Public API */
GtkWidget *
accounts_window_new (boost::shared_ptr<Ekiga::AccountCore> account_core,
boost::shared_ptr<Ekiga::PersonalDetails> details)
{
AccountsWindow *self = NULL;
boost::signals::connection conn;
GtkWidget *vbox = NULL;
GtkWidget *menu_bar = NULL;
GtkWidget *menu_item = NULL;
GtkWidget *menu = NULL;
GtkWidget *item = NULL;
GtkWidget *event_box = NULL;
GtkWidget *scroll_window = NULL;
GtkWidget* button_box = NULL;
GtkWidget* button = NULL;
GtkWidget *frame = NULL;
GtkWidget *hbox = NULL;
GtkCellRenderer *renderer = NULL;
GtkListStore *list_store = NULL;
GtkTreeViewColumn *column = NULL;
GtkTreeSelection* selection = NULL;
AtkObject *aobj;
const gchar *column_names [] = {
"",
"",
"",
"",
_("Account Name"),
_("Status")
};
/* The window */
self = (AccountsWindow *) g_object_new (ACCOUNTS_WINDOW_TYPE, NULL);
self->priv = new AccountsWindowPrivate;
self->priv->details = details;
self->priv->account_core = account_core;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_window_set_title (GTK_WINDOW (self), _("Accounts"));
/* The menu */
menu_bar = gtk_menu_bar_new ();
self->priv->accel = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel);
g_object_unref (self->priv->accel);
self->priv->menu_item_core = gtk_menu_item_new_with_mnemonic (_("_Accounts"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_core);
g_object_ref (self->priv->menu_item_core);
menu_item = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), menu_item);
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
item = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_signal_connect (item, "activate", G_CALLBACK (help_callback), NULL);
/* The accounts list store */
list_store = gtk_list_store_new (COLUMN_ACCOUNT_NUMBER,
G_TYPE_POINTER,
G_TYPE_STRING, /* Icon */
G_TYPE_BOOLEAN, /* Is account active? */
G_TYPE_INT,
G_TYPE_STRING, /* Account Name */
G_TYPE_STRING, /* Error Message */
G_TYPE_INT); /* State */
self->priv->accounts_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->priv->accounts_list), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->priv->accounts_list), TRUE);
aobj = gtk_widget_get_accessible (GTK_WIDGET (self->priv->accounts_list));
atk_object_set_name (aobj, _("Accounts"));
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"icon-name", COLUMN_ACCOUNT_ICON);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->accounts_list), column);
/* Add all text renderers */
for (int i = COLUMN_ACCOUNT_ACCOUNT_NAME ; i < COLUMN_ACCOUNT_NUMBER ; i++) {
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (column_names [i],
renderer,
"text",
i,
"weight",
COLUMN_ACCOUNT_WEIGHT,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->accounts_list), column);
gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_sort_column_id (column, i);
}
g_signal_connect (self->priv->accounts_list, "event_after",
G_CALLBACK (account_clicked_cb), self);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->accounts_list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), self);
/* The scrolled window with the accounts list store */
scroll_window = gtk_scrolled_window_new (FALSE, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
event_box = gtk_event_box_new ();
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_container_add (GTK_CONTAINER (event_box), hbox);
frame = gtk_frame_new (NULL);
gtk_widget_set_size_request (GTK_WIDGET (frame), 250, 150);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), scroll_window);
gtk_container_add (GTK_CONTAINER (scroll_window), self->priv->accounts_list);
gtk_container_set_border_width (GTK_CONTAINER (self->priv->accounts_list), 0);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
/* setting up a horizontal button box
* (each button with be dynamically disabled/enabled as needed)
*/
button_box = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_CENTER);
button = gtk_button_new_with_mnemonic (_("_Enable"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("user-available", GTK_BUTTON (button));
button = gtk_button_new_with_mnemonic (_("_Disable"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("user-offline", GTK_BUTTON (button));
button = gtk_button_new_with_mnemonic (_("Edi_t"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("edit", GTK_BUTTON (button));
button = gtk_button_new_with_mnemonic (_("_Remove"));
gtk_box_pack_start (GTK_BOX (button_box), button, FALSE, FALSE, 3);
self->priv->toolbar.add_button ("remove", GTK_BUTTON (button));
gtk_box_pack_start (GTK_BOX (hbox), button_box, FALSE, FALSE, 10);
populate_menu (GTK_WIDGET (self)); // This will add static and dynamic actions
gtk_box_pack_start (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), event_box, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (self), vbox);
gtk_widget_show_all (GTK_WIDGET (vbox));
/* Engine Signals callbacks */
conn = self->priv->account_core->bank_added.connect (boost::bind (&on_bank_added, _1, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->account_added.connect (boost::bind (&on_account_added, _1, _2, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->account_updated.connect (boost::bind (&on_account_updated, _1, _2, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->account_removed.connect (boost::bind (&on_account_removed, _1, _2, self));
self->priv->connections.add (conn);
conn = self->priv->account_core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self));
self->priv->connections.add (conn);
self->priv->presence = self->priv->details->get_presence ();
conn = self->priv->details->updated.connect (boost::bind (&on_personal_details_updated, self, self->priv->details));
self->priv->connections.add (conn);
self->priv->account_core->visit_banks (boost::bind (&on_visit_banks, _1, self));
return GTK_WIDGET (self);
}
/* GTK+ Callbacks */
static gint
account_clicked_cb (G_GNUC_UNUSED GtkWidget *w,
GdkEventButton *event,
gpointer data)
{
AccountsWindow *self = ACCOUNTS_WINDOW (data);
GtkTreePath *path = NULL;
GtkTreeView *tree_view = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
Ekiga::Account *account = NULL;
tree_view = GTK_TREE_VIEW (self->priv->accounts_list);
model = gtk_tree_view_get_model (tree_view);
if (event->type == GDK_BUTTON_PRESS || event->type == GDK_KEY_PRESS || event->type == GDK_2BUTTON_PRESS) {
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view),
(gint) event->x, (gint) event->y,
&path, NULL, NULL, NULL)) {
if (gtk_tree_model_get_iter (model, &iter, path)) {
gtk_tree_model_get (model, &iter,
COLUMN_ACCOUNT, &account,
-1);
gtk_tree_path_free (path);
}
}
}
if (account == NULL)
return FALSE;
if (event->type == GDK_BUTTON_PRESS || event->type == GDK_KEY_PRESS) {
populate_menu (GTK_WIDGET (data));
if (event->button == 3) {
MenuBuilderGtk builder;
account->populate_menu (builder);
if (!builder.empty ()) {
gtk_widget_show_all (builder.menu);
gtk_menu_popup (GTK_MENU (builder.menu), NULL, NULL,
NULL, NULL, event->button, event->time);
g_signal_connect (builder.menu, "hide",
G_CALLBACK (g_object_unref),
(gpointer) builder.menu);
}
g_object_ref_sink (G_OBJECT (builder.menu));
}
}
else if (event->type == GDK_2BUTTON_PRESS) {
Ekiga::TriggerMenuBuilder builder;
account->populate_menu (builder);
}
return TRUE;
}
GtkWidget * make_menu_tab (GtkAccelGroup * accel)
{
GtkWidget * shell = gtk_menu_new ();
populate_menu (shell, tab_items, G_N_ELEMENTS (tab_items), accel);
return shell;
}
GtkWidget * make_menu_bar (GtkAccelGroup * accel)
{
GtkWidget * bar = gtk_menu_bar_new ();
populate_menu (bar, main_items, G_N_ELEMENTS (main_items), accel);
return bar;
}
static void populate_menu (GtkWidget * shell, const struct MenuItem * items,
gint n_items, GtkAccelGroup * accel)
{
for (gint i = 0; i < n_items; i ++)
{
const struct MenuItem * item = & items[i];
GtkWidget * widget = NULL;
if (item->name && item->func) /* normal widget */
{
widget = gtk_image_menu_item_new_with_mnemonic (_(item->name));
g_signal_connect (widget, "activate", item->func, NULL);
if (item->icon)
gtk_image_menu_item_set_image ((GtkImageMenuItem *) widget,
gtk_image_new_from_stock (item->icon, GTK_ICON_SIZE_MENU));
}
else if (item->name && item->get && item->set) /* toggle widget */
{
widget = gtk_check_menu_item_new_with_mnemonic (_(item->name));
gtk_check_menu_item_set_active ((GtkCheckMenuItem *) widget,
item->get ());
g_signal_connect (widget, "toggled", (GCallback) toggled_cb,
(void *) item);
if (item->hook)
{
g_object_set_data ((GObject *) widget, "item", (void *) item);
hook_associate (item->hook, (HookFunction) hook_cb, widget);
g_signal_connect (widget, "destroy", (GCallback) unhook_cb,
(void *) item);
}
}
else if (item->name && (item->items || item->get_sub)) /* submenu */
{
widget = gtk_image_menu_item_new_with_mnemonic (_(item->name));
if (item->icon)
gtk_image_menu_item_set_image ((GtkImageMenuItem *) widget,
gtk_image_new_from_stock (item->icon, GTK_ICON_SIZE_MENU));
GtkWidget * sub;
if (item->get_sub)
sub = item->get_sub ();
else
{
sub = gtk_menu_new ();
populate_menu (sub, item->items, item->n_items, accel);
}
gtk_menu_item_set_submenu ((GtkMenuItem *) widget, sub);
}
else if (item->sep) /* separator */
widget = gtk_separator_menu_item_new ();
if (! widget)
continue;
if (item->key)
gtk_widget_add_accelerator (widget, "activate", accel, item->key,
item->mod, GTK_ACCEL_VISIBLE);
gtk_widget_show (widget);
gtk_menu_shell_append ((GtkMenuShell *) shell, widget);
}
}
