int wxListBox::GetCountPerPage() const
{
wxGtkTreePath path;
GtkTreeViewColumn *column;
if ( !gtk_tree_view_get_path_at_pos
(
m_treeview,
0,
0,
path.ByRef(),
&column,
NULL,
NULL
) )
{
return -1;
}
GdkRectangle rect;
gtk_tree_view_get_cell_area(m_treeview, path, column, &rect);
if ( !rect.height )
return -1;
GdkRectangle vis;
gtk_tree_view_get_visible_rect(m_treeview, &vis);
return vis.height / rect.height;
}
static gboolean
file_view_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard,
GtkTooltip* tooltip)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModel* model_sort;
GtkTreeModel* file_model = GTK_TREE_MODEL (priv->model);
GtkTreePath* path;
GtkTreeIter iter;
GtkTreeIter real_iter;
gchar* filename;
gboolean result = TRUE;
GdkRectangle visible_rect, column_rect;
GdkScreen *screen = gdk_screen_get_default ();
PangoContext *context;
PangoLayout *layout;
gint width, height;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view),
&x, &y, keyboard,
&model_sort,
&path,
&iter))
return FALSE;
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model_sort),
&real_iter, &iter);
filename = file_model_get_filename (FILE_MODEL (file_model), &real_iter);
context = gdk_pango_context_get_for_screen (screen);
layout = pango_layout_new (context);
pango_layout_set_text (layout, filename, -1);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_tree_view_get_visible_rect (GTK_TREE_VIEW (view), &visible_rect);
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (view), path,
gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), &column_rect);
if (column_rect.x + width > visible_rect.x + visible_rect.width ||
column_rect.x < visible_rect.x)
{
gtk_tooltip_set_text (tooltip, filename);
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view),
tooltip,
path);
} else
{
result = FALSE;
}
g_free (filename);
gtk_tree_path_free (path);
g_object_unref (layout);
g_object_unref (context);
return result;
}
/*
* get the top or bottom visible row in the connection list
* returns TOP row if (int top) is > 0 and list is not empty
* returns BOTTOM row if (int top) is 0 and visible area is full
*/
static void gtkui_connection_list_row(int top, struct row_pairs *pair) {
GtkTreeIter iter; /* points to a specific row */
GtkTreePath *path = NULL; /* for finding the first visible row */
GtkTreeModel *model = NULL; /* points to the list data */
GdkRectangle rect; /* holds coordinates of visible rows */
int wx = 0, wy = 0; /* for converting tree view coords to widget coords */
void *row = NULL;
if(!ls_conns || !pair)
return;
/* in case we don't get a row */
pair->conn = NULL;
model = GTK_TREE_MODEL (ls_conns);
if(gtk_tree_model_get_iter_first(model, &iter)) {
gtk_tree_view_get_visible_rect(GTK_TREE_VIEW(treeview), &rect);
/* get the first visible row */
gtk_tree_view_tree_to_widget_coords(GTK_TREE_VIEW(treeview), rect.x, (top)?rect.y:rect.height, &wx, &wy);
path = gtk_tree_path_new();
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), wx+2, (top)?wy+2:wy-2, &path, NULL, NULL, NULL)) {
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get (model, &iter, 9, &row, -1);
pair->iter = iter;
pair->conn = row;
}
if(path)
gtk_tree_path_free(path);
}
return;
}
static VALUE
rg_visible_rect(VALUE self)
{
GdkRectangle rect;
gtk_tree_view_get_visible_rect(_SELF(self), &rect);
return BOXED2RVAL(&rect, GDK_TYPE_RECTANGLE);
}
void SelectBooksDialog::update_gui()
{
// Get the upper corners of the visible area of both treeviews.
// If one changed, then the other will be scrolled to the same position,
// and vice versa.
GdkRectangle gdk_rectangle;
gtk_tree_view_get_visible_rect(GTK_TREE_VIEW(treeviewbooks), &gdk_rectangle);
if (gdk_rectangle.y != treeviewbooks_previous_y) {
treeviewbooks_previous_y = gdk_rectangle.y;
gtk_tree_view_scroll_to_point(GTK_TREE_VIEW(treeviewportions), -1, gdk_rectangle.y);
}
gtk_tree_view_get_visible_rect(GTK_TREE_VIEW(treeviewportions), &gdk_rectangle);
if (gdk_rectangle.y != treeviewportions_previous_y) {
treeviewportions_previous_y = gdk_rectangle.y;
gtk_tree_view_scroll_to_point(GTK_TREE_VIEW(treeviewbooks), -1, gdk_rectangle.y);
}
}
static void
cv_tree_focus (chan *ch)
{
GtkTreeView *tree = ((treeview *)ch->cv)->tree;
GtkTreeModel *model = gtk_tree_view_get_model (tree);
GtkTreePath *path;
GtkTreeIter parent;
GdkRectangle cell_rect;
GdkRectangle vis_rect;
gint dest_y;
/* expand the parent node */
if (gtk_tree_model_iter_parent (model, &parent, &ch->iter))
{
path = gtk_tree_model_get_path (model, &parent);
if (path)
{
/*if (!gtk_tree_view_row_expanded (tree, path))
{
gtk_tree_path_free (path);
return;
}*/
gtk_tree_view_expand_row (tree, path, FALSE);
gtk_tree_path_free (path);
}
}
path = gtk_tree_model_get_path (model, &ch->iter);
if (path)
{
/* This full section does what
* gtk_tree_view_scroll_to_cell (tree, path, NULL, TRUE, 0.5, 0.5);
* does, except it only scrolls the window if the provided cell is
* not visible. Basic algorithm taken from gtktreeview.c */
/* obtain information to see if the cell is visible */
gtk_tree_view_get_background_area (tree, path, NULL, &cell_rect);
gtk_tree_view_get_visible_rect (tree, &vis_rect);
/* The cordinates aren't offset correctly */
gtk_tree_view_widget_to_tree_coords( tree, cell_rect.x, cell_rect.y, NULL, &cell_rect.y );
/* only need to scroll if out of bounds */
if (cell_rect.y < vis_rect.y ||
cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
{
dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * 0.5);
if (dest_y < 0)
dest_y = 0;
gtk_tree_view_scroll_to_point (tree, -1, dest_y);
}
/* theft done, now make it focused like */
gtk_tree_view_set_cursor (tree, path, NULL, FALSE);
gtk_tree_path_free (path);
}
}
/* Scroll function taken/adapted from gtktreeview.c */
static gint
scroll_row_timeout (gpointer data)
{
GtkTreeView *tree_view = data;
GdkRectangle visible_rect;
gint y, x;
gint offset;
gfloat value;
GtkAdjustment* vadj;
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, TRUE);
gdk_window_get_pointer (gtk_tree_view_get_bin_window (tree_view), &x, &y, NULL);
gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, x, y, &x, &y);
gtk_tree_view_convert_bin_window_to_tree_coords (tree_view, x, y, &x, &y);
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
/* see if we are near the edge. */
if (x < visible_rect.x && x > visible_rect.x + visible_rect.width)
{
GDK_THREADS_LEAVE ();
priv_data->scroll_timeout = 0;
return FALSE;
}
offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
if (offset > 0)
{
offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
if (offset < 0)
{
GDK_THREADS_LEAVE ();
priv_data->scroll_timeout = 0;
return FALSE;
}
}
vadj = gtk_tree_view_get_vadjustment (tree_view);
value = CLAMP (vadj->value + offset, vadj->lower, vadj->upper - vadj->page_size);
gtk_adjustment_set_value (vadj, value);
/* don't remove it if we're on the edge and not scrolling */
if (ABS (vadj->value - value) > 0.0001)
remove_select_on_drag_timeout(tree_view);
GDK_THREADS_LEAVE ();
return TRUE;
}
static int row_is_visible(GtkTreeView *tree, GtkTreeIter *iter)
{
GtkTreeModel *model = gtk_tree_view_get_model(tree);
GtkTreePath *path;
GdkRectangle rect;
GdkRectangle visible;
path = gtk_tree_model_get_path(model, iter);
gtk_tree_view_get_cell_area(tree, path, gtk_tree_view_get_column(tree, 0), &rect);
gtk_tree_path_free(path);
gtk_tree_view_get_visible_rect(tree, &visible);
//fprintf(stderr, "-- visible.height=%d rect.y=%d => %s\n", visible.height, rect.y, ((rect.y > 0) && ((rect.y - 1) <= visible.height)) ? "visible":"hidden");
return (rect.y > 0) && ((rect.y - 1) <= visible.height);
}
void
show_tasks_desc_panel (gboolean enable, GUI *appGUI) {
GtkTreeIter iter;
GdkRectangle rect, visible_rect;
GtkTreePath *visible_path;
GtkTreeModel *model;
if(enable == TRUE) {
if (gtk_tree_selection_get_selected (appGUI->tsk->tasks_list_selection, &model, &iter)) {
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), config.tasks_pane_pos);
while (g_main_context_iteration(NULL, FALSE));
visible_path = gtk_tree_model_get_path (model, &iter);
if (visible_path) {
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (appGUI->tsk->tasks_list), visible_path, NULL, &rect);
gtk_tree_view_get_visible_rect (GTK_TREE_VIEW (appGUI->tsk->tasks_list), &visible_rect);
if (rect.y < visible_rect.y || rect.y > visible_rect.y + visible_rect.height) {
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (appGUI->tsk->tasks_list), visible_path, NULL, TRUE, 0.5, 0.0);
}
gtk_tree_path_free(visible_path);
}
} else {
enable = FALSE;
}
} else {
config.tasks_pane_pos = gtk_paned_get_position(GTK_PANED(appGUI->tsk->tasks_paned));
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999);
}
appGUI->tsk->tasks_panel_status = enable;
}
void
gul_gui_menu_position_tree_selection (GtkMenu *menu,
gint *x,
gint *y,
gboolean *push_in,
gpointer user_data)
{
GtkTreeSelection *selection;
GList *selected_rows;
GtkTreeModel *model;
GtkTreeView *tree_view = GTK_TREE_VIEW (user_data);
GtkWidget *widget = GTK_WIDGET (user_data);
GtkRequisition req;
GdkRectangle visible;
gtk_widget_size_request (GTK_WIDGET (menu), &req);
gdk_window_get_origin (widget->window, x, y);
*x += (widget->allocation.width - req.width) / 2;
/* Add on height for the treeview title */
gtk_tree_view_get_visible_rect (tree_view, &visible);
*y += widget->allocation.height - visible.height;
selection = gtk_tree_view_get_selection (tree_view);
selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
if (selected_rows)
{
GdkRectangle cell_rect;
gtk_tree_view_get_cell_area (tree_view, selected_rows->data,
NULL, &cell_rect);
*y += CLAMP (cell_rect.y + cell_rect.height, 0, visible.height);
g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
g_list_free (selected_rows);
}
gul_gui_sanitise_popup_position (menu, widget, x, y);
}
static void
gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
{
GdkRectangle visible_rect;
GtkAdjustment *vadjustment;
GdkWindow *window;
int y;
int offset;
float value;
window = gtk_tree_view_get_bin_window (tree_view);
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (tree_view));
gdk_window_get_device_position (window,
gdk_device_manager_get_client_pointer (
gdk_display_get_device_manager (
gtk_widget_get_display (GTK_WIDGET (tree_view)))),
NULL, &y, NULL);
y += gtk_adjustment_get_value (vadjustment);
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
offset = y - (visible_rect.y + 2 * AUTO_SCROLL_MARGIN);
if (offset > 0)
{
offset = y - (visible_rect.y + visible_rect.height - 2 * AUTO_SCROLL_MARGIN);
if (offset < 0)
{
return;
}
}
value = CLAMP (gtk_adjustment_get_value (vadjustment) + offset, 0.0,
gtk_adjustment_get_upper (vadjustment) - gtk_adjustment_get_page_size (vadjustment));
gtk_adjustment_set_value (vadjustment, value);
}
static gboolean
tree_event (GtkTreeView *tree,
GdkEvent *event)
{
GtkTreeViewColumn *column;
gint cx, cy, atrow;
switch (event->type)
{
GdkRectangle rect;
gint wx, wy;
case GDK_BUTTON_PRESS:
atrow = gtk_tree_view_get_path_at_pos (tree, event->button.x, event->button.y,
NULL, &column, &cx, &cy);
g_print ("got button_press at %f,%f [%u] (%p %d %d)\n", event->button.x, event->button.y, atrow, column, cx, cy);
break;
case GDK_BUTTON_RELEASE:
atrow = gtk_tree_view_get_path_at_pos (tree, event->button.x, event->button.y,
NULL, &column, &cx, &cy);
g_print ("got button_release at %f,%f [%u] (%p %d %d)\n", event->button.x, event->button.y, atrow, column, cx, cy);
break;
case GDK_MOTION_NOTIFY:
atrow = gtk_tree_view_get_path_at_pos (tree, event->motion.x, event->motion.y,
NULL, &column, &cx, &cy);
gtk_tree_view_get_visible_rect (tree, &rect);
gtk_tree_view_tree_to_widget_coords (tree, rect.x, rect.y, &wx, &wy);
g_print ("got motion at %f,%f [%u] (%p %d %d) widget(%d %d)\n", event->motion.x, event->motion.y, atrow, column,
cx, cy, wx, wy);
break;
default:
}
return FALSE;
}
static GtkWidget*
pack_test_widget (void)
{
GtkWidget *scwin, *tree;
GtkTreeSelection *tsel;
GxkListWrapper *plist = gxk_list_wrapper_new (3 /* N_COLS */,
G_TYPE_STRING, /* 0 */
G_TYPE_STRING, /* 1 */
G_TYPE_STRING /* 2 */
);
g_signal_connect_object (plist, "fill-value",
G_CALLBACK (plist_fill_value),
NULL, G_CONNECT_SWAPPED);
gxk_list_wrapper_notify_prepend (plist, 200);
scwin = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"visible", TRUE,
"hscrollbar_policy", GTK_POLICY_AUTOMATIC,
"vscrollbar_policy", GTK_POLICY_ALWAYS,
"height_request", 320,
"width_request", 320,
"border_width", 5,
"shadow_type", GTK_SHADOW_IN,
NULL);
tree = g_object_new (GTK_TYPE_TREE_VIEW,
"visible", TRUE,
"can_focus", TRUE,
"model", plist,
"border_width", 10,
"parent", scwin,
NULL);
gxk_tree_view_append_text_columns (GTK_TREE_VIEW (tree), 3 /* N_COLS */,
0, "", 0.0, "Foo Name",
1, "", 0.0, "Bar Name",
2, "", 0.0, "Baz Type"
);
gtk_tree_view_add_column (GTK_TREE_VIEW (tree), -1,
g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
"title", "PTrack",
"sizing", GTK_TREE_VIEW_COLUMN_GROW_ONLY,
"resizable", TRUE,
NULL),
g_object_new (BST_TYPE_CELL_PTRACK,
"xalign", 0.0,
NULL),
// "text", 3,
NULL);
g_object_connect (tree,
"signal::event", tree_event, NULL,
NULL);
#if 0
g_object_connect (tree,
"swapped_object_signal::row_activated", tree_row_activated, self,
NULL);
#endif
/* ensure selection
*/
tsel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (tsel, GTK_SELECTION_SINGLE);
gxk_tree_selection_select_spath (tsel, "0");
return scwin;
}
