// This callback is responsible for enabling/disabling the appropriate buttons depending on
// the contents of the selection
static void tree_view_selection_changed (GtkTreeSelection *sel, gpointer data)
{
bus_layout_D *dialog = (bus_layout_D *)data ;
gboolean bSomethingSelected = FALSE ;
gboolean bBusSelected = FALSE ;
gboolean bSelectionIsFromBus = FALSE ;
gboolean bFirstSelected = FALSE ;
gboolean bLastSelected = FALSE ;
gboolean bFirstBusSelected = TRUE ;
gboolean bLastBusSelected = TRUE ;
GtkTreePath *tpSelBus = NULL, *tp = NULL ;
GtkTreeModel *tm = NULL ;
int icChildren = -1, Nix ;
tm = gtk_tree_view_get_model (gtk_tree_selection_get_tree_view (sel)) ;
if ((bSelectionIsFromBus = (NULL != (tpSelBus = get_selection_bus (sel, &bSomethingSelected)))))
if (!(bFirstSelected = bLastSelected = bBusSelected = whole_bus_selected_p (sel, tm, tpSelBus)))
if ((icChildren = gtk_tree_model_path_n_children (tm, tpSelBus)) > 0)
{
gtk_tree_path_down (tp = gtk_tree_path_copy (tpSelBus)) ;
bFirstSelected = gtk_tree_selection_path_is_selected (sel, tp) ;
for (Nix = 1 ; Nix < icChildren ; Nix++) gtk_tree_path_next (tp) ;
bLastSelected = gtk_tree_selection_path_is_selected (sel, tp) ;
gtk_tree_path_free (tp) ;
}
if (bSelectionIsFromBus)
determine_first_or_last_bus (tm, tpSelBus, &bFirstBusSelected, &bLastBusSelected) ;
gtk_widget_set_sensitive (dialog->btnCreateBus, bSomethingSelected && !bBusSelected) ;
gtk_widget_set_sensitive (dialog->btnDeleteBus, bSelectionIsFromBus) ;
gtk_widget_set_sensitive (dialog->btnMoveBusUp, bSelectionIsFromBus && !bFirstBusSelected) ;
gtk_widget_set_sensitive (dialog->btnMoveBusDown, bSelectionIsFromBus && !bLastBusSelected) ;
gtk_widget_set_sensitive (dialog->btnMoveCellsUp, bSelectionIsFromBus && !bFirstSelected) ;
gtk_widget_set_sensitive (dialog->btnMoveCellsDown, bSelectionIsFromBus && !bLastSelected) ;
gtk_widget_set_sensitive (dialog->lblBusName, bSelectionIsFromBus) ;
gtk_widget_set_sensitive (dialog->txtBusName, bSelectionIsFromBus) ;
// Fill in the text box with the name of the bus
if (bSelectionIsFromBus)
{
GtkTreeIter itr ;
char *psz = NULL ;
gtk_tree_model_get_iter (tm, &itr, tpSelBus) ;
gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_NAME, &psz, -1) ;
g_signal_handlers_block_matched (G_OBJECT (dialog->txtBusName), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)bus_name_changed, NULL) ;
gtk_entry_set_text (GTK_ENTRY (dialog->txtBusName), psz) ;
g_signal_handlers_unblock_matched (G_OBJECT (dialog->txtBusName), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)bus_name_changed, NULL) ;
g_free (psz) ;
}
if (NULL != (tp = g_object_get_data (G_OBJECT (gtk_tree_selection_get_tree_view (sel)), "tpBus")))
gtk_tree_path_free (tp) ;
g_object_set_data (G_OBJECT (gtk_tree_selection_get_tree_view (sel)), "tpBus", tpSelBus) ;
}
static void
did_not_drag (EphyNodeView *view,
GdkEventButton *event)
{
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkTreePath *path;
tree_view = GTK_TREE_VIEW (view);
selection = gtk_tree_view_get_selection (tree_view);
if (gtk_tree_view_get_path_at_pos (tree_view, event->x, event->y,
&path, NULL, NULL, NULL))
{
if((event->button == 1 || event->button == 2) &&
gtk_tree_selection_path_is_selected (selection, path) &&
!button_event_modifies_selection (event))
{
if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE)
{
gtk_tree_selection_unselect_all (selection);
}
gtk_tree_selection_select_path (selection, path);
}
gtk_tree_path_free (path);
}
}
static void raise_bus_cell_position (GtkWidget *widget, gpointer data)
{
bus_layout_D *dialog = (bus_layout_D *)data ;
GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)) ;
GtkTreeModel *tm = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview)) ;
GtkTreePath *tpBus = g_object_get_data (G_OBJECT (dialog->tview), "tpBus") ;
GtkTreePath *tpSrc = NULL, *tpDst = NULL ;
int icChildren = -1, Nix ;
if (NULL == tpBus) return ;
if (0 == (icChildren = gtk_tree_model_path_n_children (tm, tpBus))) return ;
gtk_tree_path_down (tpDst = gtk_tree_path_copy (tpBus)) ;
gtk_tree_path_next (tpSrc = gtk_tree_path_copy (tpDst)) ;
for (Nix = 1 ; Nix < icChildren ; Nix++)
{
if (gtk_tree_selection_path_is_selected (sel, tpSrc))
{
// swap the 2 rows
swap_model_paths_contents (tm, tpSrc, tpDst) ;
gtk_tree_selection_unselect_path (sel, tpSrc) ;
gtk_tree_selection_select_path (sel, tpDst) ;
}
gtk_tree_path_next (tpSrc) ;
gtk_tree_path_next (tpDst) ;
}
}
static gboolean rc_gui_list2_popup_menu(GtkWidget *widget,
GdkEventButton *event, gpointer data)
{
GtkTreePath *path = NULL;
rc_gui_list2_block_selection(widget, TRUE, -1, -1);
if(event->button!=3 && event->button!=1) return FALSE;
if(event->button==1)
{
if(event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) return FALSE;
if(!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(
rc_ui->list2_tree_view), event->x, event->y, &path, NULL,
NULL, NULL))
return FALSE;
if(gtk_tree_selection_path_is_selected(rc_ui->list2_selection,
path))
{
rc_gui_list2_block_selection(rc_ui->list2_tree_view, FALSE,
event->x, event->y);
}
if(path!=NULL) gtk_tree_path_free(path);
return FALSE;
}
if(gtk_tree_selection_count_selected_rows(rc_ui->list2_selection)>1)
return TRUE;
else return FALSE;
}
static gboolean
select_on_drag_timeout (gpointer data)
{
GtkTreeView *tree_view = data;
GtkTreeSelection *selection;
RbTreeDndData *priv_data;
GDK_THREADS_ENTER ();
priv_data = g_object_get_data (G_OBJECT (tree_view), RB_TREE_DND_STRING);
g_return_val_if_fail(priv_data != NULL, FALSE);
g_return_val_if_fail(priv_data->previous_dest_path != NULL, FALSE);
selection = gtk_tree_view_get_selection(tree_view);
if (!gtk_tree_selection_path_is_selected(selection,priv_data->previous_dest_path)) {
rb_debug("Changing selection because of drag timeout");
gtk_tree_view_set_cursor(tree_view,priv_data->previous_dest_path,NULL,FALSE);
}
priv_data->select_on_drag_timeout = 0;
gtk_tree_path_free(priv_data->previous_dest_path);
priv_data->previous_dest_path = NULL;
GDK_THREADS_LEAVE ();
return FALSE;
}
static gboolean
cb_button_pressed (XfmpcLists *lists,
GdkEventButton *event)
{
XfmpcListsPrivate *priv = XFMPC_LISTS (lists)->priv;
GtkTreeSelection *selection;
GtkTreePath *path;
if (event->type != GDK_BUTTON_PRESS || event->button != 3)
return FALSE;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (priv->treeview),
event->x, event->y,
&path, NULL, NULL, NULL))
{
if (!gtk_tree_selection_path_is_selected (selection, path))
{
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path (selection, path);
}
gtk_tree_path_free (path);
}
popup_menu (lists);
return TRUE;
}
gboolean
on_tree_view_button_pressed (GtkWidget * view,
GdkEventButton * event,
gpointer func)
{
GtkTreeView * tv = GTK_TREE_VIEW (view);
if (event->type == GDK_BUTTON_PRESS && event->button == 3)
{
GtkTreePath * path;
GtkTreeSelection * selection = gtk_tree_view_get_selection (tv);
if (gtk_tree_view_get_path_at_pos (tv,
(gint) event->x,
(gint) event->y,
&path, NULL, NULL, NULL))
{
if (!gtk_tree_selection_path_is_selected (selection, path))
{
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path (selection, path);
}
gtk_tree_path_free (path);
}
if (func != NULL)
((PopupFunc*)func)(view, event);
return TRUE;
}
return FALSE;
}
static gboolean
gimp_component_editor_button_press (GtkWidget *widget,
GdkEventButton *bevent,
GimpComponentEditor *editor)
{
GtkTreeViewColumn *column;
GtkTreePath *path;
editor->clicked_component = -1;
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
bevent->x,
bevent->y,
&path, &column, NULL, NULL))
{
GtkTreeIter iter;
GimpChannelType channel;
gboolean active;
active = gtk_tree_selection_path_is_selected (editor->selection, path);
gtk_tree_model_get_iter (editor->model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (editor->model, &iter,
COLUMN_CHANNEL, &channel,
-1);
editor->clicked_component = channel;
switch (bevent->button)
{
case 1:
if (column != editor->eye_column && bevent->type == GDK_BUTTON_PRESS)
{
GimpImage *image = GIMP_IMAGE_EDITOR (editor)->image;
gimp_image_set_component_active (image, channel, ! active);
gimp_image_flush (image);
}
break;
case 2:
break;
case 3:
gimp_editor_popup_menu (GIMP_EDITOR (editor), NULL, NULL);
break;
default:
break;
}
}
return FALSE;
}
Php::Value GtkTreeSelection_::path_is_selected(Php::Parameters ¶meters)
{
std::string param_path = parameters[0];
GtkTreePath *path = gtk_tree_path_new_from_string(param_path.c_str());
gboolean ret = gtk_tree_selection_path_is_selected (GTK_TREE_SELECTION(instance), path);
return ret;
}
static gboolean on_view_button_press( GtkTreeView* view, GdkEventButton* evt, FindFile* data )
{
if( evt->type == GDK_BUTTON_PRESS )
{
if( evt->button == 3 ) /* right single click */
{
//sfm if current item not selected, unselect all and select it
GtkTreePath *tree_path;
GtkTreeSelection* tree_sel;
gtk_tree_view_get_path_at_pos( GTK_TREE_VIEW( view ),
evt->x, evt->y, &tree_path, NULL, NULL, NULL );
tree_sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
if ( tree_path && tree_sel &&
!gtk_tree_selection_path_is_selected( tree_sel, tree_path ) )
{
gtk_tree_selection_unselect_all( tree_sel );
gtk_tree_selection_select_path( tree_sel, tree_path );
}
gtk_tree_path_free( tree_path );
GtkWidget* popup;
GtkUIManager* menu_mgr;
GtkActionGroup* action_group = gtk_action_group_new ("PopupActions");
gtk_action_group_set_translation_domain( action_group, GETTEXT_PACKAGE );
menu_mgr = gtk_ui_manager_new ();
gtk_action_group_add_actions( action_group, menu_actions, G_N_ELEMENTS(menu_actions), data );
gtk_ui_manager_insert_action_group( menu_mgr, action_group, 0 );
gtk_ui_manager_add_ui_from_string( menu_mgr, menu_def, -1, NULL );
popup = gtk_ui_manager_get_widget( menu_mgr, "/Popup" );
g_object_unref( action_group );
gtk_menu_popup( GTK_MENU( popup ), NULL, NULL, NULL, NULL, evt->button, evt->time );
/* clean up */
g_signal_connect( popup, "selection-done", G_CALLBACK(gtk_widget_destroy), NULL );
g_object_weak_ref( G_OBJECT( popup ), (GWeakNotify)g_object_unref, menu_mgr );
return TRUE;
}
}
else if( evt->type == GDK_2BUTTON_PRESS )
{
if( evt->button == 1 ) /* left double click */
{
on_open_files( NULL, data );
return TRUE;
}
}
return FALSE;
}
static gboolean
select_inverse_foreach_func (GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
GtkamMain *m = GTKAM_MAIN (data);
GtkTreeSelection *s;
s = gtk_tree_view_get_selection (GTK_TREE_VIEW (m->priv->list));
if (gtk_tree_selection_path_is_selected (s, path))
gtk_tree_selection_unselect_path (s, path);
else
gtk_tree_selection_select_path (s, path);
return (FALSE);
}
void EditedTable(GtkCellRendererText *cell, const gchar *path_string, const gchar *new_test, gpointer data)
{
if (actor->dragState == DRAG_TABLE_ROW) return;
GtkTreeModel *model = (GtkTreeModel *)data;
GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
GtkTreeIter iter;
gint column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell), "column"));
gtk_tree_model_get_iter(model, &iter, path);
gint i;
i = gtk_tree_path_get_indices(path)[0];
GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table");
if (gtk_tree_selection_path_is_selected(gtk_tree_view_get_selection(table), path)) {
SetTableFromEdit((char *)new_test, i, column);
}
}
gboolean find_existing_account_mod(GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
gpointer serv;
GtkTreeSelection *selection =
gtk_tree_view_get_selection(GTK_TREE_VIEW(account_list));
gtk_tree_model_get(model, iter, SERVICE_TYPE, &serv, -1);
if (!gtk_tree_selection_path_is_selected(selection, path)
&& !strcasecmp(serv, data)
&& !can_multiaccount(eb_services[get_service_id(data)])) {
return (service_exists = TRUE);
}
return (service_exists = FALSE);
}
/* Called when Remove button is clicked */
static void remove_exclude(GtkButton *button, gpointer user_data)
{
GtkTreeIter sel_iter;
/* Check if selected */
if (gtk_tree_selection_get_selected(exclude_selection, NULL, &sel_iter))
{
/* Delete selected and select next */
GtkTreePath* tree_path = gtk_tree_model_get_path((GtkTreeModel*)exclude_list, &sel_iter);
gtk_list_store_remove(exclude_list, &sel_iter);
gtk_tree_selection_select_path(exclude_selection, tree_path);
/* Select previous if the last row was deleted */
if (!gtk_tree_selection_path_is_selected(exclude_selection, tree_path))
{
if (gtk_tree_path_prev(tree_path))
gtk_tree_selection_select_path(exclude_selection, tree_path);
}
gtk_tree_path_free(tree_path);
}
}
static gboolean select_function(GtkTreeSelection * selection,
GtkTreeModel * model,
GtkTreePath * path,
gboolean path_currently_selected,
gpointer data)
{
GtkTreeIter iter;
FileEntry *fe;
int n;
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get(model, &iter, COLUMN_DATA_F, &fe, COLUMN_DATA_N, &n, -1);
if (gtk_tree_selection_path_is_selected(selection, path))
fe->selected = 0;
else
fe->selected = !0;
return TRUE;
}
static void
device_model_row_changed (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
BluetoothChooser *self = BLUETOOTH_CHOOSER (data);
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
char *address;
/* Not the selection changing? */
if (gtk_tree_selection_path_is_selected (priv->selection, path) == FALSE)
return;
g_object_notify (G_OBJECT (self), "device-selected");
address = bluetooth_chooser_get_selected_device (self);
g_signal_emit (G_OBJECT (self),
selection_table_signals[SELECTED_DEVICE_CHANGED],
0, address);
g_free (address);
}
gboolean cb_files_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
/* catch right-clicks to popup the context menu */
if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
GtkTreePath *path;
GtkTreeSelection *selection = gtk_tree_view_get_selection(tv_files);
gtk_tree_view_get_path_at_pos(tv_files, event->x, event->y, &path, NULL, NULL, NULL);
if (!gtk_tree_selection_path_is_selected(selection, path)) {
gtk_tree_selection_unselect_all(selection);
gtk_tree_selection_select_path(selection, path);
}
gtk_tree_path_free(path);
popup_tree_view_menu();
return TRUE;
}
return FALSE;
}
static void lower_bus_cell_position (GtkWidget *widget, gpointer data)
{
bus_layout_D *dialog = (bus_layout_D *)data ;
GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)) ;
GtkTreeModel *tm = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview)) ;
GtkTreePath *tpBus = g_object_get_data (G_OBJECT (dialog->tview), "tpBus") ;
GtkTreePath *tpSrc = NULL, *tpDst = NULL ;
int icChildren = -1, Nix ;
if (NULL == tpBus)
{
fprintf (stderr, "lower_bus_cell_position: tpBus == NULL !\n") ;
return ;
}
if (0 == (icChildren = gtk_tree_model_path_n_children (tm, tpBus)))
{
fprintf (stderr, "lower_bus_cell_position: tpBus has no children O_o\n") ;
return ;
}
gtk_tree_path_down (tpDst = gtk_tree_path_copy (tpBus)) ;
for (Nix = 1 ; Nix < icChildren ; Nix++) gtk_tree_path_next (tpDst) ;
// St00pid short-circuit if statement to suppress a warning.
if (gtk_tree_path_prev (tpSrc = gtk_tree_path_copy (tpDst))) ;
for (Nix = 1 ; Nix < icChildren ; Nix++)
{
if (gtk_tree_selection_path_is_selected (sel, tpSrc))
{
// swap the 2 rows
swap_model_paths_contents (tm, tpSrc, tpDst) ;
gtk_tree_selection_unselect_path (sel, tpSrc) ;
gtk_tree_selection_select_path (sel, tpDst) ;
}
if (!gtk_tree_path_prev (tpSrc)) break ;
if (!gtk_tree_path_prev (tpDst)) break ;
}
}
static gboolean whole_bus_selected_p (GtkTreeSelection *sel, GtkTreeModel *tm, GtkTreePath *tpSelBus)
{
int Nix ;
int icChildren = -1 ;
GtkTreePath *tp = NULL ;
icChildren = gtk_tree_model_path_n_children (tm, tpSelBus) ;
if (icChildren > 0)
{
gtk_tree_path_down (tp = gtk_tree_path_copy (tpSelBus)) ;
for (Nix = 0 ; Nix < icChildren ; Nix++, gtk_tree_path_next (tp))
if (!gtk_tree_selection_path_is_selected (sel, tp))
break ;
gtk_tree_path_free (tp) ;
return (Nix == icChildren) ;
}
fprintf (stderr, "What ?! The bus had 0 children ?!\n") ;
return TRUE ;
}
/*
* gets tree row reference for an unsected row at the same depth
*/
GtkTreeRowReference* get_unselected_sibling(GtkTreePath *path)
{
GtkTreeRowReference *sibling = NULL;
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
/* move down find first unselected sibling */
GtkTreeIter titer;
gtk_tree_model_get_iter(model, &titer, path);
while (gtk_tree_model_iter_next(model, &titer))
{
if (!gtk_tree_selection_iter_is_selected(selection, &titer))
{
GtkTreePath *sibling_path = gtk_tree_model_get_path(model, &titer);
sibling = gtk_tree_row_reference_new(model, sibling_path);
gtk_tree_path_free(sibling_path);
break;
}
}
if (!sibling)
{
/* move up find first unselected sibling */
GtkTreePath *sibling_path = gtk_tree_path_copy(path);
while (gtk_tree_path_prev(sibling_path))
{
if (!gtk_tree_selection_path_is_selected(selection, sibling_path))
{
sibling = gtk_tree_row_reference_new(model, sibling_path);
break;
}
}
gtk_tree_path_free(sibling_path);
}
return sibling;
}
/* Handle click on treeview */
static gboolean view_click_event(GtkWidget *view, GdkEventButton *event, gpointer user_data){
if(event->button!=3) return FALSE;//let system handle left click
GtkTreePath *path=NULL;
GtkTreeViewColumn *column=NULL;
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view),
(gint)event->x,
(gint)event->y,
&path, &column, NULL, NULL)){
/*clicks within treeview.*/
if(!gtk_tree_selection_path_is_selected(selection, path)){
/*the path clicked is not selected. move selection to this path*/
gtk_tree_selection_unselect_all(selection);
gtk_tree_selection_select_path(selection, path);
}
gtk_tree_path_free(path);
}else{//clicks outsize of treeview. unselect all.
gtk_tree_selection_unselect_all(selection);
path=NULL; column=NULL;
}
//right click popup menu
view_popup_menu(view, user_data);
return TRUE;
}
static gboolean
file_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
gint retval =
GTK_WIDGET_CLASS (file_view_parent_class)->button_press_event (widget,
event);
/* Ignore double-clicks and triple-clicks */
if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
{
GtkTreePath *path;
/* Select file under cursor if not selected */
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
event->x,event->y, &path, NULL, NULL, NULL))
{
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (widget));
if (!gtk_tree_selection_path_is_selected(selection, path))
{
gtk_tree_selection_unselect_all(selection);
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget),
path, NULL, FALSE);
}
gtk_tree_path_free (path);
file_view_do_popup_menu (widget, event);
return TRUE;
}
}
return retval;
}
static gboolean
on_listview_button_press_event (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
//printf("popup menu\n");
g_return_val_if_fail (user_data != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (G_UNLIKELY (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)))) {
// clicked outside of list (e.g. column header)
return FALSE;
}
if (event->type == GDK_BUTTON_PRESS)
{
if (event->button == GDK_BUTTON_SECONDARY)
{
GtkTreeView *view = GTK_TREE_VIEW (widget);
GtkTreePath *path = NULL;
GtkTreeSelection *selection = gtk_tree_view_get_selection (view);
if ((event->state & gtk_accelerator_get_default_mod_mask ()) == 0
&& !gtk_tree_view_get_path_at_pos (view,
event->x,
event->y,
&path,
NULL,
NULL,
NULL))
{
// clicked empty area
gtk_tree_selection_unselect_all (selection);
return FALSE;
}
if (!path) {
return FALSE;
}
if (!gtk_tree_selection_path_is_selected (selection, path)) {
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path (selection, path);
}
GtkBuilder *builder = gtk_builder_new_from_resource ("/org/fsearch/fsearch/menus.ui");
fill_open_with_menu (GTK_TREE_VIEW (widget), builder, path);
GMenu *menu_root = G_MENU (gtk_builder_get_object (builder,
"fsearch_listview_popup_menu"));
GtkWidget *menu_widget = gtk_menu_new_from_model (G_MENU_MODEL (menu_root));
gtk_menu_attach_to_widget (GTK_MENU (menu_widget),
GTK_WIDGET (widget),
NULL);
gtk_menu_popup (GTK_MENU (menu_widget), NULL, NULL, NULL, NULL,
event->button, event->time);
g_object_unref (builder);
return TRUE;
}
}
else if (event->type == GDK_2BUTTON_PRESS) {
if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))) {
GtkTreeViewColumn *column = NULL;
GtkTreePath *path = NULL;
gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
event->x,
event->y,
&path,
&column,
NULL,
NULL);
if (path) {
gtk_tree_path_free(path);
}
}
}
return FALSE;
}
/*
* key has been pressed while being in watch tree view
*/
static gboolean on_watch_key_pressed_callback(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
/* handling only Delete button pressing
* that means "delete selected rows" */
int keyval = ((GdkEventKey*)event)->keyval;
if (keyval != GDK_Delete)
return FALSE;
/* get selected rows */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(wtree));
GList *rows = gtk_tree_selection_get_selected_rows(selection, &wmodel);
/* empty row path */
GtkTreePath *empty_path = wtree_empty_path();
/* check whether only empty row was selected */
if (1 != gtk_tree_selection_count_selected_rows(selection) ||
gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path))
{
/* path reference to select after deleteing finishes */
GtkTreeRowReference *reference_to_select = NULL;
/* get references to the rows */
GList *references = NULL;
GList *iter = rows;
while (iter)
{
GtkTreePath *path = (GtkTreePath*)iter->data;
/* move up paths to the root elements */
while (gtk_tree_path_get_depth(path) > 1)
gtk_tree_path_up(path);
/* add path reference if it's not an empty row*/
if (gtk_tree_path_compare(path, empty_path))
references = g_list_append(references, gtk_tree_row_reference_new(wmodel, path));
iter = iter->next;
}
/* iterate through references and remove */
iter = references;
while (iter)
{
GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data;
/* check for valid reference because two or more equal
refernces could be put in the list if several child items
of the same node were selected and the path for the
current reference was already deleted */
if (gtk_tree_row_reference_valid(reference))
{
GtkTreePath *path = gtk_tree_row_reference_get_path(reference);
if (!reference_to_select)
{
/* select upper sibling of the upper
selected row that has unselected upper sibling */
GtkTreePath *sibling = gtk_tree_path_copy(path);
if(gtk_tree_path_prev(sibling))
{
if (!gtk_tree_selection_path_is_selected(selection, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling);
}
else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling);
}
/* get iterator */
GtkTreeIter titer;
gtk_tree_model_get_iter(wmodel, &titer, path);
/* remove from the debug session, if it's active */
if (DBS_STOPPED == debug_state)
{
gchar *internal = NULL;
gtk_tree_model_get (
wmodel,
&titer,
W_INTERNAL, &internal,
-1);
active_module->remove_watch(internal);
g_free(internal);
}
gtk_tree_store_remove(wstore, &titer);
gtk_tree_path_free(path);
}
iter = iter->next;
}
/* if all (with or without empty row) was selected - set empty row
as a path to be selected after deleting */
if (!reference_to_select)
{
GtkTreePath *path = wtree_empty_path();
reference_to_select = gtk_tree_row_reference_new (gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), path);
gtk_tree_path_free(path);
}
/* set selection */
gtk_tree_selection_unselect_all(selection);
GtkTreePath *path_to_select = gtk_tree_row_reference_get_path(reference_to_select);
gtk_tree_selection_select_path(selection, path_to_select);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget), path_to_select, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(path_to_select);
/* free references list */
g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free (references);
config_set_debug_changed();
}
gtk_tree_path_free(empty_path);
/* free rows list */
g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL);
g_list_free (rows);
return FALSE;
}
/*
* delete selected rows from env variables page
*/
static void delete_selected_rows()
{
/* path to select after deleting finishes */
GtkTreeRowReference *reference_to_select = NULL;
/* empty row path */
GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row);
/* get selected rows */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
GList *rows = gtk_tree_selection_get_selected_rows(selection, &model);
/* check whether only empty row was selected */
if (1 != gtk_tree_selection_count_selected_rows(selection) ||
gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path))
{
/* get references to the selected rows and find out what to
select after deletion */
GList *references = NULL;
GList *iter = rows;
while (iter)
{
GtkTreePath *path = (GtkTreePath*)iter->data;
if (!reference_to_select)
{
/* select upper sibling of the upper
selected row that has unselected upper sibling */
GtkTreePath *sibling = gtk_tree_path_copy(path);
if(gtk_tree_path_prev(sibling))
{
if (!gtk_tree_selection_path_is_selected(selection, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)), sibling);
}
else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)), sibling);
}
if (gtk_tree_path_compare(path, empty_path))
references = g_list_append(references, gtk_tree_row_reference_new(model, path));
iter = iter->next;
}
/* if all (with or without empty row) was selected - set empty row
as a path to be selected after deleting */
if (!reference_to_select)
reference_to_select = gtk_tree_row_reference_copy (empty_row);
iter = references;
while (iter)
{
GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data;
GtkTreePath *path = gtk_tree_row_reference_get_path(reference);
GtkTreeIter titer;
gtk_tree_model_get_iter(model, &titer, path);
gtk_list_store_remove(store, &titer);
gtk_tree_path_free(path);
iter = iter->next;
}
/* set selection */
gtk_tree_selection_unselect_all(selection);
GtkTreePath *path = gtk_tree_row_reference_get_path(reference_to_select);
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree), path, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(path);
/* free references list */
g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free (references);
}
/* free selection reference */
gtk_tree_row_reference_free(reference_to_select);
gtk_tree_path_free(empty_path);
/* free rows list */
g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL);
g_list_free (rows);
}
static gboolean
ephy_node_view_button_press_cb (GtkWidget *treeview,
GdkEventButton *event,
EphyNodeView *view)
{
GtkTreePath *path = NULL;
GtkTreeSelection *selection;
gboolean call_parent = TRUE, path_is_selected;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (treeview)))
{
return GTK_WIDGET_CLASS (parent_class)->button_press_event (treeview, event);
}
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (treeview),
event->x,
event->y,
&path,
NULL, NULL, NULL))
{
path_is_selected = gtk_tree_selection_path_is_selected (selection, path);
if (!gtk_widget_is_focus (GTK_WIDGET (treeview)))
{
gtk_widget_grab_focus (GTK_WIDGET (treeview));
}
if (event->button == 3 && path_is_selected)
{
call_parent = FALSE;
}
if(!button_event_modifies_selection (event) &&
event->button == 1 && path_is_selected &&
gtk_tree_selection_count_selected_rows (selection) > 1)
{
call_parent = FALSE;
}
if (call_parent)
{
GTK_WIDGET_CLASS (parent_class)->button_press_event (treeview, event);
}
if (event->button == 3)
{
gboolean retval;
g_signal_emit_by_name (view, "popup_menu", &retval);
}
else if (event->button == 2)
{
EphyNode *clicked_node;
clicked_node = process_middle_click (path, view);
g_signal_emit (G_OBJECT (view),
ephy_node_view_signals[NODE_MIDDLE_CLICKED], 0, clicked_node);
}
else if (event->button == 1)
{
if (view->priv->toggle_column >= 0)
{
path_toggled (NULL, path, NULL, view);
}
else
{
view->priv->drag_started = FALSE;
view->priv->drag_button = event->button;
view->priv->drag_x = event->x;
view->priv->drag_y = event->y;
}
}
gtk_tree_path_free (path);
}
else
{
gtk_tree_selection_unselect_all (selection);
}
return TRUE;
}
static gboolean
on_button_press_event_recordings_list (GtkWidget *treeview, GdkEventButton *event, gpointer user_data)
{
FreetuxTVApp *app = (FreetuxTVApp *) user_data;
if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
GtkTreeSelection *selection;
GtkTreeModel* model_filter;
GList *list;
gint nbRecordingsTab[TYPERECORDING_COUNT+1] = {0, 0, 0};
GtkTreePath *path;
GtkTreePath *path_selected;
model_filter = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
// Get the selection
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
// Select the path where user has clicked if not selected
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
(gint) event->x, (gint) event->y,
&path_selected, NULL, NULL, NULL)){
if(!gtk_tree_selection_path_is_selected (selection, path_selected)){
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path(selection, path_selected);
}
gtk_tree_path_free(path_selected);
path_selected = NULL;
}
// Get the final list of selected item
list = gtk_tree_selection_get_selected_rows (selection, &model_filter);
//nbTotalGroupsVisible = gtk_tree_model_iter_n_children (GTK_TREE_MODEL(model_filter), NULL);
// Count number of elements selected by category
GList* iterator = NULL;
iterator = g_list_first (list);
while(iterator != NULL){
GtkTreePath *real_path;
GtkTreeIter iter;
// Get the real path
path = (GtkTreePath*)iterator->data;
real_path = gtk_tree_model_filter_convert_path_to_child_path(GTK_TREE_MODEL_FILTER(model_filter), path);
// Look the type of the data in the path
FreetuxTVRecordingInfos* pRecordingInfo;
gtk_tree_model_get_iter (GTK_TREE_MODEL(app->pRecordingList), &iter, real_path);
gtk_tree_model_get(GTK_TREE_MODEL(app->pRecordingList), &iter, RECORDING_COLUMN, &pRecordingInfo, -1);
if(pRecordingInfo != NULL){
switch(pRecordingInfo->status)
{
case FREETUXTV_RECORDING_STATUS_PROCESSING :
case FREETUXTV_RECORDING_STATUS_WAITING :
nbRecordingsTab[TYPERECORDING_INPROGRESS]++;
break;
default:
nbRecordingsTab[TYPERECORDING_TERMINATED]++;
break;
}
nbRecordingsTab[TYPERECORDING_COUNT]++;
}
// Iterate next path
iterator = g_list_next(iterator);
}
GtkWidget *pMenu = NULL;
GtkWidget *pMenuItem;
if(nbRecordingsTab[TYPERECORDING_COUNT] > 0){
pMenu = gtk_menu_new();
g_signal_connect(G_OBJECT(pMenu), "selection-done",
G_CALLBACK(on_popupmenu_selectiondone), app);
// Delete channels from favourites group
pMenuItem = gtk_image_menu_item_new_from_stock ("gtk-delete", NULL);
#if GTK_API_VERSION == 3
gtk_menu_shell_append (GTK_MENU_SHELL (pMenu), pMenuItem);
#else
gtk_menu_append (GTK_MENU (pMenu), pMenuItem);
#endif
g_signal_connect(G_OBJECT(pMenuItem), "activate",
G_CALLBACK(on_popupmenu_activated_recordingdelete), app);
gtk_widget_show (pMenuItem);
}
if(pMenu){
gtk_widget_show(pMenu);
gtk_menu_popup(GTK_MENU(pMenu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent*)event));
}
return TRUE;
}
return FALSE;
}
static gboolean
egg_tree_multi_drag_button_press_event (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
GtkTreeView *tree_view;
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
gint cell_x, cell_y;
GtkTreeSelection *selection;
EggTreeMultiDndData *priv_data;
if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)))
return FALSE;
if (event->button == 3)
return FALSE;
tree_view = GTK_TREE_VIEW (widget);
priv_data = g_object_get_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING);
if (priv_data == NULL)
{
priv_data = g_new0 (EggTreeMultiDndData, 1);
priv_data->pending_event = FALSE;
g_object_set_data (G_OBJECT (tree_view),
EGG_TREE_MULTI_DND_STRING,
priv_data);
}
if (g_slist_find (priv_data->event_list, event))
return FALSE;
if (priv_data->pending_event)
{
/* save the event to be propagated in order */
priv_data->event_list = g_slist_append (priv_data->event_list,
gdk_event_copy ((GdkEvent*)event));
return TRUE;
}
if (event->type == GDK_2BUTTON_PRESS)
return FALSE;
gtk_tree_view_get_path_at_pos (tree_view,
event->x, event->y,
&path, &column,
&cell_x, &cell_y);
selection = gtk_tree_view_get_selection (tree_view);
if (path)
{
gboolean call_parent = (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK) ||
!gtk_tree_selection_path_is_selected (selection, path) ||
event->button != 1);
if (call_parent)
(GTK_WIDGET_GET_CLASS (tree_view))->button_press_event (widget, event);
if (gtk_tree_selection_path_is_selected (selection, path))
{
priv_data->pressed_button = event->button;
priv_data->x = event->x;
priv_data->y = event->y;
priv_data->pending_event = TRUE;
if (!call_parent)
priv_data->event_list = g_slist_append (priv_data->event_list,
gdk_event_copy ((GdkEvent*)event));
if (priv_data->motion_notify_handler == 0)
{
priv_data->motion_notify_handler =
g_signal_connect (G_OBJECT (tree_view),
"motion_notify_event",
G_CALLBACK (egg_tree_multi_drag_motion_event),
NULL);
}
if (priv_data->button_release_handler == 0)
{
priv_data->button_release_handler =
g_signal_connect (G_OBJECT (tree_view),
"button_release_event",
G_CALLBACK (egg_tree_multi_drag_button_release_event),
NULL);
}
if (priv_data->drag_data_get_handler == 0)
{
priv_data->drag_data_get_handler =
g_signal_connect (G_OBJECT (tree_view),
"drag_data_get",
G_CALLBACK (egg_tree_multi_drag_drag_data_get),
NULL);
}
}
gtk_tree_path_free (path);
/* We called the default handler so we don't let the default handler run */
return TRUE;
}
return FALSE;
}
static gboolean
egg_tree_multi_drag_button_press_event (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
GtkTreeView *tree_view;
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
gint cell_x, cell_y;
GtkTreeSelection *selection;
EggTreeMultiDndData *priv_data;
tree_view = GTK_TREE_VIEW (widget);
priv_data = g_object_get_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING);
if (priv_data == NULL)
{
priv_data = g_new0 (EggTreeMultiDndData, 1);
g_object_set_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING, priv_data);
}
if (g_slist_find (priv_data->event_list, event))
return FALSE;
if (priv_data->event_list)
{
/* save the event to be propagated in order */
priv_data->event_list = g_slist_append (priv_data->event_list, gdk_event_copy ((GdkEvent*)event));
return TRUE;
}
if (event->type == GDK_2BUTTON_PRESS)
return FALSE;
if (event->button == 3)
return FALSE;
gtk_tree_view_get_path_at_pos (tree_view,
event->x, event->y,
&path, &column,
&cell_x, &cell_y);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
if (path && gtk_tree_selection_path_is_selected (selection, path))
{
priv_data->pressed_button = event->button;
priv_data->x = event->x;
priv_data->y = event->y;
priv_data->event_list = g_slist_append (priv_data->event_list, gdk_event_copy ((GdkEvent*)event));
priv_data->motion_notify_handler =
g_signal_connect (G_OBJECT (tree_view), "motion_notify_event", G_CALLBACK (egg_tree_multi_drag_motion_event), NULL);
priv_data->button_release_handler =
g_signal_connect (G_OBJECT (tree_view), "button_release_event", G_CALLBACK (egg_tree_multi_drag_button_release_event), NULL);
if (priv_data->drag_data_get_handler == 0)
{
priv_data->drag_data_get_handler =
g_signal_connect (G_OBJECT (tree_view), "drag_data_get", G_CALLBACK (egg_tree_multi_drag_drag_data_get), NULL);
}
gtk_tree_path_free (path);
return TRUE;
}
if (path)
{
gtk_tree_path_free (path);
}
return FALSE;
}
gboolean on_btn_pressed(GtkWidget* view, GdkEventButton* evt, FmFolderView* fv)
{
GList* sels;
FmFolderViewClickType type = 0;
GtkTreePath* tp;
if(!fv->model)
return FALSE;
/* FIXME: handle single click activation */
if( evt->type == GDK_BUTTON_PRESS )
{
/* special handling for ExoIconView */
if(evt->button != 1)
{
if(fv->mode==FM_FV_ICON_VIEW || fv->mode==FM_FV_COMPACT_VIEW || fv->mode==FM_FV_THUMBNAIL_VIEW)
{
/* select the item on right click for ExoIconView */
if(exo_icon_view_get_item_at_pos(EXO_ICON_VIEW(view), evt->x, evt->y, &tp, NULL))
{
/* if the hit item is not currently selected */
if(!exo_icon_view_path_is_selected(EXO_ICON_VIEW(view), tp))
{
sels = exo_icon_view_get_selected_items((const struct ExoIconView *)(const struct ExoIconView *)view);
if( sels ) /* if there are selected items */
{
exo_icon_view_unselect_all(EXO_ICON_VIEW(view)); /* unselect all items */
g_list_foreach(sels, (GFunc)gtk_tree_path_free, NULL);
g_list_free(sels);
}
exo_icon_view_select_path(EXO_ICON_VIEW(view), tp);
exo_icon_view_set_cursor(EXO_ICON_VIEW(view), tp, NULL, FALSE);
}
gtk_tree_path_free(tp);
}
}
else if( fv->mode == FM_FV_LIST_VIEW
&& evt->window == gtk_tree_view_get_bin_window(GTK_TREE_VIEW(view)))
{
/* special handling for ExoTreeView */
/* Fix #2986834: MAJOR PROBLEM: Deletes Wrong File Frequently. */
GtkTreeViewColumn* col;
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), evt->x, evt->y, &tp, &col, NULL, NULL))
{
GtkTreeSelection* tree_sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if(!gtk_tree_selection_path_is_selected(tree_sel, tp))
{
gtk_tree_selection_unselect_all(tree_sel);
if(col == exo_tree_view_get_activable_column(EXO_TREE_VIEW(view)))
{
gtk_tree_selection_select_path(tree_sel, tp);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), tp, NULL, FALSE);
}
}
gtk_tree_path_free(tp);
}
}
}
if(evt->button == 2) /* middle click */
type = FM_FV_MIDDLE_CLICK;
else if(evt->button == 3) /* right click */
type = FM_FV_CONTEXT_MENU;
}
if( type != FM_FV_CLICK_NONE )
{
sels = fm_folder_view_get_selected_tree_paths(fv);
if( sels || type == FM_FV_CONTEXT_MENU )
{
item_clicked(fv, sels ? sels->data : NULL, type);
if(sels)
{
g_list_foreach(sels, (GFunc)gtk_tree_path_free, NULL);
g_list_free(sels);
}
}
}
return FALSE;
}
