From 6601bf27d85f3a9bad9926432f2044363f420b9d Mon Sep 17 00:00:00 2001 From: compudj Date: Wed, 16 Jul 2003 20:32:50 +0000 Subject: [PATCH] needed private information not accessible otherwise git-svn-id: http://ltt.polymtl.ca/svn@107 04897980-b3bd-0310-b5e0-8ef037075253 --- ltt/branches/poly/lttv/modules/gtkrbtree.h | 184 +++++++++ .../poly/lttv/modules/gtktreeprivate.h | 377 ++++++++++++++++++ ltt/branches/poly/lttv/modules/guiEvents.c | 65 +-- 3 files changed, 595 insertions(+), 31 deletions(-) create mode 100644 ltt/branches/poly/lttv/modules/gtkrbtree.h create mode 100644 ltt/branches/poly/lttv/modules/gtktreeprivate.h diff --git a/ltt/branches/poly/lttv/modules/gtkrbtree.h b/ltt/branches/poly/lttv/modules/gtkrbtree.h new file mode 100644 index 00000000..bf149836 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gtkrbtree.h @@ -0,0 +1,184 @@ +/* gtkrbtree.h + * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +/* A Red-Black Tree implementation used specifically by GtkTreeView. + */ +#ifndef __GTK_RBTREE_H__ +#define __GTK_RBTREE_H__ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include +typedef enum +{ + GTK_RBNODE_BLACK = 1 << 0, + GTK_RBNODE_RED = 1 << 1, + GTK_RBNODE_IS_PARENT = 1 << 2, + GTK_RBNODE_IS_SELECTED = 1 << 3, + GTK_RBNODE_IS_PRELIT = 1 << 4, + GTK_RBNODE_IS_SEMI_COLLAPSED = 1 << 5, + GTK_RBNODE_IS_SEMI_EXPANDED = 1 << 6, + GTK_RBNODE_INVALID = 1 << 7, + GTK_RBNODE_COLUMN_INVALID = 1 << 8, + GTK_RBNODE_DESCENDANTS_INVALID = 1 << 9, + GTK_RBNODE_NON_COLORS = GTK_RBNODE_IS_PARENT | + GTK_RBNODE_IS_SELECTED | + GTK_RBNODE_IS_PRELIT | + GTK_RBNODE_IS_SEMI_COLLAPSED | + GTK_RBNODE_IS_SEMI_EXPANDED | + GTK_RBNODE_INVALID | + GTK_RBNODE_COLUMN_INVALID | + GTK_RBNODE_DESCENDANTS_INVALID +} GtkRBNodeColor; + +typedef struct _GtkRBTree GtkRBTree; +typedef struct _GtkRBNode GtkRBNode; +typedef struct _GtkRBTreeView GtkRBTreeView; + +typedef void (*GtkRBTreeTraverseFunc) (GtkRBTree *tree, + GtkRBNode *node, + gpointer data); + +struct _GtkRBTree +{ + GtkRBNode *root; + GtkRBNode *nil; + GtkRBTree *parent_tree; + GtkRBNode *parent_node; +}; + +struct _GtkRBNode +{ + guint flags : 14; + + /* We keep track of whether the aggregate count of children plus 1 + * for the node itself comes to an even number. The parity flag is + * the total count of children mod 2, where the total count of + * children gets computed in the same way that the total offset gets + * computed. i.e. not the same as the "count" field below which + * doesn't include children. We could replace parity with a + * full-size int field here, and then take % 2 to get the parity flag, + * but that would use extra memory. + */ + + guint parity : 1; + + GtkRBNode *left; + GtkRBNode *right; + GtkRBNode *parent; + + /* count is the number of nodes beneath us, plus 1 for ourselves. + * i.e. node->left->count + node->right->count + 1 + */ + gint count; + + /* this is the total of sizes of + * node->left, node->right, our own height, and the height + * of all trees in ->children, iff children exists because + * the thing is expanded. + */ + gint offset; + + /* Child trees */ + GtkRBTree *children; +}; + + +#define GTK_RBNODE_GET_COLOR(node) (node?(((node->flags>K_RBNODE_RED)==GTK_RBNODE_RED)?GTK_RBNODE_RED:GTK_RBNODE_BLACK):GTK_RBNODE_BLACK) +#define GTK_RBNODE_SET_COLOR(node,color) if((node->flags&color)!=color)node->flags=node->flags^(GTK_RBNODE_RED|GTK_RBNODE_BLACK) +#define GTK_RBNODE_GET_HEIGHT(node) (node->offset-(node->left->offset+node->right->offset+(node->children?node->children->root->offset:0))) +#define GTK_RBNODE_SET_FLAG(node, flag) G_STMT_START{ (node->flags|=flag); }G_STMT_END +#define GTK_RBNODE_UNSET_FLAG(node, flag) G_STMT_START{ (node->flags&=~(flag)); }G_STMT_END +#define GTK_RBNODE_FLAG_SET(node, flag) (node?(((node->flags&flag)==flag)?TRUE:FALSE):FALSE) + + +void _gtk_rbtree_push_allocator (GAllocator *allocator); +void _gtk_rbtree_pop_allocator (void); +GtkRBTree *_gtk_rbtree_new (void); +void _gtk_rbtree_free (GtkRBTree *tree); +void _gtk_rbtree_remove (GtkRBTree *tree); +void _gtk_rbtree_destroy (GtkRBTree *tree); +GtkRBNode *_gtk_rbtree_insert_before (GtkRBTree *tree, + GtkRBNode *node, + gint height, + gboolean valid); +GtkRBNode *_gtk_rbtree_insert_after (GtkRBTree *tree, + GtkRBNode *node, + gint height, + gboolean valid); +void _gtk_rbtree_remove_node (GtkRBTree *tree, + GtkRBNode *node); +void _gtk_rbtree_reorder (GtkRBTree *tree, + gint *new_order, + gint length); +GtkRBNode *_gtk_rbtree_find_count (GtkRBTree *tree, + gint count); +void _gtk_rbtree_node_set_height (GtkRBTree *tree, + GtkRBNode *node, + gint height); +void _gtk_rbtree_node_mark_invalid(GtkRBTree *tree, + GtkRBNode *node); +void _gtk_rbtree_node_mark_valid (GtkRBTree *tree, + GtkRBNode *node); +void _gtk_rbtree_column_invalid (GtkRBTree *tree); +void _gtk_rbtree_mark_invalid (GtkRBTree *tree); +void _gtk_rbtree_set_fixed_height (GtkRBTree *tree, + gint height); +gint _gtk_rbtree_node_find_offset (GtkRBTree *tree, + GtkRBNode *node); +gint _gtk_rbtree_node_find_parity (GtkRBTree *tree, + GtkRBNode *node); +gint _gtk_rbtree_find_offset (GtkRBTree *tree, + gint offset, + GtkRBTree **new_tree, + GtkRBNode **new_node); +void _gtk_rbtree_traverse (GtkRBTree *tree, + GtkRBNode *node, + GTraverseType order, + GtkRBTreeTraverseFunc func, + gpointer data); +GtkRBNode *_gtk_rbtree_next (GtkRBTree *tree, + GtkRBNode *node); +GtkRBNode *_gtk_rbtree_prev (GtkRBTree *tree, + GtkRBNode *node); +void _gtk_rbtree_next_full (GtkRBTree *tree, + GtkRBNode *node, + GtkRBTree **new_tree, + GtkRBNode **new_node); +void _gtk_rbtree_prev_full (GtkRBTree *tree, + GtkRBNode *node, + GtkRBTree **new_tree, + GtkRBNode **new_node); + +gint _gtk_rbtree_get_depth (GtkRBTree *tree); + +/* This func checks the integrity of the tree */ +#ifdef G_ENABLE_DEBUG +void _gtk_rbtree_test (const gchar *where, + GtkRBTree *tree); +void _gtk_rbtree_debug_spew (GtkRBTree *tree); +#endif + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __GTK_RBTREE_H__ */ diff --git a/ltt/branches/poly/lttv/modules/gtktreeprivate.h b/ltt/branches/poly/lttv/modules/gtktreeprivate.h new file mode 100644 index 00000000..d56e1880 --- /dev/null +++ b/ltt/branches/poly/lttv/modules/gtktreeprivate.h @@ -0,0 +1,377 @@ +/* gtktreeprivate.h + * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __GTK_TREE_PRIVATE_H__ +#define __GTK_TREE_PRIVATE_H__ + + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include +#include +//#include +#include "gtkrbtree.h" + +#define TREE_VIEW_DRAG_WIDTH 6 + +typedef enum +{ + GTK_TREE_VIEW_IS_LIST = 1 << 0, + GTK_TREE_VIEW_SHOW_EXPANDERS = 1 << 1, + GTK_TREE_VIEW_IN_COLUMN_RESIZE = 1 << 2, + GTK_TREE_VIEW_ARROW_PRELIT = 1 << 3, + GTK_TREE_VIEW_HEADERS_VISIBLE = 1 << 4, + GTK_TREE_VIEW_DRAW_KEYFOCUS = 1 << 5, + GTK_TREE_VIEW_MODEL_SETUP = 1 << 6, + GTK_TREE_VIEW_IN_COLUMN_DRAG = 1 << 7 +} GtkTreeViewFlags; + +enum +{ + DRAG_COLUMN_WINDOW_STATE_UNSET = 0, + DRAG_COLUMN_WINDOW_STATE_ORIGINAL = 1, + DRAG_COLUMN_WINDOW_STATE_ARROW = 2, + DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT = 3, + DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT = 4 +}; + +#define GTK_TREE_VIEW_SET_FLAG(tree_view, flag) G_STMT_START{ (tree_view->priv->flags|=flag); }G_STMT_END +#define GTK_TREE_VIEW_UNSET_FLAG(tree_view, flag) G_STMT_START{ (tree_view->priv->flags&=~(flag)); }G_STMT_END +#define GTK_TREE_VIEW_FLAG_SET(tree_view, flag) ((tree_view->priv->flags&flag)==flag) +#define TREE_VIEW_HEADER_HEIGHT(tree_view) (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE)?tree_view->priv->header_height:0) +#define TREE_VIEW_COLUMN_REQUESTED_WIDTH(column) (CLAMP (column->requested_width, (column->min_width!=-1)?column->min_width:column->requested_width, (column->max_width!=-1)?column->max_width:column->requested_width)) +#define TREE_VIEW_DRAW_EXPANDERS(tree_view) (!GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST)&>K_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS)) + + /* This lovely little value is used to determine how far away from the title bar + * you can move the mouse and still have a column drag work. + */ +#define TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER(tree_view) (10*TREE_VIEW_HEADER_HEIGHT(tree_view)) + +typedef void (*GtkTreeViewSearchDialogPositionFunc) (GtkTreeView *tree_view, + GtkWidget *search_dialog); + +typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder; +struct _GtkTreeViewColumnReorder +{ + gint left_align; + gint right_align; + GtkTreeViewColumn *left_column; + GtkTreeViewColumn *right_column; +}; + +struct _GtkTreeViewPrivate +{ + GtkTreeModel *model; + + guint flags; + /* tree information */ + GtkRBTree *tree; + + GtkRBNode *button_pressed_node; + GtkRBTree *button_pressed_tree; + + GList *children; + gint width; + gint height; + gint expander_size; + + GtkAdjustment *hadjustment; + GtkAdjustment *vadjustment; + + GdkWindow *bin_window; + GdkWindow *header_window; + GdkWindow *drag_window; + GdkWindow *drag_highlight_window; + GtkTreeViewColumn *drag_column; + + GtkTreeRowReference *last_button_press; + GtkTreeRowReference *last_button_press_2; + + /* bin_window offset */ + GtkTreeRowReference *top_row; + gint top_row_dy; + /* dy == y pos of top_row + top_row_dy */ + /* we cache it for simplicity of the code */ + gint dy; + gint drag_column_x; + + GtkTreeViewColumn *expander_column; + GtkTreeViewColumn *edited_column; + guint presize_handler_timer; + guint validate_rows_timer; + guint scroll_sync_timer; + + /* Focus code */ + GtkTreeViewColumn *focus_column; + + /* Selection stuff */ + GtkTreeRowReference *anchor; + GtkTreeRowReference *cursor; + + /* Column Resizing */ + gint drag_pos; + gint x_drag; + + /* Prelight information */ + GtkRBNode *prelight_node; + GtkRBTree *prelight_tree; + + /* The node that's currently being collapsed or expanded */ + GtkRBNode *expanded_collapsed_node; + GtkRBTree *expanded_collapsed_tree; + guint expand_collapse_timeout; + + /* Selection information */ + GtkTreeSelection *selection; + + /* Header information */ + gint n_columns; + GList *columns; + gint header_height; + + GtkTreeViewColumnDropFunc column_drop_func; + gpointer column_drop_func_data; + GtkDestroyNotify column_drop_func_data_destroy; + GList *column_drag_info; + GtkTreeViewColumnReorder *cur_reorder; + + /* ATK Hack */ + GtkTreeDestroyCountFunc destroy_count_func; + gpointer destroy_count_data; + GtkDestroyNotify destroy_count_destroy; + + /* Scroll timeout (e.g. during dnd) */ + guint scroll_timeout; + + /* Row drag-and-drop */ + GtkTreeRowReference *drag_dest_row; + GtkTreeViewDropPosition drag_dest_pos; + guint open_dest_timeout; + + gint pressed_button; + gint press_start_x; + gint press_start_y; + + /* Scroll-to functionality when unrealized */ + GtkTreeRowReference *scroll_to_path; + GtkTreeViewColumn *scroll_to_column; + gfloat scroll_to_row_align; + gfloat scroll_to_col_align; + guint scroll_to_use_align : 1; + + guint fixed_height_check : 1; + + guint reorderable : 1; + guint header_has_focus : 1; + guint drag_column_window_state : 3; + /* hint to display rows in alternating colors */ + guint has_rules : 1; + guint mark_rows_col_dirty : 1; + + /* interactive search */ + guint enable_search : 1; + guint disable_popdown : 1; + gint search_column; + GtkTreeViewSearchDialogPositionFunc search_dialog_position_func; + GtkTreeViewSearchEqualFunc search_equal_func; + gpointer search_user_data; + GtkDestroyNotify search_destroy; +}; + +/* cool ABI compat hack */ +#define GTK_CELL_RENDERER_INFO_KEY "gtk-cell-renderer-info" + +typedef struct _GtkCellRendererInfo GtkCellRendererInfo; +struct _GtkCellRendererInfo +{ + GdkColor cell_background; + + /* text renderer */ + gulong focus_out_id; + + /* toggle renderer */ + gboolean inconsistent :1; +}; + +#ifdef __GNUC__ + +#define TREE_VIEW_INTERNAL_ASSERT(expr, ret) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d (%s): assertion `%s' failed.\n" \ + "There is a disparity between the internal view of the GtkTreeView,\n" \ + "and the GtkTreeModel. This generally means that the model has changed\n"\ + "without letting the view know. Any display from now on is likely to\n" \ + "be incorrect.\n", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); \ + return ret; \ + }; }G_STMT_END + +#define TREE_VIEW_INTERNAL_ASSERT_VOID(expr) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d (%s): assertion `%s' failed.\n" \ + "There is a disparity between the internal view of the GtkTreeView,\n" \ + "and the GtkTreeModel. This generally means that the model has changed\n"\ + "without letting the view know. Any display from now on is likely to\n" \ + "be incorrect.\n", \ + __FILE__, \ + __LINE__, \ + __PRETTY_FUNCTION__, \ + #expr); \ + return; \ + }; }G_STMT_END + +#else + +#define TREE_VIEW_INTERNAL_ASSERT(expr, ret) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d: assertion `%s' failed.\n" \ + "There is a disparity between the internal view of the GtkTreeView,\n" \ + "and the GtkTreeModel. This generally means that the model has changed\n"\ + "without letting the view know. Any display from now on is likely to\n" \ + "be incorrect.\n", \ + __FILE__, \ + __LINE__, \ + #expr); \ + return ret; \ + }; }G_STMT_END + +#define TREE_VIEW_INTERNAL_ASSERT_VOID(expr) G_STMT_START{ \ + if (!(expr)) \ + { \ + g_log (G_LOG_DOMAIN, \ + G_LOG_LEVEL_CRITICAL, \ + "file %s: line %d: assertion '%s' failed.\n" \ + "There is a disparity between the internal view of the GtkTreeView,\n" \ + "and the GtkTreeModel. This generally means that the model has changed\n"\ + "without letting the view know. Any display from now on is likely to\n" \ + "be incorrect.\n", \ + __FILE__, \ + __LINE__, \ + #expr); \ + return; \ + }; }G_STMT_END +#endif + + +/* functions that shouldn't be exported */ +void _gtk_tree_selection_internal_select_node (GtkTreeSelection *selection, + GtkRBNode *node, + GtkRBTree *tree, + GtkTreePath *path, + GdkModifierType state, + gboolean override_browse_mode); +gboolean _gtk_tree_view_find_node (GtkTreeView *tree_view, + GtkTreePath *path, + GtkRBTree **tree, + GtkRBNode **node); +GtkTreePath *_gtk_tree_view_find_path (GtkTreeView *tree_view, + GtkRBTree *tree, + GtkRBNode *node); +void _gtk_tree_view_child_move_resize (GtkTreeView *tree_view, + GtkWidget *widget, + gint x, + gint y, + gint width, + gint height); +void _gtk_tree_view_queue_draw_node (GtkTreeView *tree_view, + GtkRBTree *tree, + GtkRBNode *node, + GdkRectangle *clip_rect); + +void _gtk_tree_view_column_realize_button (GtkTreeViewColumn *column); +void _gtk_tree_view_column_unrealize_button (GtkTreeViewColumn *column); +void _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column, + GtkTreeView *tree_view); +void _gtk_tree_view_column_unset_model (GtkTreeViewColumn *column, + GtkTreeModel *old_model); +void _gtk_tree_view_column_unset_tree_view (GtkTreeViewColumn *column); +void _gtk_tree_view_column_set_width (GtkTreeViewColumn *column, + gint width); +void _gtk_tree_view_column_start_drag (GtkTreeView *tree_view, + GtkTreeViewColumn *column); +gboolean _gtk_tree_view_column_cell_event (GtkTreeViewColumn *tree_column, + GtkCellEditable **editable_widget, + GdkEvent *event, + gchar *path_string, + GdkRectangle *background_area, + GdkRectangle *cell_area, + guint flags); +void _gtk_tree_view_column_start_editing (GtkTreeViewColumn *tree_column, + GtkCellEditable *editable_widget); +void _gtk_tree_view_column_stop_editing (GtkTreeViewColumn *tree_column); +void _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view); +void _gtk_tree_view_column_autosize (GtkTreeView *tree_view, + GtkTreeViewColumn *column); + +gboolean _gtk_tree_view_column_has_editable_cell (GtkTreeViewColumn *column); +GtkCellRenderer *_gtk_tree_view_column_get_edited_cell (GtkTreeViewColumn *column); +gint _gtk_tree_view_column_count_special_cells (GtkTreeViewColumn *column); +GtkCellRenderer *_gtk_tree_view_column_get_cell_at_pos (GtkTreeViewColumn *column, + gint x); + +GtkTreeSelection* _gtk_tree_selection_new (void); +GtkTreeSelection* _gtk_tree_selection_new_with_tree_view (GtkTreeView *tree_view); +void _gtk_tree_selection_set_tree_view (GtkTreeSelection *selection, + GtkTreeView *tree_view); + +void _gtk_tree_view_column_cell_render (GtkTreeViewColumn *tree_column, + GdkWindow *window, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + guint flags); +gboolean _gtk_tree_view_column_cell_focus (GtkTreeViewColumn *tree_column, + gint direction, + gboolean left, + gboolean right); +void _gtk_tree_view_column_cell_draw_focus (GtkTreeViewColumn *tree_column, + GdkWindow *window, + GdkRectangle *background_area, + GdkRectangle *cell_area, + GdkRectangle *expose_area, + guint flags); +void _gtk_tree_view_column_cell_set_dirty (GtkTreeViewColumn *tree_column, + gboolean install_handler); +void _gtk_tree_view_column_get_neighbor_sizes (GtkTreeViewColumn *column, + GtkCellRenderer *cell, + gint *left, + gint *right); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GTK_TREE_PRIVATE_H__ */ + diff --git a/ltt/branches/poly/lttv/modules/guiEvents.c b/ltt/branches/poly/lttv/modules/guiEvents.c index 32da6cbd..b021a943 100644 --- a/ltt/branches/poly/lttv/modules/guiEvents.c +++ b/ltt/branches/poly/lttv/modules/guiEvents.c @@ -33,6 +33,7 @@ #include //#include #include "mw_api.h" +#include "gtktreeprivate.h" #include "icons/hGuiEventsInsert.xpm" @@ -170,7 +171,7 @@ GuiEvents(void) GtkTreeViewColumn *column; GtkCellRenderer *renderer; EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ; - gint width, height; + /* Create a model for storing the data list */ Event_Viewer_Data->Store_M = gtk_list_store_new (N_COLUMNS, /* Total number of columns */ G_TYPE_INT, /* CPUID */ @@ -256,8 +257,6 @@ GuiEvents(void) gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column); - gtk_cell_renderer_get_size(renderer, GTK_WIDGET(Event_Viewer_Data->Tree_V), NULL, NULL, NULL, &width, &height); - g_critical("first size h : %i",height); /* Setup the selection handler */ Event_Viewer_Data->Select_C = gtk_tree_view_get_selection (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V)); gtk_tree_selection_set_mode (Event_Viewer_Data->Select_C, GTK_SELECTION_SINGLE); @@ -287,7 +286,6 @@ GuiEvents(void) Event_Viewer_Data->VAdjust_C->step_increment = 1; Event_Viewer_Data->VAdjust_C->page_increment = Event_Viewer_Data->VTree_Adjust_C->upper; - //FIXME change page size dynamically to fit event list size Event_Viewer_Data->VAdjust_C->page_size = Event_Viewer_Data->VTree_Adjust_C->upper; g_critical("value : %u",Event_Viewer_Data->VTree_Adjust_C->upper); @@ -311,44 +309,49 @@ void v_scroll_cb (GtkAdjustment *adjustment, gpointer data) } +gint get_cell_height(GtkTreeView *TreeView) +{ + gint height, width; + GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0); + GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column); + GtkCellRenderer *Renderer = g_list_first(Render_List)->data; + + gtk_cell_renderer_get_size(Renderer, GTK_WIDGET(TreeView), + NULL, NULL, NULL, &width, &height); + + return height; +} + void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data) { EventViewerData *Event_Viewer_Data = (EventViewerData*)data; - + gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)); + g_critical("size-allocate"); - Event_Viewer_Data->Visible_Events = alloc->y ; - g_critical("num of event shown : %u",Event_Viewer_Data->Visible_Events); - - + Event_Viewer_Data->Visible_Events = ( alloc->height - + TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) ) + / Cell_Height ; + g_critical("number of events shown : %u",Event_Viewer_Data->Visible_Events); + + Event_Viewer_Data->VAdjust_C->page_increment = + Event_Viewer_Data->Visible_Events; + Event_Viewer_Data->VAdjust_C->page_size = + Event_Viewer_Data->Visible_Events; + } void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data) { - gint w, h; - gint height, width; - + gint h; EventViewerData *Event_Viewer_Data = (EventViewerData*)data; - GtkTreeViewColumn *Column = gtk_tree_view_get_column(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), 1); - GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column); - GtkCellRenderer *Renderer = g_list_first(Render_List)->data; + gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)); g_critical("size-request"); - //gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, &width, &height); - //h = height; - //gtk_cell_renderer_get_size(Renderer, GTK_WIDGET(Event_Viewer_Data->Tree_V), NULL, NULL, NULL, &width, &height); - //h += height; - //gtk_cell_renderer_get_fixed_size(Renderer,w,h); - - gtk_tree_view_tree_to_widget_coords(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), - 1,1,&width, &height); - w = width; - h = height; - //requisition->height = Cell_Height; - requisition->height = 46; - g_critical("width : %i height : %i", w, h); - + h = Cell_Height + TREE_VIEW_HEADER_HEIGHT + (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)); + requisition->height = h; } @@ -807,8 +810,8 @@ int main(int argc, char **argv) ListViewer = hGuiEvents(Window); gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0); - ListViewer = hGuiEvents(Window); - gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0); + //ListViewer = hGuiEvents(Window); + //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0); gtk_widget_show (VBox_V); gtk_widget_show (Window); -- 2.34.1