/**
* clear and fill the reconciliation tree with the accounts,
* and for each account, set the method of payments in the good order
*
* \param
*
* \return
*/
void gsb_reconcile_sort_config_fill ( void )
{
GtkTreeIter account_iter, payment_method_iter;
GSList *list_tmp;
GtkTreeModel *model;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (reconcile_treeview));
gtk_tree_store_clear (GTK_TREE_STORE (model));
list_tmp = gsb_data_account_get_list_accounts ();
while ( list_tmp )
{
gint account_number;
GSList *sorted_list;
GSList *payment_list;
gboolean visible;
account_number = gsb_data_account_get_no_account ( list_tmp -> data );
/* when no method of payment, hide the checkbuttons because non sense */
payment_list = gsb_data_payment_get_list_for_account (account_number);
if (payment_list)
{
visible = TRUE;
g_slist_free (payment_list);
}
else
visible = FALSE;
gtk_tree_store_append (GTK_TREE_STORE (model), &account_iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (model), &account_iter,
RECONCILIATION_SORT_NAME_COLUMN, gsb_data_account_get_name (account_number),
RECONCILIATION_SORT_VISIBLE_COLUMN, visible,
RECONCILIATION_SORT_SORT_COLUMN, gsb_data_account_get_reconcile_sort_type(account_number),
RECONCILIATION_SORT_SPLIT_NEUTRAL_COLUMN, gsb_data_account_get_split_neutral_payment (account_number),
RECONCILIATION_SORT_ACCOUNT_COLUMN, account_number,
RECONCILIATION_SORT_TYPE_COLUMN, 0,
RECONCILIATION_SORT_SENSITIVE_COLUMN, visible,
-1 );
/* the sorted list is a list of numbers of method of payment, in the good order */
sorted_list = gsb_data_account_get_sort_list (account_number);
while ( sorted_list )
{
gint payment_number;
/* in the sorted list, a number can be negative, when split a neutral into 2 parts
* so payment number here can be negative for neutral payments */
payment_number = GPOINTER_TO_INT (sorted_list -> data);
if (payment_number)
{
gchar *name = NULL;
gtk_tree_store_append (GTK_TREE_STORE (model),
&payment_method_iter,
&account_iter);
/* if split the neutrals, show here with the name */
switch (gsb_data_payment_get_sign (abs (payment_number)))
{
case GSB_PAYMENT_DEBIT:
case GSB_PAYMENT_CREDIT:
name = my_strdup (gsb_data_payment_get_name (payment_number));
break;
case GSB_PAYMENT_NEUTRAL:
if (gsb_data_account_get_split_neutral_payment (account_number))
{
/* the neutrals are splitted */
if (payment_number < 0)
name = g_strconcat ( gsb_data_payment_get_name (-payment_number),
" ( - )", NULL );
else
name = g_strconcat ( gsb_data_payment_get_name (payment_number),
" ( + )", NULL );
}
else
name = my_strdup (gsb_data_payment_get_name (payment_number));
break;
}
gtk_tree_store_set (GTK_TREE_STORE (model), &payment_method_iter,
RECONCILIATION_SORT_NAME_COLUMN, name,
RECONCILIATION_SORT_VISIBLE_COLUMN, FALSE,
RECONCILIATION_SORT_SORT_COLUMN, FALSE,
RECONCILIATION_SORT_SPLIT_NEUTRAL_COLUMN, FALSE,
RECONCILIATION_SORT_ACCOUNT_COLUMN, account_number,
RECONCILIATION_SORT_TYPE_COLUMN, payment_number,
RECONCILIATION_SORT_SENSITIVE_COLUMN, TRUE,
-1 );
if (name)
g_free (name);
}
sorted_list = sorted_list -> next;
}
if ( gtk_tree_model_iter_has_child( GTK_TREE_MODEL(model), &account_iter)
&&
gsb_data_account_get_reconcile_sort_type (account_number) )
{
GtkTreePath * treepath;
treepath = gtk_tree_model_get_path (GTK_TREE_MODEL(model), &account_iter);
if ( treepath )
{
gtk_tree_view_expand_row ( GTK_TREE_VIEW(reconcile_treeview), treepath, TRUE );
gtk_tree_path_free ( treepath );
}
}
list_tmp = list_tmp -> next;
}
}
// Implements the selection constraints for the available cells tree view
static gboolean select_cell_row_p (GtkTreeSelection *sel, GtkTreeModel *tm, GtkTreePath *tp, gboolean bSelStatus, gpointer data)
{
int Nix ;
static gboolean bIgnore = FALSE ;
int this_row_type = -1 ;
GtkTreeIter itr ;
if (bIgnore) return TRUE ;
gtk_tree_model_get_iter (tm, &itr, tp) ;
gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &this_row_type, -1) ;
if (this_row_type & ROW_TYPE_BUS)
{
GtkTreePath *tpNew = NULL ;
int icChildren = gtk_tree_model_iter_n_children (tm, &itr) ;
int x, y ;
GdkModifierType mask ;
if (bSelStatus)
{
bIgnore = TRUE ;
gtk_tree_selection_unselect_path (sel, tp) ;
bIgnore = FALSE ;
}
gtk_tree_view_expand_row (gtk_tree_selection_get_tree_view (sel), tp, TRUE) ;
if (icChildren > 0)
{
// I should be able to programmatically simulate a "click" event, because its meaning depends
// on whether Ctrl or Shift are held down. I should not have to reproduce that behaviour here,
// because it may change in the future. I need to simulate a "click" event because I would like to
// implement the following: Clicking on a bus is equivalent to clicking on all its inputs
gdk_window_get_pointer (GTK_WIDGET (gtk_tree_selection_get_tree_view (sel))->window, &x, &y, &mask) ;
gtk_tree_path_down (tpNew = gtk_tree_path_copy (tp)) ;
bSelStatus = gtk_tree_selection_path_is_selected (sel, tpNew) ;
for (Nix = 0 ; Nix < icChildren ; Nix++, gtk_tree_path_next (tpNew))
if ((mask & GDK_CONTROL_MASK))
{
if (bSelStatus)
gtk_tree_selection_unselect_path (sel, tpNew) ;
else
gtk_tree_selection_select_path (sel, tpNew) ;
}
else
gtk_tree_selection_select_path (sel, tpNew) ;
gtk_tree_path_free (tpNew) ;
}
return FALSE ;
}
else
if (this_row_type & ROW_TYPE_CELL)
{
if (!bSelStatus)
{
DESELECT_DIFFERENT_CELLS_STRUCT ddcs = {NULL, 0} ;
ddcs.sel = sel ;
ddcs.row_type = this_row_type ;
gtk_tree_selection_selected_foreach (sel, deselect_other_type_of_cells, &ddcs) ;
}
}
return TRUE ;
}
static void
ref_count_delete_row (void)
{
GtkTreeIter grandparent1, grandparent2, parent1, parent2;
GtkTreeIter iter_parent1, iter_parent2;
GtkTreeModel *model;
GtkTreeModelRefCount *ref_model;
GtkTreeModel *sort_model;
GtkTreePath *path;
GtkWidget *tree_view;
model = gtk_tree_model_ref_count_new ();
ref_model = GTK_TREE_MODEL_REF_COUNT (model);
/* + grandparent1
* + grandparent2
* + parent1
* + iter_parent1
* + parent2
* + iter_parent2
* + iter_parent2
*/
gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
assert_entire_model_unreferenced (ref_model);
sort_model = gtk_tree_model_sort_new_with_model (model);
tree_view = gtk_tree_view_new_with_model (sort_model);
assert_root_level_referenced (ref_model, 1);
assert_node_ref_count (ref_model, &parent1, 0);
assert_node_ref_count (ref_model, &parent2, 0);
assert_level_unreferenced (ref_model, &parent1);
assert_level_unreferenced (ref_model, &parent2);
path = gtk_tree_path_new_from_indices (1, -1);
gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
gtk_tree_path_free (path);
assert_node_ref_count (ref_model, &grandparent1, 1);
assert_node_ref_count (ref_model, &grandparent2, 2);
assert_node_ref_count (ref_model, &parent1, 2);
assert_node_ref_count (ref_model, &parent2, 2);
assert_node_ref_count (ref_model, &iter_parent1, 1);
assert_node_ref_count (ref_model, &iter_parent2, 1);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2);
assert_node_ref_count (ref_model, &grandparent1, 1);
assert_node_ref_count (ref_model, &grandparent2, 2);
assert_node_ref_count (ref_model, &parent1, 2);
assert_level_referenced (ref_model, 1, &parent1);
assert_node_ref_count (ref_model, &parent2, 2);
assert_level_referenced (ref_model, 1, &parent2);
gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1);
assert_node_ref_count (ref_model, &grandparent1, 1);
assert_node_ref_count (ref_model, &grandparent2, 2);
assert_node_ref_count (ref_model, &parent2, 2);
assert_level_referenced (ref_model, 1, &parent2);
gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2);
assert_node_ref_count (ref_model, &grandparent1, 1);
gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
assert_node_ref_count (ref_model, &grandparent1, 1);
gtk_widget_destroy (tree_view);
assert_entire_model_unreferenced (ref_model);
g_object_unref (sort_model);
g_object_unref (ref_model);
}
gboolean on_dir_tree_view_button_press( GtkWidget* view,
GdkEventButton* evt,
PtkFileBrowser* browser )
{
GtkTreeModel* model;
GtkTreePath* tree_path;
GtkTreeViewColumn* tree_col;
GtkTreeIter it;
if ( evt->type == GDK_BUTTON_PRESS &&
( evt->button == 1 || evt->button == 3 ) )
{
// middle click 2 handled in ptk-file-browser.c on_dir_tree_button_press
model = gtk_tree_view_get_model( GTK_TREE_VIEW( view ) );
if ( gtk_tree_view_get_path_at_pos( GTK_TREE_VIEW( view ),
evt->x, evt->y, &tree_path,
&tree_col, NULL, NULL ) )
{
if ( gtk_tree_model_get_iter( model, &it, tree_path ) )
{
gtk_tree_view_set_cursor( GTK_TREE_VIEW( view ),
tree_path,
tree_col, FALSE );
if ( evt->button == 3 )
{
// right click
char* dir_path = ptk_dir_tree_view_get_selected_dir(
GTK_TREE_VIEW( view ) );
if ( ptk_file_browser_chdir( browser, dir_path,
PTK_FB_CHDIR_ADD_HISTORY ) )
{
/* show right-click menu
* This simulates a right-click in the file list when
* no files are selected (even if some are) since
* actions are to be taken on the dir itself. */
GtkWidget* popup = ptk_file_menu_new( NULL, browser,
NULL, NULL,
dir_path, NULL );
if ( popup )
gtk_menu_popup( GTK_MENU( popup ), NULL, NULL,
NULL, NULL, 3, 0 );
gtk_tree_path_free( tree_path );
return TRUE;
}
}
else
gtk_tree_view_row_activated( GTK_TREE_VIEW( view ),
tree_path,
tree_col );
}
gtk_tree_path_free( tree_path );
}
}
else if ( evt->type == GDK_2BUTTON_PRESS && evt->button == 1 )
{
// double click - expand/collapse
if ( gtk_tree_view_get_path_at_pos( GTK_TREE_VIEW( view ),
evt->x, evt->y, &tree_path,
NULL, NULL, NULL ) )
{
if ( gtk_tree_view_row_expanded( GTK_TREE_VIEW( view ),
tree_path ) )
gtk_tree_view_collapse_row( GTK_TREE_VIEW( view ), tree_path );
else
gtk_tree_view_expand_row( GTK_TREE_VIEW( view ), tree_path,
FALSE );
gtk_tree_path_free( tree_path );
return TRUE;
}
}
return FALSE;
}
gboolean on_dir_tree_view_key_press( GtkWidget* view,
GdkEventKey* evt,
PtkFileBrowser* browser )
{
VFSFileInfo* file;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if(!gtk_tree_selection_get_selected(select, &model, &iter))
return FALSE;
int keymod = ( evt->state & ( GDK_SHIFT_MASK | GDK_CONTROL_MASK |
GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK ) );
GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
switch( evt->keyval ) {
case GDK_KEY_Left:
if(gtk_tree_view_row_expanded(GTK_TREE_VIEW(view), path)) {
gtk_tree_view_collapse_row(GTK_TREE_VIEW(view), path);
} else if(gtk_tree_path_up(path)) {
gtk_tree_selection_select_path(select, path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL, FALSE);
} else {
gtk_tree_path_free( path );
return FALSE;
}
break;
case GDK_KEY_Right:
if(!gtk_tree_view_row_expanded(GTK_TREE_VIEW(view), path)) {
gtk_tree_view_expand_row(GTK_TREE_VIEW(view), path, FALSE);
} else {
gtk_tree_path_down(path);
gtk_tree_selection_select_path(select, path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL, FALSE);
}
break;
case GDK_KEY_F10:
case GDK_KEY_Menu:
if ( evt->keyval == GDK_KEY_F10 && keymod != GDK_SHIFT_MASK )
{
gtk_tree_path_free( path );
return FALSE;
}
char* dir_path = ptk_dir_tree_view_get_selected_dir(
GTK_TREE_VIEW( view ) );
if ( ptk_file_browser_chdir( browser, dir_path,
PTK_FB_CHDIR_ADD_HISTORY ) )
{
/* show right-click menu
* This simulates a right-click in the file list when
* no files are selected (even if some are) since
* actions are to be taken on the dir itself. */
GtkWidget* popup = ptk_file_menu_new( NULL, browser,
NULL, NULL,
dir_path, NULL );
if ( popup )
gtk_menu_popup( GTK_MENU( popup ), NULL, NULL,
NULL, NULL, 3, 0 );
}
/* this old method operates on the wrong files
gtk_tree_model_get( gtk_tree_view_get_model( GTK_TREE_VIEW( view ) ),
&iter,
COL_DIR_TREE_INFO,
&file, -1 );
if ( file )
{
GtkWidget * popup;
char* file_path;
GList* sel_files;
char* dir_name;
file_path = ptk_dir_view_get_dir_path(
gtk_tree_view_get_model( GTK_TREE_VIEW( view ) ), &iter );
sel_files = g_list_prepend( NULL, vfs_file_info_ref(file) );
dir_name = g_path_get_dirname( file_path );
popup = ptk_file_menu_new( NULL, browser,
file_path, file,
dir_name, sel_files );
g_free( dir_name );
g_free( file_path );
if ( popup )
gtk_menu_popup( GTK_MENU( popup ), NULL, NULL,
NULL, NULL, 3, evt->time );
vfs_file_info_unref( file );
}
*/
break;
default:
gtk_tree_path_free( path );
return FALSE;
}
gtk_tree_path_free( path );
return TRUE;
}
/* Create a new dir tree view */
GtkWidget* ptk_dir_tree_view_new( PtkFileBrowser* browser,
gboolean show_hidden )
{
GtkTreeView * dir_tree_view;
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTreeModel* model;
GtkTreeSelection* tree_sel;
GtkTreePath* tree_path;
GtkTreeModel* filter;
dir_tree_view = GTK_TREE_VIEW( gtk_tree_view_new () );
gtk_tree_view_set_headers_visible( dir_tree_view, FALSE );
gtk_tree_view_set_enable_tree_lines(dir_tree_view, TRUE);
//MOD enabled DND FIXME: Temporarily disable drag & drop since it doesn't work right now.
/* exo_icon_view_enable_model_drag_dest (
EXO_ICON_VIEW( dir_tree_view ),
drag_targets, G_N_ELEMENTS( drag_targets ), GDK_ACTION_ALL ); */
gtk_tree_view_enable_model_drag_dest ( dir_tree_view,
drag_targets,
sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK );
/*
gtk_tree_view_enable_model_drag_source ( dir_tree_view,
( GDK_CONTROL_MASK | GDK_BUTTON1_MASK | GDK_BUTTON3_MASK ),
drag_targets,
sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );
*/
col = gtk_tree_view_column_new ();
renderer = ( GtkCellRenderer* ) ptk_file_icon_renderer_new();
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_DIR_TREE_ICON,
"info", COL_DIR_TREE_INFO, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start( col, renderer, TRUE );
gtk_tree_view_column_set_attributes( col, renderer, "text", COL_DIR_TREE_DISP_NAME, NULL );
gtk_tree_view_append_column ( dir_tree_view, col );
tree_sel = gtk_tree_view_get_selection( dir_tree_view );
gtk_tree_selection_set_select_function( tree_sel, sel_func, NULL, NULL );
if ( G_UNLIKELY( !dir_tree_view_data ) )
dir_tree_view_data = g_quark_from_static_string( "show_hidden" );
g_object_set_qdata( G_OBJECT( dir_tree_view ),
dir_tree_view_data, GINT_TO_POINTER( show_hidden ) );
model = get_dir_tree_model();
filter = gtk_tree_model_filter_new( model, NULL );
g_object_unref( G_OBJECT( model ) );
gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ),
filter_func, dir_tree_view, NULL );
gtk_tree_view_set_model( dir_tree_view, filter );
g_object_unref( G_OBJECT( filter ) );
g_signal_connect ( dir_tree_view, "row-expanded",
G_CALLBACK ( on_dir_tree_view_row_expanded ),
model );
g_signal_connect_data ( dir_tree_view, "row-collapsed",
G_CALLBACK ( on_dir_tree_view_row_collapsed ),
model, NULL, G_CONNECT_AFTER );
g_signal_connect ( dir_tree_view, "button-press-event",
G_CALLBACK ( on_dir_tree_view_button_press ),
browser );
g_signal_connect ( dir_tree_view, "key-press-event",
G_CALLBACK ( on_dir_tree_view_key_press ),
browser );
//MOD drag n drop
g_signal_connect ( ( gpointer ) dir_tree_view, "drag-data-received",
G_CALLBACK ( on_dir_tree_view_drag_data_received ),
browser );
g_signal_connect ( ( gpointer ) dir_tree_view, "drag-motion",
G_CALLBACK ( on_dir_tree_view_drag_motion ),
browser );
g_signal_connect ( ( gpointer ) dir_tree_view, "drag-leave",
G_CALLBACK ( on_dir_tree_view_drag_leave ),
browser );
g_signal_connect ( ( gpointer ) dir_tree_view, "drag-drop",
G_CALLBACK ( on_dir_tree_view_drag_drop ),
browser );
tree_path = gtk_tree_path_new_first();
gtk_tree_view_expand_row( dir_tree_view, tree_path, FALSE );
gtk_tree_path_free( tree_path );
g_signal_connect( dir_tree_view, "destroy", G_CALLBACK(on_destroy), NULL );
return GTK_WIDGET( dir_tree_view );
}
gboolean ptk_dir_tree_view_chdir( GtkTreeView* dir_tree_view, const char* path )
{
GtkTreeModel * model;
GtkTreeIter it, parent_it;
GtkTreePath* tree_path = NULL;
gchar **dirs, **dir;
gboolean found;
VFSFileInfo* info;
if ( !path || *path != '/' )
return FALSE;
dirs = g_strsplit( path + 1, "/", -1 );
if ( !dirs )
return FALSE;
model = gtk_tree_view_get_model( dir_tree_view );
if ( ! gtk_tree_model_iter_children ( model, &parent_it, NULL ) )
{
g_strfreev( dirs );
return FALSE;
}
/* special case: root dir */
if ( ! dirs[ 0 ] )
{
it = parent_it;
tree_path = gtk_tree_model_get_path ( model, &parent_it );
goto _found;
}
for ( dir = dirs; *dir; ++dir )
{
if ( ! gtk_tree_model_iter_children ( model, &it, &parent_it ) )
{
g_strfreev( dirs );
return FALSE;
}
found = FALSE;
do
{
gtk_tree_model_get( model, &it, COL_DIR_TREE_INFO, &info, -1 );
if ( !info )
continue;
if ( 0 == strcmp( vfs_file_info_get_name( info ), *dir ) )
{
tree_path = gtk_tree_model_get_path( model, &it );
if( dir[1] ) {
gtk_tree_view_expand_row ( dir_tree_view, tree_path, FALSE );
gtk_tree_model_get_iter( model, &parent_it, tree_path );
}
found = TRUE;
vfs_file_info_unref( info );
break;
}
vfs_file_info_unref( info );
}
while ( gtk_tree_model_iter_next( model, &it ) );
if ( ! found )
return FALSE; /* Error! */
if ( tree_path && dir[ 1 ] )
{
gtk_tree_path_free( tree_path );
tree_path = NULL;
}
}
_found:
g_strfreev( dirs );
gtk_tree_selection_select_path (
gtk_tree_view_get_selection( dir_tree_view ), tree_path );
gtk_tree_view_scroll_to_cell ( dir_tree_view, tree_path, NULL, FALSE, 0.5, 0.5 );
gtk_tree_path_free( tree_path );
return TRUE;
}
static void log_row_activated_cb(GtkTreeView *tv, GtkTreePath *path, GtkTreeViewColumn *col, PidginLogViewer *viewer) {
if (gtk_tree_view_row_expanded(tv, path))
gtk_tree_view_collapse_row(tv, path);
else
gtk_tree_view_expand_row(tv, path, FALSE);
}
gboolean on_dir_tree_view_key_press( GtkWidget* view,
GdkEventKey* evt,
PtkFileBrowser* browser )
{
VFSFileInfo* file;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if(!gtk_tree_selection_get_selected(select, &model, &iter))
return FALSE;
int keymod = ( evt->state & ( GDK_SHIFT_MASK | GDK_CONTROL_MASK |
GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK ) );
GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
switch( evt->keyval ) {
case GDK_KEY_Left:
if(gtk_tree_view_row_expanded(GTK_TREE_VIEW(view), path)) {
gtk_tree_view_collapse_row(GTK_TREE_VIEW(view), path);
} else if(gtk_tree_path_up(path)) {
gtk_tree_selection_select_path(select, path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL, FALSE);
} else {
gtk_tree_path_free( path );
return FALSE;
}
break;
case GDK_KEY_Right:
if(!gtk_tree_view_row_expanded(GTK_TREE_VIEW(view), path)) {
gtk_tree_view_expand_row(GTK_TREE_VIEW(view), path, FALSE);
} else {
gtk_tree_path_down(path);
gtk_tree_selection_select_path(select, path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path, NULL, FALSE);
}
break;
case GDK_KEY_F10:
case GDK_KEY_Menu:
if ( evt->keyval == GDK_KEY_F10 && keymod != GDK_SHIFT_MASK )
{
gtk_tree_path_free( path );
return FALSE;
}
gtk_tree_model_get( gtk_tree_view_get_model( GTK_TREE_VIEW( view ) ),
&iter,
COL_DIR_TREE_INFO,
&file, -1 );
if ( file )
{
GtkWidget * popup;
char* file_path;
GList* sel_files;
char* dir_name;
file_path = ptk_dir_view_get_dir_path(
gtk_tree_view_get_model( GTK_TREE_VIEW( view ) ), &iter );
sel_files = g_list_prepend( NULL, vfs_file_info_ref(file) );
dir_name = g_path_get_dirname( file_path );
popup = ptk_file_menu_new( NULL, browser,
file_path, file,
dir_name, sel_files );
g_free( dir_name );
g_free( file_path );
if ( popup )
gtk_menu_popup( GTK_MENU( popup ), NULL, NULL,
NULL, NULL, 3, evt->time );
vfs_file_info_unref( file );
}
break;
default:
gtk_tree_path_free( path );
return FALSE;
}
gtk_tree_path_free( path );
return TRUE;
}
gboolean on_dir_tree_view_button_press( GtkWidget* view,
GdkEventButton* evt,
PtkFileBrowser* browser )
{
GtkTreeModel* model;
GtkTreePath* tree_path;
GtkTreeViewColumn* tree_col;
GtkTreeIter it;
if ( evt->type == GDK_BUTTON_PRESS &&
( evt->button == 1 || evt->button == 3 ) )
{
// middle click 2 handled in ptk-file-browser.c on_dir_tree_button_press
model = gtk_tree_view_get_model( GTK_TREE_VIEW( view ) );
if ( gtk_tree_view_get_path_at_pos( GTK_TREE_VIEW( view ),
evt->x, evt->y, &tree_path,
&tree_col, NULL, NULL ) )
{
if ( gtk_tree_model_get_iter( model, &it, tree_path ) )
{
gtk_tree_view_set_cursor( GTK_TREE_VIEW( view ),
tree_path,
tree_col, FALSE );
gtk_tree_view_row_activated( GTK_TREE_VIEW( view ),
tree_path,
tree_col );
if ( evt->button == 3 )
{
// right click
VFSFileInfo * file;
gtk_tree_model_get( model, &it,
COL_DIR_TREE_INFO,
&file, -1 );
if ( file )
{
GtkWidget * popup;
char* file_path;
GList* sel_files;
char* dir_name;
file_path = ptk_dir_view_get_dir_path( model, &it );
sel_files = g_list_prepend( NULL, vfs_file_info_ref(file) );
dir_name = g_path_get_dirname( file_path );
/* FIXME: New|Tab Here and New|File etc work on the
* wrong location because dir_name is really incorrect.
* But if set to cur dir it breaks Copy, etc. */
popup = ptk_file_menu_new( NULL, browser,
file_path, file,
dir_name, sel_files );
g_free( dir_name );
g_free( file_path );
if ( popup )
gtk_menu_popup( GTK_MENU( popup ), NULL, NULL,
NULL, NULL, 3, evt->time );
vfs_file_info_unref( file );
gtk_tree_path_free( tree_path );
return TRUE;
}
}
}
gtk_tree_path_free( tree_path );
}
}
else if ( evt->type == GDK_2BUTTON_PRESS && evt->button == 1 )
{
// double click - expand/collapse
if ( gtk_tree_view_get_path_at_pos( GTK_TREE_VIEW( view ),
evt->x, evt->y, &tree_path,
NULL, NULL, NULL ) )
{
if ( gtk_tree_view_row_expanded( GTK_TREE_VIEW( view ),
tree_path ) )
gtk_tree_view_collapse_row( GTK_TREE_VIEW( view ), tree_path );
else
gtk_tree_view_expand_row( GTK_TREE_VIEW( view ), tree_path,
FALSE );
gtk_tree_path_free( tree_path );
return TRUE;
}
}
return FALSE;
}
bool
sc_navigate_index(girara_session_t* session, girara_argument_t* argument,
girara_event_t* UNUSED(event), unsigned int UNUSED(t))
{
g_return_val_if_fail(session != NULL, false);
g_return_val_if_fail(session->global.data != NULL, false);
zathura_t* zathura = session->global.data;
g_return_val_if_fail(argument != NULL, false);
g_return_val_if_fail(zathura->document != NULL, false);
if(zathura->ui.index == NULL) {
return false;
}
GtkTreeView *tree_view = gtk_container_get_children(GTK_CONTAINER(zathura->ui.index))->data;
GtkTreePath *path;
gtk_tree_view_get_cursor(tree_view, &path, NULL);
if (path == NULL) {
return false;
}
GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
GtkTreeIter iter;
GtkTreeIter child_iter;
gboolean is_valid_path = TRUE;
switch(argument->n) {
case UP:
if (gtk_tree_path_prev(path) == FALSE) {
/* For some reason gtk_tree_path_up returns TRUE although we're not
* moving anywhere. */
is_valid_path = gtk_tree_path_up(path) && (gtk_tree_path_get_depth(path) > 0);
} else { /* row above */
while(gtk_tree_view_row_expanded(tree_view, path)) {
gtk_tree_model_get_iter(model, &iter, path);
/* select last child */
gtk_tree_model_iter_nth_child(model, &child_iter, &iter,
gtk_tree_model_iter_n_children(model, &iter)-1);
gtk_tree_path_free(path);
path = gtk_tree_model_get_path(model, &child_iter);
}
}
break;
case COLLAPSE:
if (gtk_tree_view_collapse_row(tree_view, path) == FALSE
&& gtk_tree_path_get_depth(path) > 1) {
gtk_tree_path_up(path);
gtk_tree_view_collapse_row(tree_view, path);
}
break;
case DOWN:
if (gtk_tree_view_row_expanded(tree_view, path) == TRUE) {
gtk_tree_path_down(path);
} else {
do {
gtk_tree_model_get_iter(model, &iter, path);
if (gtk_tree_model_iter_next(model, &iter)) {
gtk_tree_path_free(path);
path = gtk_tree_model_get_path(model, &iter);
break;
}
} while((is_valid_path = (gtk_tree_path_get_depth(path) > 1))
&& gtk_tree_path_up(path));
}
break;
case EXPAND:
if (gtk_tree_view_expand_row(tree_view, path, FALSE)) {
gtk_tree_path_down(path);
}
break;
case EXPAND_ALL:
gtk_tree_view_expand_all(tree_view);
break;
case COLLAPSE_ALL:
gtk_tree_view_collapse_all(tree_view);
gtk_tree_path_free(path);
path = gtk_tree_path_new_first();
gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE);
break;
case SELECT:
cb_index_row_activated(tree_view, path, NULL, zathura);
gtk_tree_path_free(path);
return false;
}
if (is_valid_path) {
gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE);
}
gtk_tree_path_free(path);
return false;
}
static gboolean on_modules_list_button_release(GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
GtkTreeSelection *selection;
GtkTreeIter selected;
GtkTreeModel *model;
gchar *mod = NULL;
gchar *caption = NULL;
selection =
gtk_tree_view_get_selection(GTK_TREE_VIEW(sidebar.module_list));
if (!gtk_tree_selection_get_selected(selection, &model, &selected))
return FALSE;
gtk_tree_model_get(GTK_TREE_MODEL(model), &selected, 2, &caption,
3, &mod, -1);
//uncomment the following two lines if you want to see how it looks without
//triangls or plus symbols
//gtk_tree_view_set_show_expanders(sidebar.module_list, FALSE);
//gtk_tree_view_set_level_indentation(sidebar.module_list, 12);
GtkTreePath *path = gtk_tree_model_get_path(model, &selected);
if (gtk_tree_view_row_expanded(GTK_TREE_VIEW(sidebar.module_list), path))
gtk_tree_view_collapse_row(GTK_TREE_VIEW(sidebar.module_list), path);
else
gtk_tree_view_expand_row(GTK_TREE_VIEW(sidebar.module_list), path,
FALSE);
gtk_tree_path_free(path);
switch (event->button) {
case 1:
main_mod_treeview_button_one(model, selected);
break;
case 2:
if (mod && (g_utf8_collate(mod, _("Parallel View"))) && (g_utf8_collate(mod, _("Standard View"))))
gui_open_module_in_new_tab(mod);
break;
case 3:
if (mod && (g_utf8_collate(mod, _("Parallel View"))) && (g_utf8_collate(mod, _("Standard View"))) //) {
&& (main_get_mod_type(mod) != PRAYERLIST_TYPE)) {
buf_module = mod;
create_menu_modules();
/*gtk_menu_popup(GTK_MENU(sidebar.menu_modules),
NULL, NULL, NULL, NULL,
0, gtk_get_current_event_time()); */
g_free(caption);
return FALSE;
}
if (caption &&
(!g_utf8_collate(caption, _("Prayer List/Journal")))) {
gui_menu_prayerlist_popup(NULL, NULL);
g_free(mod);
return FALSE;
}
if (mod && (main_get_mod_type(mod) == PRAYERLIST_TYPE)) {
buf_module = mod;
gtk_menu_popup(GTK_MENU(sidebar.menu_prayerlist_mod), NULL,
NULL, NULL, NULL, 0,
gtk_get_current_event_time());
g_free(caption);
return FALSE;
}
break;
}
g_free(caption);
g_free(mod);
return FALSE;
}
