Pileus Git - ~andy/gtk/blob - gtk/gtkctree.h

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball, Josh MacDonald
   3  * Copyright (C) 1997-1998 Jay Painter <jpaint@serv.net><jpaint@gimp.org>
   4  *
   5  * GtkCTree widget for GTK+
   6  * Copyright (C) 1998 Lars Hamann and Stefan Jeske
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #ifndef __GTK_CTREE_H__
  25 #define __GTK_CTREE_H__
  26
  27 #include <gtk/gtkclist.h>
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif                          /* __cplusplus */
  32
  33 #define GTK_TYPE_CTREE            (gtk_ctree_get_type ())
  34 #define GTK_CTREE(obj)            (GTK_CHECK_CAST ((obj), GTK_TYPE_CTREE, GtkCTree))
  35 #define GTK_CTREE_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CTREE, GtkCTreeClass))
  36 #define GTK_IS_CTREE(obj)         (GTK_CHECK_TYPE ((obj), GTK_TYPE_CTREE))
  37 #define GTK_IS_CTREE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CTREE))
  38
  39 #define GTK_CTREE_ROW(_node_) ((GtkCTreeRow *)(((GList *)(_node_))->data))
  40 #define GTK_CTREE_NODE(_node_) ((GtkCTreeNode *)((_node_)))
  41 #define GTK_CTREE_NODE_NEXT(_nnode_) ((GtkCTreeNode *)(((GList *)(_nnode_))->next))
  42 #define GTK_CTREE_NODE_PREV(_pnode_) ((GtkCTreeNode *)(((GList *)(_pnode_))->prev))
  43 #define GTK_CTREE_FUNC(_func_) ((GtkCTreeFunc)(_func_))
  44
  45 typedef enum
  46 {
  47   GTK_CTREE_POS_BEFORE,
  48   GTK_CTREE_POS_AS_CHILD,
  49   GTK_CTREE_POS_AFTER
  50 } GtkCTreePos;
  51
  52 typedef enum
  53 {
  54   GTK_CTREE_LINES_NONE,
  55   GTK_CTREE_LINES_SOLID,
  56   GTK_CTREE_LINES_DOTTED,
  57   GTK_CTREE_LINES_TABBED
  58 } GtkCTreeLineStyle;
  59
  60 typedef enum
  61 {
  62   GTK_CTREE_EXPANDER_NONE,
  63   GTK_CTREE_EXPANDER_SQUARE,
  64   GTK_CTREE_EXPANDER_TRIANGLE,
  65   GTK_CTREE_EXPANDER_CIRCULAR
  66 } GtkCTreeExpanderStyle;
  67
  68 typedef enum
  69 {
  70   GTK_CTREE_EXPANSION_EXPAND,
  71   GTK_CTREE_EXPANSION_EXPAND_RECURSIVE,
  72   GTK_CTREE_EXPANSION_COLLAPSE,
  73   GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE,
  74   GTK_CTREE_EXPANSION_TOGGLE,
  75   GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE
  76 } GtkCTreeExpansionType;
  77
  78 typedef struct _GtkCTree      GtkCTree;
  79 typedef struct _GtkCTreeClass GtkCTreeClass;
  80 typedef struct _GtkCTreeRow   GtkCTreeRow;
  81 typedef struct _GtkCTreeNode  GtkCTreeNode;
  82
  83 typedef void (*GtkCTreeFunc) (GtkCTree     *ctree,
  84                               GtkCTreeNode *node,
  85                               gpointer      data);
  86
  87 typedef gboolean (*GtkCTreeGNodeFunc) (GtkCTree     *ctree,
  88                                        guint         depth,
  89                                        GNode        *gnode,
  90                                        GtkCTreeNode *cnode,
  91                                        gpointer      data);
  92
  93 typedef gboolean (*GtkCTreeCompareDragFunc) (GtkCTree     *ctree,
  94                                              GtkCTreeNode *source_node,
  95                                              GtkCTreeNode *new_parent,
  96                                              GtkCTreeNode *new_sibling);
  97
  98 struct _GtkCTree
  99 {
 100   GtkCList clist;
 101
 102   GdkGC *lines_gc;
 103   GdkWindow *drag_icon;
 104   gint icon_width;
 105   gint icon_height;
 106
 107   gint tree_indent;
 108   gint tree_spacing;
 109   gint tree_column;
 110   gint drag_row;
 111   GtkCTreeNode *drag_source;
 112   GtkCTreeNode *drag_target;
 113   gint insert_pos;
 114
 115   guint reorderable    : 1;
 116   guint use_icons      : 1;
 117   guint in_drag        : 1;
 118   guint drag_rect      : 1;
 119   guint line_style     : 2;
 120   guint expander_style : 2;
 121   guint show_stub      : 1;
 122
 123   GtkCTreeCompareDragFunc drag_compare;
 124 };
 125
 126 struct _GtkCTreeClass
 127 {
 128   GtkCListClass parent_class;
 129
 130   void (*tree_select_row)   (GtkCTree     *ctree,
 131                              GtkCTreeNode *row,
 132                              gint          column);
 133   void (*tree_unselect_row) (GtkCTree     *ctree,
 134                              GtkCTreeNode *row,
 135                              gint          column);
 136   void (*tree_expand)       (GtkCTree     *ctree,
 137                              GtkCTreeNode *node);
 138   void (*tree_collapse)     (GtkCTree     *ctree,
 139                              GtkCTreeNode *node);
 140   void (*tree_move)         (GtkCTree     *ctree,
 141                              GtkCTreeNode *node,
 142                              GtkCTreeNode *new_parent,
 143                              GtkCTreeNode *new_sibling);
 144   void (*change_focus_row_expansion) (GtkCTree *ctree,
 145                                       GtkCTreeExpansionType action);
 146 };
 147
 148 struct _GtkCTreeRow
 149 {
 150   GtkCListRow row;
 151
 152   GtkCTreeNode *parent;
 153   GtkCTreeNode *sibling;
 154   GtkCTreeNode *children;
 155
 156   GdkPixmap *pixmap_closed;
 157   GdkBitmap *mask_closed;
 158   GdkPixmap *pixmap_opened;
 159   GdkBitmap *mask_opened;
 160
 161   guint16 level;
 162
 163   guint is_leaf  : 1;
 164   guint expanded : 1;
 165 };
 166
 167 struct _GtkCTreeNode {
 168   GList list;
 169 };
 170
 171
 172 /***********************************************************
 173  *           Creation, insertion, deletion                 *
 174  ***********************************************************/
 175
 176 GtkType gtk_ctree_get_type                       (void);
 177 void gtk_ctree_construct                         (GtkCTree     *ctree,
 178                                                   gint          columns,
 179                                                   gint          tree_column,
 180                                                   const gchar  *titles[]);
 181 GtkWidget * gtk_ctree_new_with_titles            (gint          columns,
 182                                                   gint          tree_column,
 183                                                   const gchar  *titles[]);
 184 GtkWidget * gtk_ctree_new                        (gint          columns,
 185                                                   gint          tree_column);
 186 GtkCTreeNode * gtk_ctree_insert_node             (GtkCTree     *ctree,
 187                                                   GtkCTreeNode *parent,
 188                                                   GtkCTreeNode *sibling,
 189                                                   gchar        *text[],
 190                                                   guint8        spacing,
 191                                                   GdkPixmap    *pixmap_closed,
 192                                                   GdkBitmap    *mask_closed,
 193                                                   GdkPixmap    *pixmap_opened,
 194                                                   GdkBitmap    *mask_opened,
 195                                                   gboolean      is_leaf,
 196                                                   gboolean      expanded);
 197 void gtk_ctree_remove_node                       (GtkCTree     *ctree,
 198                                                   GtkCTreeNode *node);
 199 GtkCTreeNode * gtk_ctree_insert_gnode            (GtkCTree          *ctree,
 200                                                   GtkCTreeNode      *parent,
 201                                                   GtkCTreeNode      *sibling,
 202                                                   GNode             *gnode,
 203                                                   GtkCTreeGNodeFunc  func,
 204                                                   gpointer           data);
 205 GNode * gtk_ctree_export_to_gnode                (GtkCTree          *ctree,
 206                                                   GNode             *parent,
 207                                                   GNode             *sibling,
 208                                                   GtkCTreeNode      *node,
 209                                                   GtkCTreeGNodeFunc  func,
 210                                                   gpointer           data);
 211
 212 /***********************************************************
 213  *  Generic recursive functions, querying / finding tree   *
 214  *  information                                            *
 215  ***********************************************************/
 216
 217 void gtk_ctree_post_recursive                    (GtkCTree     *ctree,
 218                                                   GtkCTreeNode *node,
 219                                                   GtkCTreeFunc  func,
 220                                                   gpointer      data);
 221 void gtk_ctree_post_recursive_to_depth           (GtkCTree     *ctree,
 222                                                   GtkCTreeNode *node,
 223                                                   gint          depth,
 224                                                   GtkCTreeFunc  func,
 225                                                   gpointer      data);
 226 void gtk_ctree_pre_recursive                     (GtkCTree     *ctree,
 227                                                   GtkCTreeNode *node,
 228                                                   GtkCTreeFunc  func,
 229                                                   gpointer      data);
 230 void gtk_ctree_pre_recursive_to_depth            (GtkCTree     *ctree,
 231                                                   GtkCTreeNode *node,
 232                                                   gint          depth,
 233                                                   GtkCTreeFunc  func,
 234                                                   gpointer      data);
 235 gboolean gtk_ctree_is_viewable                   (GtkCTree     *ctree,
 236                                                   GtkCTreeNode *node);
 237 GtkCTreeNode * gtk_ctree_last                    (GtkCTree     *ctree,
 238                                                   GtkCTreeNode *node);
 239 GtkCTreeNode * gtk_ctree_find_node_ptr           (GtkCTree     *ctree,
 240                                                   GtkCTreeRow  *ctree_row);
 241 GtkCTreeNode * gtk_ctree_node_nth                (GtkCTree     *ctree,
 242                                                   guint         row);
 243 gboolean gtk_ctree_find                          (GtkCTree     *ctree,
 244                                                   GtkCTreeNode *node,
 245                                                   GtkCTreeNode *child);
 246 gboolean gtk_ctree_is_ancestor                   (GtkCTree     *ctree,
 247                                                   GtkCTreeNode *node,
 248                                                   GtkCTreeNode *child);
 249 GtkCTreeNode * gtk_ctree_find_by_row_data        (GtkCTree     *ctree,
 250                                                   GtkCTreeNode *node,
 251                                                   gpointer      data);
 252 /* returns a GList of all GtkCTreeNodes with row->data == data. */
 253 GList * gtk_ctree_find_all_by_row_data           (GtkCTree     *ctree,
 254                                                   GtkCTreeNode *node,
 255                                                   gpointer      data);
 256 GtkCTreeNode * gtk_ctree_find_by_row_data_custom (GtkCTree     *ctree,
 257                                                   GtkCTreeNode *node,
 258                                                   gpointer      data,
 259                                                   GCompareFunc  func);
 260 /* returns a GList of all GtkCTreeNodes with row->data == data. */
 261 GList * gtk_ctree_find_all_by_row_data_custom    (GtkCTree     *ctree,
 262                                                   GtkCTreeNode *node,
 263                                                   gpointer      data,
 264                                                   GCompareFunc  func);
 265 gboolean gtk_ctree_is_hot_spot                   (GtkCTree     *ctree,
 266                                                   gint          x,
 267                                                   gint          y);
 268
 269 /***********************************************************
 270  *   Tree signals : move, expand, collapse, (un)select     *
 271  ***********************************************************/
 272
 273 void gtk_ctree_move                              (GtkCTree     *ctree,
 274                                                   GtkCTreeNode *node,
 275                                                   GtkCTreeNode *new_parent,
 276                                                   GtkCTreeNode *new_sibling);
 277 void gtk_ctree_expand                            (GtkCTree     *ctree,
 278                                                   GtkCTreeNode *node);
 279 void gtk_ctree_expand_recursive                  (GtkCTree     *ctree,
 280                                                   GtkCTreeNode *node);
 281 void gtk_ctree_expand_to_depth                   (GtkCTree     *ctree,
 282                                                   GtkCTreeNode *node,
 283                                                   gint          depth);
 284 void gtk_ctree_collapse                          (GtkCTree     *ctree,
 285                                                   GtkCTreeNode *node);
 286 void gtk_ctree_collapse_recursive                (GtkCTree     *ctree,
 287                                                   GtkCTreeNode *node);
 288 void gtk_ctree_collapse_to_depth                 (GtkCTree     *ctree,
 289                                                   GtkCTreeNode *node,
 290                                                   gint          depth);
 291 void gtk_ctree_toggle_expansion                  (GtkCTree     *ctree,
 292                                                   GtkCTreeNode *node);
 293 void gtk_ctree_toggle_expansion_recursive        (GtkCTree     *ctree,
 294                                                   GtkCTreeNode *node);
 295 void gtk_ctree_select                            (GtkCTree     *ctree,
 296                                                   GtkCTreeNode *node);
 297 void gtk_ctree_select_recursive                  (GtkCTree     *ctree,
 298                                                   GtkCTreeNode *node);
 299 void gtk_ctree_unselect                          (GtkCTree     *ctree,
 300                                                   GtkCTreeNode *node);
 301 void gtk_ctree_unselect_recursive                (GtkCTree     *ctree,
 302                                                   GtkCTreeNode *node);
 303 void gtk_ctree_real_select_recursive             (GtkCTree     *ctree,
 304                                                   GtkCTreeNode *node,
 305                                                   gint          state);
 306
 307 /***********************************************************
 308  *           Analogons of GtkCList functions               *
 309  ***********************************************************/
 310
 311 void gtk_ctree_node_set_text                     (GtkCTree     *ctree,
 312                                                   GtkCTreeNode *node,
 313                                                   gint          column,
 314                                                   const gchar  *text);
 315 void gtk_ctree_node_set_pixmap                   (GtkCTree     *ctree,
 316                                                   GtkCTreeNode *node,
 317                                                   gint          column,
 318                                                   GdkPixmap    *pixmap,
 319                                                   GdkBitmap    *mask);
 320 void gtk_ctree_node_set_pixtext                  (GtkCTree     *ctree,
 321                                                   GtkCTreeNode *node,
 322                                                   gint          column,
 323                                                   const gchar  *text,
 324                                                   guint8        spacing,
 325                                                   GdkPixmap    *pixmap,
 326                                                   GdkBitmap    *mask);
 327 void gtk_ctree_set_node_info                     (GtkCTree     *ctree,
 328                                                   GtkCTreeNode *node,
 329                                                   const gchar  *text,
 330                                                   guint8        spacing,
 331                                                   GdkPixmap    *pixmap_closed,
 332                                                   GdkBitmap    *mask_closed,
 333                                                   GdkPixmap    *pixmap_opened,
 334                                                   GdkBitmap    *mask_opened,
 335                                                   gboolean      is_leaf,
 336                                                   gboolean      expanded);
 337 void gtk_ctree_node_set_shift                    (GtkCTree     *ctree,
 338                                                   GtkCTreeNode *node,
 339                                                   gint          column,
 340                                                   gint          vertical,
 341                                                   gint          horizontal);
 342 void gtk_ctree_node_set_selectable               (GtkCTree     *ctree,
 343                                                   GtkCTreeNode *node,
 344                                                   gboolean      selectable);
 345 gboolean gtk_ctree_node_get_selectable           (GtkCTree     *ctree,
 346                                                   GtkCTreeNode *node);
 347 GtkCellType gtk_ctree_node_get_cell_type         (GtkCTree     *ctree,
 348                                                   GtkCTreeNode *node,
 349                                                   gint          column);
 350 gint gtk_ctree_node_get_text                     (GtkCTree     *ctree,
 351                                                   GtkCTreeNode *node,
 352                                                   gint          column,
 353                                                   gchar       **text);
 354 gint gtk_ctree_node_get_pixmap                   (GtkCTree     *ctree,
 355                                                   GtkCTreeNode *node,
 356                                                   gint          column,
 357                                                   GdkPixmap   **pixmap,
 358                                                   GdkBitmap   **mask);
 359 gint gtk_ctree_node_get_pixtext                  (GtkCTree     *ctree,
 360                                                   GtkCTreeNode *node,
 361                                                   gint          column,
 362                                                   gchar       **text,
 363                                                   guint8       *spacing,
 364                                                   GdkPixmap   **pixmap,
 365                                                   GdkBitmap   **mask);
 366 gint gtk_ctree_get_node_info                     (GtkCTree     *ctree,
 367                                                   GtkCTreeNode *node,
 368                                                   gchar       **text,
 369                                                   guint8       *spacing,
 370                                                   GdkPixmap   **pixmap_closed,
 371                                                   GdkBitmap   **mask_closed,
 372                                                   GdkPixmap   **pixmap_opened,
 373                                                   GdkBitmap   **mask_opened,
 374                                                   gboolean     *is_leaf,
 375                                                   gboolean     *expanded);
 376 void gtk_ctree_node_set_row_style                (GtkCTree     *ctree,
 377                                                   GtkCTreeNode *node,
 378                                                   GtkStyle     *style);
 379 GtkStyle * gtk_ctree_node_get_row_style          (GtkCTree     *ctree,
 380                                                   GtkCTreeNode *node);
 381 void gtk_ctree_node_set_cell_style               (GtkCTree     *ctree,
 382                                                   GtkCTreeNode *node,
 383                                                   gint          column,
 384                                                   GtkStyle     *style);
 385 GtkStyle * gtk_ctree_node_get_cell_style         (GtkCTree     *ctree,
 386                                                   GtkCTreeNode *node,
 387                                                   gint          column);
 388 void gtk_ctree_node_set_foreground               (GtkCTree     *ctree,
 389                                                   GtkCTreeNode *node,
 390                                                   GdkColor     *color);
 391 void gtk_ctree_node_set_background               (GtkCTree     *ctree,
 392                                                   GtkCTreeNode *node,
 393                                                   GdkColor     *color);
 394 void gtk_ctree_node_set_row_data                 (GtkCTree     *ctree,
 395                                                   GtkCTreeNode *node,
 396                                                   gpointer      data);
 397 void gtk_ctree_node_set_row_data_full            (GtkCTree     *ctree,
 398                                                   GtkCTreeNode *node,
 399                                                   gpointer      data,
 400                                                   GtkDestroyNotify destroy);
 401 gpointer gtk_ctree_node_get_row_data             (GtkCTree     *ctree,
 402                                                   GtkCTreeNode *node);
 403 void gtk_ctree_node_moveto                       (GtkCTree     *ctree,
 404                                                   GtkCTreeNode *node,
 405                                                   gint          column,
 406                                                   gfloat        row_align,
 407                                                   gfloat        col_align);
 408 GtkVisibility gtk_ctree_node_is_visible          (GtkCTree     *ctree,
 409                                                   GtkCTreeNode *node);
 410
 411 /***********************************************************
 412  *             GtkCTree specific functions                 *
 413  ***********************************************************/
 414
 415 void gtk_ctree_set_indent            (GtkCTree                *ctree,
 416                                       gint                     indent);
 417 void gtk_ctree_set_spacing           (GtkCTree                *ctree,
 418                                       gint                     spacing);
 419 void gtk_ctree_set_show_stub         (GtkCTree                *ctree,
 420                                       gboolean                 show_stub);
 421 void gtk_ctree_set_reorderable       (GtkCTree                *ctree,
 422                                       gboolean                 reorderable);
 423 void gtk_ctree_set_use_drag_icons    (GtkCTree                *ctree,
 424                                       gboolean                 use_icons);
 425 void gtk_ctree_set_line_style        (GtkCTree                *ctree,
 426                                       GtkCTreeLineStyle        line_style);
 427 void gtk_ctree_set_expander_style    (GtkCTree                *ctree,
 428                                       GtkCTreeExpanderStyle    expander_style);
 429 void gtk_ctree_set_drag_compare_func (GtkCTree                *ctree,
 430                                       GtkCTreeCompareDragFunc  cmp_func);
 431
 432 /***********************************************************
 433  *             Tree sorting functions                      *
 434  ***********************************************************/
 435
 436 void gtk_ctree_sort_node                         (GtkCTree     *ctree,
 437                                                   GtkCTreeNode *node);
 438 void gtk_ctree_sort_recursive                    (GtkCTree     *ctree,
 439                                                   GtkCTreeNode *node);
 440
 441
 442 /* deprecated*/
 443 void gtk_ctree_show_stub             (GtkCTree                *ctree,
 444                                       gboolean                 show_stub);
 445
 446
 447
 448 #ifdef __cplusplus
 449 }
 450 #endif                          /* __cplusplus */
 451
 452 #endif                          /* __GTK_CTREE_H__ */