src/gtk/gtkcmclist.c

   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  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include <config.h>
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <gtk/gtk.h>
  34 #include "claws-marshal.h"
  35 #include "gtkcmclist.h"
  36 #include <gdk/gdkkeysyms.h>
  37
  38 /* length of button_actions array */
  39 #define MAX_BUTTON 5
  40
  41 /* the number rows memchunk expands at a time */
  42 #define CMCLIST_OPTIMUM_SIZE 64
  43
  44 /* the width of the column resize windows */
  45 #define DRAG_WIDTH  6
  46
  47 /* minimum allowed width of a column */
  48 #define COLUMN_MIN_WIDTH 5
  49
  50 /* this defigns the base grid spacing */
  51 #define CELL_SPACING 1
  52
  53 /* added the horizontal space at the beginning and end of a row*/
  54 #define COLUMN_INSET 3
  55
  56 /* used for auto-scrolling */
  57 #define SCROLL_TIME  100
  58
  59 /* gives the top pixel of the given row in context of
  60  * the clist's voffset */
  61 #define ROW_TOP_YPIXEL(clist, row) (((clist)->row_height * (row)) + \
  62                                     (((row) + 1) * CELL_SPACING) + \
  63                                     (clist)->voffset)
  64
  65 /* returns the row index from a y pixel location in the
  66  * context of the clist's voffset */
  67 #define ROW_FROM_YPIXEL(clist, y)  (((y) - (clist)->voffset) / \
  68                                     ((clist)->row_height + CELL_SPACING))
  69
  70 /* gives the left pixel of the given column in context of
  71  * the clist's hoffset */
  72 #define COLUMN_LEFT_XPIXEL(clist, colnum)  ((clist)->column[(colnum)].area.x + \
  73                                             (clist)->hoffset)
  74
  75 /* returns the column index from a x pixel location in the
  76  * context of the clist's hoffset */
  77 static inline gint
  78 COLUMN_FROM_XPIXEL (GtkCMCList * clist,
  79                     gint x)
  80 {
  81   gint i, cx;
  82
  83   for (i = 0; i < clist->columns; i++)
  84     if (clist->column[i].visible)
  85       {
  86         cx = clist->column[i].area.x + clist->hoffset;
  87
  88         if (x >= (cx - (COLUMN_INSET + CELL_SPACING)) &&
  89             x <= (cx + clist->column[i].area.width + COLUMN_INSET))
  90           return i;
  91       }
  92
  93   /* no match */
  94   return -1;
  95 }
  96
  97 /* returns the top pixel of the given row in the context of
  98  * the list height */
  99 #define ROW_TOP(clist, row)        (((clist)->row_height + CELL_SPACING) * (row))
 100
 101 /* returns the left pixel of the given column in the context of
 102  * the list width */
 103 #define COLUMN_LEFT(clist, colnum) ((clist)->column[(colnum)].area.x)
 104
 105 /* returns the total height of the list */
 106 #define LIST_HEIGHT(clist)         (((clist)->row_height * ((clist)->rows)) + \
 107                                     (CELL_SPACING * ((clist)->rows + 1)))
 108
 109
 110 /* returns the total width of the list */
 111 static inline gint
 112 LIST_WIDTH (GtkCMCList * clist)
 113 {
 114   gint last_column;
 115
 116   for (last_column = clist->columns - 1;
 117        last_column >= 0 && !clist->column[last_column].visible; last_column--);
 118
 119   if (last_column >= 0)
 120     return (clist->column[last_column].area.x +
 121             clist->column[last_column].area.width +
 122             COLUMN_INSET + CELL_SPACING);
 123   return 0;
 124 }
 125
 126 /* returns the GList item for the nth row */
 127 #define ROW_ELEMENT(clist, row) (((row) == (clist)->rows - 1) ? \
 128                                  (clist)->row_list_end : \
 129                                  g_list_nth ((clist)->row_list, (row)))
 130
 131
 132 /* redraw the list if it's not frozen */
 133 #define CLIST_UNFROZEN(clist)     (((GtkCMCList*) (clist))->freeze_count == 0)
 134 #define CLIST_REFRESH(clist)    G_STMT_START { \
 135   if (CLIST_UNFROZEN (clist)) \
 136     GTK_CMCLIST_GET_CLASS (clist)->refresh ((GtkCMCList*) (clist)); \
 137 } G_STMT_END
 138
 139
 140 /* Signals */
 141 enum {
 142   SELECT_ROW,
 143   UNSELECT_ROW,
 144   ROW_MOVE,
 145   CLICK_COLUMN,
 146   RESIZE_COLUMN,
 147   TOGGLE_FOCUS_ROW,
 148   SELECT_ALL,
 149   UNSELECT_ALL,
 150   UNDO_SELECTION,
 151   START_SELECTION,
 152   END_SELECTION,
 153   TOGGLE_ADD_MODE,
 154   EXTEND_SELECTION,
 155   SCROLL_VERTICAL,
 156   SCROLL_HORIZONTAL,
 157   ABORT_COLUMN_RESIZE,
 158   LAST_SIGNAL
 159 };
 160
 161 enum {
 162   SYNC_REMOVE,
 163   SYNC_INSERT
 164 };
 165
 166 enum {
 167   ARG_0,
 168   ARG_N_COLUMNS,
 169   ARG_SHADOW_TYPE,
 170   ARG_SELECTION_MODE,
 171   ARG_ROW_HEIGHT,
 172   ARG_TITLES_ACTIVE,
 173   ARG_REORDERABLE,
 174   ARG_USE_DRAG_ICONS,
 175   ARG_SORT_TYPE
 176 };
 177
 178 /* GtkCMCList Methods */
 179 static void     gtk_cmclist_class_init  (GtkCMCListClass         *klass);
 180 static void     gtk_cmclist_init        (GtkCMCList              *clist);
 181 static GObject* gtk_cmclist_constructor (GType                  type,
 182                                        guint                  n_construct_properties,
 183                                        GObjectConstructParam *construct_params);
 184
 185 /* GtkObject Methods */
 186 static void gtk_cmclist_destroy  (GtkObject *object);
 187 static void gtk_cmclist_finalize (GObject   *object);
 188 static void gtk_cmclist_set_arg  (GObject *object,
 189                                 guint      arg_id,
 190                                 const GValue *value,
 191                                 GParamSpec *spec);
 192 static void gtk_cmclist_get_arg  (GObject *object,
 193                                 guint      arg_id,
 194                                 GValue *value,
 195                                 GParamSpec *spec);
 196
 197 /* GtkWidget Methods */
 198 static void gtk_cmclist_set_scroll_adjustments (GtkCMCList      *clist,
 199                                               GtkAdjustment *hadjustment,
 200                                               GtkAdjustment *vadjustment);
 201 static void gtk_cmclist_realize         (GtkWidget        *widget);
 202 static void gtk_cmclist_unrealize       (GtkWidget        *widget);
 203 static void gtk_cmclist_map             (GtkWidget        *widget);
 204 static void gtk_cmclist_unmap           (GtkWidget        *widget);
 205 static gint gtk_cmclist_expose          (GtkWidget        *widget,
 206                                        GdkEventExpose   *event);
 207 static gint gtk_cmclist_button_press    (GtkWidget        *widget,
 208                                        GdkEventButton   *event);
 209 static gint gtk_cmclist_button_release  (GtkWidget        *widget,
 210                                        GdkEventButton   *event);
 211 static gint gtk_cmclist_motion          (GtkWidget        *widget,
 212                                        GdkEventMotion   *event);
 213 static void gtk_cmclist_size_request    (GtkWidget        *widget,
 214                                        GtkRequisition   *requisition);
 215 static void gtk_cmclist_size_allocate   (GtkWidget        *widget,
 216                                        GtkAllocation    *allocation);
 217 static void gtk_cmclist_draw_focus      (GtkWidget        *widget);
 218 static gint gtk_cmclist_focus_in        (GtkWidget        *widget,
 219                                        GdkEventFocus    *event);
 220 static gint gtk_cmclist_focus_out       (GtkWidget        *widget,
 221                                        GdkEventFocus    *event);
 222 static gint gtk_cmclist_focus           (GtkWidget        *widget,
 223                                        GtkDirectionType  direction);
 224 static void gtk_cmclist_set_focus_child (GtkContainer     *container,
 225                                        GtkWidget        *child);
 226 static void gtk_cmclist_style_set       (GtkWidget        *widget,
 227                                        GtkStyle         *previous_style);
 228 static void gtk_cmclist_drag_begin      (GtkWidget        *widget,
 229                                        GdkDragContext   *context);
 230 static gint gtk_cmclist_drag_motion     (GtkWidget        *widget,
 231                                        GdkDragContext   *context,
 232                                        gint              x,
 233                                        gint              y,
 234                                        guint             time);
 235 static void gtk_cmclist_drag_leave      (GtkWidget        *widget,
 236                                        GdkDragContext   *context,
 237                                        guint             time);
 238 static void gtk_cmclist_drag_end        (GtkWidget        *widget,
 239                                        GdkDragContext   *context);
 240 static gboolean gtk_cmclist_drag_drop   (GtkWidget      *widget,
 241                                        GdkDragContext *context,
 242                                        gint            x,
 243                                        gint            y,
 244                                        guint           time);
 245 static void gtk_cmclist_drag_data_get   (GtkWidget        *widget,
 246                                        GdkDragContext   *context,
 247                                        GtkSelectionData *selection_data,
 248                                        guint             info,
 249                                        guint             time);
 250 static void gtk_cmclist_drag_data_received (GtkWidget        *widget,
 251                                           GdkDragContext   *context,
 252                                           gint              x,
 253                                           gint              y,
 254                                           GtkSelectionData *selection_data,
 255                                           guint             info,
 256                                           guint             time);
 257
 258 /* GtkContainer Methods */
 259 static void gtk_cmclist_forall          (GtkContainer  *container,
 260                                        gboolean       include_internals,
 261                                        GtkCallback    callback,
 262                                        gpointer       callback_data);
 263
 264 /* Selection */
 265 static void toggle_row                (GtkCMCList      *clist,
 266                                        gint           row,
 267                                        gint           column,
 268                                        GdkEvent      *event);
 269 static void real_select_row           (GtkCMCList      *clist,
 270                                        gint           row,
 271                                        gint           column,
 272                                        GdkEvent      *event);
 273 static void real_unselect_row         (GtkCMCList      *clist,
 274                                        gint           row,
 275                                        gint           column,
 276                                        GdkEvent      *event);
 277 static void update_extended_selection (GtkCMCList      *clist,
 278                                        gint           row);
 279 static GList *selection_find          (GtkCMCList      *clist,
 280                                        gint           row_number,
 281                                        GList         *row_list_element);
 282 static void real_select_all           (GtkCMCList      *clist);
 283 static void real_unselect_all         (GtkCMCList      *clist);
 284 static void move_vertical             (GtkCMCList      *clist,
 285                                        gint           row,
 286                                        gfloat         align);
 287 static void move_horizontal           (GtkCMCList      *clist,
 288                                        gint           diff);
 289 static void real_undo_selection       (GtkCMCList      *clist);
 290 static void fake_unselect_all         (GtkCMCList      *clist,
 291                                        gint           row);
 292 static void fake_toggle_row           (GtkCMCList      *clist,
 293                                        gint           row);
 294 static void resync_selection          (GtkCMCList      *clist,
 295                                        GdkEvent      *event);
 296 static void sync_selection            (GtkCMCList      *clist,
 297                                        gint           row,
 298                                        gint           mode);
 299 static void set_anchor                (GtkCMCList      *clist,
 300                                        gboolean       add_mode,
 301                                        gint           anchor,
 302                                        gint           undo_anchor);
 303 static void start_selection           (GtkCMCList      *clist);
 304 static void end_selection             (GtkCMCList      *clist);
 305 static void toggle_add_mode           (GtkCMCList      *clist);
 306 static void toggle_focus_row          (GtkCMCList      *clist);
 307 static void extend_selection          (GtkCMCList      *clist,
 308                                        GtkScrollType  scroll_type,
 309                                        gfloat         position,
 310                                        gboolean       auto_start_selection);
 311 static gint get_selection_info        (GtkCMCList       *clist,
 312                                        gint            x,
 313                                        gint            y,
 314                                        gint           *row,
 315                                        gint           *column);
 316
 317 /* Scrolling */
 318 static void move_focus_row     (GtkCMCList      *clist,
 319                                 GtkScrollType  scroll_type,
 320                                 gfloat         position);
 321 static void scroll_horizontal  (GtkCMCList      *clist,
 322                                 GtkScrollType  scroll_type,
 323                                 gfloat         position);
 324 static void scroll_vertical    (GtkCMCList      *clist,
 325                                 GtkScrollType  scroll_type,
 326                                 gfloat         position);
 327 static void move_horizontal    (GtkCMCList      *clist,
 328                                 gint           diff);
 329 static void move_vertical      (GtkCMCList      *clist,
 330                                 gint           row,
 331                                 gfloat         align);
 332 static gint horizontal_timeout (GtkCMCList      *clist);
 333 static gint vertical_timeout   (GtkCMCList      *clist);
 334 static void remove_grab        (GtkCMCList      *clist);
 335
 336
 337 /* Resize Columns */
 338 static void draw_xor_line             (GtkCMCList       *clist);
 339 static gint new_column_width          (GtkCMCList       *clist,
 340                                        gint            column,
 341                                        gint           *x);
 342 static void column_auto_resize        (GtkCMCList       *clist,
 343                                        GtkCMCListRow    *clist_row,
 344                                        gint            column,
 345                                        gint            old_width);
 346 static void real_resize_column        (GtkCMCList       *clist,
 347                                        gint            column,
 348                                        gint            width);
 349 static void abort_column_resize       (GtkCMCList       *clist);
 350 static void cell_size_request         (GtkCMCList       *clist,
 351                                        GtkCMCListRow    *clist_row,
 352                                        gint            column,
 353                                        GtkRequisition *requisition);
 354
 355 /* Buttons */
 356 static void column_button_create      (GtkCMCList       *clist,
 357                                        gint            column);
 358 static void column_button_clicked     (GtkWidget      *widget,
 359                                        gpointer        data);
 360
 361 /* Adjustments */
 362 static void adjust_adjustments        (GtkCMCList       *clist,
 363                                        gboolean        block_resize);
 364 static void vadjustment_changed       (GtkAdjustment  *adjustment,
 365                                        gpointer        data);
 366 static void vadjustment_value_changed (GtkAdjustment  *adjustment,
 367                                        gpointer        data);
 368 static void hadjustment_changed       (GtkAdjustment  *adjustment,
 369                                        gpointer        data);
 370 static void hadjustment_value_changed (GtkAdjustment  *adjustment,
 371                                        gpointer        data);
 372
 373 /* Drawing */
 374 static void get_cell_style   (GtkCMCList      *clist,
 375                               GtkCMCListRow   *clist_row,
 376                               gint           state,
 377                               gint           column,
 378                               GtkStyle     **style,
 379                               GdkGC        **fg_gc,
 380                               GdkGC        **bg_gc);
 381 static gint draw_cell_pixmap (GdkWindow     *window,
 382                               GdkRectangle  *clip_rectangle,
 383                               GdkGC         *fg_gc,
 384                               GdkPixmap     *pixmap,
 385                               GdkBitmap     *mask,
 386                               gint           x,
 387                               gint           y,
 388                               gint           width,
 389                               gint           height);
 390 static void draw_row         (GtkCMCList      *clist,
 391                               GdkRectangle  *area,
 392                               gint           row,
 393                               GtkCMCListRow   *clist_row);
 394 static void draw_rows        (GtkCMCList      *clist,
 395                               GdkRectangle  *area);
 396 static void clist_refresh    (GtkCMCList      *clist);
 397 static void draw_drag_highlight (GtkCMCList        *clist,
 398                                  GtkCMCListRow     *dest_row,
 399                                  gint             dest_row_number,
 400                                  GtkCMCListDragPos  drag_pos);
 401
 402 /* Size Allocation / Requisition */
 403 static void size_allocate_title_buttons (GtkCMCList *clist);
 404 static void size_allocate_columns       (GtkCMCList *clist,
 405                                          gboolean  block_resize);
 406 static gint list_requisition_width      (GtkCMCList *clist);
 407
 408 /* Memory Allocation/Distruction Routines */
 409 static GtkCMCListColumn *columns_new (GtkCMCList      *clist);
 410 static void column_title_new       (GtkCMCList      *clist,
 411                                     gint           column,
 412                                     const gchar   *title);
 413 static void columns_delete         (GtkCMCList      *clist);
 414 static GtkCMCListRow *row_new        (GtkCMCList      *clist);
 415 static void row_delete             (GtkCMCList      *clist,
 416                                     GtkCMCListRow   *clist_row);
 417 static void set_cell_contents      (GtkCMCList      *clist,
 418                                     GtkCMCListRow   *clist_row,
 419                                     gint           column,
 420                                     GtkCMCellType    type,
 421                                     const gchar   *text,
 422                                     guint8         spacing,
 423                                     GdkPixmap     *pixmap,
 424                                     GdkBitmap     *mask);
 425 static gint real_insert_row        (GtkCMCList      *clist,
 426                                     gint           row,
 427                                     gchar         *text[]);
 428 static void real_remove_row        (GtkCMCList      *clist,
 429                                     gint           row);
 430 static void real_clear             (GtkCMCList      *clist);
 431
 432 /* Sorting */
 433 static gint default_compare        (GtkCMCList      *clist,
 434                                     gconstpointer  row1,
 435                                     gconstpointer  row2);
 436 static void real_sort_list         (GtkCMCList      *clist);
 437 static GList *gtk_cmclist_merge      (GtkCMCList      *clist,
 438                                     GList         *a,
 439                                     GList         *b);
 440 static GList *gtk_cmclist_mergesort  (GtkCMCList      *clist,
 441                                     GList         *list,
 442                                     gint           num);
 443 /* Misc */
 444 static gboolean title_focus_in   (GtkCMCList *clist,
 445                                   gint      dir);
 446 static gboolean title_focus_move (GtkCMCList *clist,
 447                                   gint      dir);
 448
 449 static void real_row_move             (GtkCMCList  *clist,
 450                                        gint       source_row,
 451                                        gint       dest_row);
 452 static gint column_title_passive_func (GtkWidget *widget,
 453                                        GdkEvent  *event,
 454                                        gpointer   data);
 455 static void drag_dest_cell            (GtkCMCList         *clist,
 456                                        gint              x,
 457                                        gint              y,
 458                                        GtkCMCListDestInfo *dest_info);
 459
 460
 461
 462 static GtkContainerClass *parent_class = NULL;
 463 static guint clist_signals[LAST_SIGNAL] = {0};
 464
 465 static const GtkTargetEntry clist_target_table = { "gtk-clist-drag-reorder", 0, 0};
 466
 467 GType
 468 gtk_cmclist_get_type (void)
 469 {
 470   static GType clist_type = 0;
 471
 472   if (!clist_type)
 473     {
 474       static const GTypeInfo clist_info =
 475       {
 476                         sizeof (GtkCMCListClass),
 477
 478                         (GBaseInitFunc) NULL,
 479                         (GBaseFinalizeFunc) NULL,
 480
 481                         (GClassInitFunc) gtk_cmclist_class_init,
 482                         (GClassFinalizeFunc) NULL,
 483                         NULL,   /* class_data */
 484
 485                         sizeof (GtkCMCList),
 486                         0,      /* n_preallocs */
 487                         (GInstanceInitFunc) gtk_cmclist_init,
 488         };
 489         clist_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkCMCList", &clist_info, (GTypeFlags)0);
 490     }
 491
 492   return clist_type;
 493 }
 494
 495 static void
 496 gtk_cmclist_class_init (GtkCMCListClass *klass)
 497 {
 498   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 499   GtkObjectClass *gtk_object_class;
 500   GtkWidgetClass *widget_class;
 501   GtkContainerClass *container_class;
 502   GtkBindingSet *binding_set;
 503
 504   object_class->constructor = gtk_cmclist_constructor;
 505
 506   gtk_object_class = (GtkObjectClass *) klass;
 507   widget_class = (GtkWidgetClass *) klass;
 508   container_class = (GtkContainerClass *) klass;
 509
 510   parent_class = g_type_class_peek (GTK_TYPE_CONTAINER);
 511
 512   object_class->finalize = gtk_cmclist_finalize;
 513   gtk_object_class->destroy = gtk_cmclist_destroy;
 514   object_class->set_property = gtk_cmclist_set_arg;
 515   object_class->get_property = gtk_cmclist_get_arg;
 516
 517
 518   widget_class->realize = gtk_cmclist_realize;
 519   widget_class->unrealize = gtk_cmclist_unrealize;
 520   widget_class->map = gtk_cmclist_map;
 521   widget_class->unmap = gtk_cmclist_unmap;
 522   widget_class->button_press_event = gtk_cmclist_button_press;
 523   widget_class->button_release_event = gtk_cmclist_button_release;
 524   widget_class->motion_notify_event = gtk_cmclist_motion;
 525   widget_class->expose_event = gtk_cmclist_expose;
 526   widget_class->size_request = gtk_cmclist_size_request;
 527   widget_class->size_allocate = gtk_cmclist_size_allocate;
 528   widget_class->focus_in_event = gtk_cmclist_focus_in;
 529   widget_class->focus_out_event = gtk_cmclist_focus_out;
 530   widget_class->style_set = gtk_cmclist_style_set;
 531   widget_class->drag_begin = gtk_cmclist_drag_begin;
 532   widget_class->drag_end = gtk_cmclist_drag_end;
 533   widget_class->drag_motion = gtk_cmclist_drag_motion;
 534   widget_class->drag_leave = gtk_cmclist_drag_leave;
 535   widget_class->drag_drop = gtk_cmclist_drag_drop;
 536   widget_class->drag_data_get = gtk_cmclist_drag_data_get;
 537   widget_class->drag_data_received = gtk_cmclist_drag_data_received;
 538   widget_class->focus = gtk_cmclist_focus;
 539
 540   /* container_class->add = NULL; use the default GtkContainerClass warning */
 541   /* container_class->remove=NULL; use the default GtkContainerClass warning */
 542
 543   container_class->forall = gtk_cmclist_forall;
 544   container_class->set_focus_child = gtk_cmclist_set_focus_child;
 545
 546   klass->set_scroll_adjustments = gtk_cmclist_set_scroll_adjustments;
 547   klass->refresh = clist_refresh;
 548   klass->select_row = real_select_row;
 549   klass->unselect_row = real_unselect_row;
 550   klass->row_move = real_row_move;
 551   klass->undo_selection = real_undo_selection;
 552   klass->resync_selection = resync_selection;
 553   klass->selection_find = selection_find;
 554   klass->click_column = NULL;
 555   klass->resize_column = real_resize_column;
 556   klass->draw_row = draw_row;
 557   klass->draw_drag_highlight = draw_drag_highlight;
 558   klass->insert_row = real_insert_row;
 559   klass->remove_row = real_remove_row;
 560   klass->clear = real_clear;
 561   klass->sort_list = real_sort_list;
 562   klass->select_all = real_select_all;
 563   klass->unselect_all = real_unselect_all;
 564   klass->fake_unselect_all = fake_unselect_all;
 565   klass->scroll_horizontal = scroll_horizontal;
 566   klass->scroll_vertical = scroll_vertical;
 567   klass->extend_selection = extend_selection;
 568   klass->toggle_focus_row = toggle_focus_row;
 569   klass->toggle_add_mode = toggle_add_mode;
 570   klass->start_selection = start_selection;
 571   klass->end_selection = end_selection;
 572   klass->abort_column_resize = abort_column_resize;
 573   klass->set_cell_contents = set_cell_contents;
 574   klass->cell_size_request = cell_size_request;
 575
 576   g_object_class_install_property (object_class,
 577                                 ARG_N_COLUMNS,
 578                                 g_param_spec_uint ("n-columns",
 579                                 "N-Columns",
 580                                 "N-Columns",
 581                                 1,
 582                                 G_MAXINT,
 583                                 1,
 584                                 G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
 585   g_object_class_install_property (object_class,
 586                                 ARG_SHADOW_TYPE,
 587                                 g_param_spec_enum ("shadow-type",
 588                                 "shadow-type",
 589                                 "shadow-type",
 590                                 GTK_TYPE_SHADOW_TYPE, 0,
 591                                 G_PARAM_READWRITE));
 592   g_object_class_install_property (object_class,
 593                                 ARG_SELECTION_MODE,
 594                                 g_param_spec_enum ("selection-mode",
 595                                 "selection-mode",
 596                                 "selection-mode",
 597                                 GTK_TYPE_SELECTION_MODE, 0,
 598                                 G_PARAM_READWRITE));
 599   g_object_class_install_property (object_class,
 600                                 ARG_ROW_HEIGHT,
 601                                 g_param_spec_uint ("row-height",
 602                                 "row-height",
 603                                 "row-height",
 604                                 0,
 605                                 G_MAXINT,
 606                                 0,
 607                                 G_PARAM_READWRITE));
 608   g_object_class_install_property (object_class,
 609                                 ARG_REORDERABLE,
 610                                 g_param_spec_boolean ("reorderable",
 611                                 "reorderable",
 612                                 "reorderable",
 613                                 TRUE,
 614                                 G_PARAM_READWRITE));
 615   g_object_class_install_property (object_class,
 616                                 ARG_TITLES_ACTIVE,
 617                                 g_param_spec_boolean ("titles-active",
 618                                 "titles-active",
 619                                 "titles-active",
 620                                 TRUE,
 621                                 G_PARAM_READWRITE));
 622   g_object_class_install_property (object_class,
 623                                 ARG_USE_DRAG_ICONS,
 624                                 g_param_spec_boolean ("use-drag-icons",
 625                                 "use-drag-icons",
 626                                 "use-drag-icons",
 627                                 TRUE,
 628                                 G_PARAM_READWRITE));
 629   g_object_class_install_property (object_class,
 630                                 ARG_SORT_TYPE,
 631                                 g_param_spec_enum ("sort-type",
 632                                 "sort-type",
 633                                 "sort-type",
 634                                 GTK_TYPE_SORT_TYPE, 0,
 635                                 G_PARAM_READWRITE));
 636   widget_class->set_scroll_adjustments_signal =
 637                 g_signal_new ("set_scroll_adjustments",
 638                               G_TYPE_FROM_CLASS (object_class),
 639                               G_SIGNAL_RUN_LAST,
 640                               G_STRUCT_OFFSET (GtkCMCListClass, set_scroll_adjustments),
 641                               NULL, NULL,
 642                               claws_marshal_VOID__OBJECT_OBJECT,
 643                               G_TYPE_NONE, 2,
 644                               GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 645
 646   clist_signals[SELECT_ROW] =
 647                 g_signal_new ("select_row",
 648                               G_TYPE_FROM_CLASS (object_class),
 649                               G_SIGNAL_RUN_FIRST,
 650                               G_STRUCT_OFFSET (GtkCMCListClass, select_row),
 651                               NULL, NULL,
 652                               claws_marshal_VOID__INT_INT_BOXED,
 653                               G_TYPE_NONE, 3,
 654                               G_TYPE_INT,
 655                               G_TYPE_INT,
 656                               GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
 657   clist_signals[UNSELECT_ROW] =
 658                 g_signal_new ("unselect_row",
 659                               G_TYPE_FROM_CLASS (object_class),
 660                               G_SIGNAL_RUN_FIRST,
 661                               G_STRUCT_OFFSET (GtkCMCListClass, unselect_row),
 662                               NULL, NULL,
 663                               claws_marshal_VOID__INT_INT_BOXED,
 664                               G_TYPE_NONE, 3,
 665                               G_TYPE_INT,
 666                               G_TYPE_INT,
 667                               GDK_TYPE_EVENT);
 668   clist_signals[ROW_MOVE] =
 669                 g_signal_new ("row_move",
 670                               G_TYPE_FROM_CLASS (object_class),
 671                               G_SIGNAL_RUN_LAST,
 672                               G_STRUCT_OFFSET (GtkCMCListClass, row_move),
 673                               NULL, NULL,
 674                               claws_marshal_VOID__INT_INT,
 675                               G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
 676   clist_signals[CLICK_COLUMN] =
 677                 g_signal_new ("click_column",
 678                               G_TYPE_FROM_CLASS (object_class),
 679                               G_SIGNAL_RUN_FIRST,
 680                               G_STRUCT_OFFSET (GtkCMCListClass, click_column),
 681                               NULL, NULL,
 682                               claws_marshal_VOID__INT,
 683                               G_TYPE_NONE, 1, G_TYPE_INT);
 684   clist_signals[RESIZE_COLUMN] =
 685                 g_signal_new ("resize_column",
 686                               G_TYPE_FROM_CLASS (object_class),
 687                               G_SIGNAL_RUN_LAST,
 688                               G_STRUCT_OFFSET (GtkCMCListClass, resize_column),
 689                               NULL, NULL,
 690                               claws_marshal_VOID__INT_INT,
 691                               G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
 692
 693   clist_signals[TOGGLE_FOCUS_ROW] =
 694                 g_signal_new ("toggle_focus_row",
 695                               G_TYPE_FROM_CLASS (object_class),
 696                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 697                               G_STRUCT_OFFSET (GtkCMCListClass, toggle_focus_row),
 698                               NULL, NULL,
 699                               claws_marshal_VOID__VOID,
 700                               G_TYPE_NONE, 0);
 701   clist_signals[SELECT_ALL] =
 702                 g_signal_new ("select_all",
 703                               G_TYPE_FROM_CLASS (object_class),
 704                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 705                               G_STRUCT_OFFSET (GtkCMCListClass, select_all),
 706                               NULL, NULL,
 707                               claws_marshal_VOID__VOID,
 708                               G_TYPE_NONE, 0);
 709   clist_signals[UNSELECT_ALL] =
 710                 g_signal_new ("unselect_all",
 711                               G_TYPE_FROM_CLASS (object_class),
 712                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 713                               G_STRUCT_OFFSET (GtkCMCListClass, unselect_all),
 714                               NULL, NULL,
 715                               claws_marshal_VOID__VOID,
 716                               G_TYPE_NONE, 0);
 717   clist_signals[UNDO_SELECTION] =
 718                 g_signal_new ("undo_selection",
 719                               G_TYPE_FROM_CLASS (object_class),
 720                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 721                               G_STRUCT_OFFSET (GtkCMCListClass, undo_selection),
 722                               NULL, NULL,
 723                               claws_marshal_VOID__VOID,
 724                               G_TYPE_NONE, 0);
 725   clist_signals[START_SELECTION] =
 726                 g_signal_new ("start_selection",
 727                               G_TYPE_FROM_CLASS (object_class),
 728                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 729                               G_STRUCT_OFFSET (GtkCMCListClass, start_selection),
 730                               NULL, NULL,
 731                               claws_marshal_VOID__VOID,
 732                               G_TYPE_NONE, 0);
 733   clist_signals[END_SELECTION] =
 734                 g_signal_new ("end_selection",
 735                               G_TYPE_FROM_CLASS (object_class),
 736                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 737                               G_STRUCT_OFFSET (GtkCMCListClass, end_selection),
 738                               NULL, NULL,
 739                               claws_marshal_VOID__VOID,
 740                               G_TYPE_NONE, 0);
 741   clist_signals[TOGGLE_ADD_MODE] =
 742                 g_signal_new ("toggle_add_mode",
 743                               G_TYPE_FROM_CLASS (object_class),
 744                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 745                               G_STRUCT_OFFSET (GtkCMCListClass, toggle_add_mode),
 746                               NULL, NULL,
 747                               claws_marshal_VOID__VOID,
 748                               G_TYPE_NONE, 0);
 749   clist_signals[EXTEND_SELECTION] =
 750                 g_signal_new ("extend_selection",
 751                               G_TYPE_FROM_CLASS (object_class),
 752                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 753                               G_STRUCT_OFFSET (GtkCMCListClass, extend_selection),
 754                               NULL, NULL,
 755                               claws_marshal_VOID__ENUM_FLOAT_BOOLEAN,
 756                               G_TYPE_NONE, 3, GTK_TYPE_SCROLL_TYPE, G_TYPE_FLOAT, G_TYPE_BOOLEAN);
 757   clist_signals[SCROLL_VERTICAL] =
 758                 g_signal_new ("scroll_vertical",
 759                               G_TYPE_FROM_CLASS (object_class),
 760                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 761                               G_STRUCT_OFFSET (GtkCMCListClass, scroll_vertical),
 762                               NULL, NULL,
 763                               claws_marshal_VOID__ENUM_FLOAT,
 764                               G_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, G_TYPE_FLOAT);
 765   clist_signals[SCROLL_HORIZONTAL] =
 766                 g_signal_new ("scroll_horizontal",
 767                               G_TYPE_FROM_CLASS (object_class),
 768                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 769                               G_STRUCT_OFFSET (GtkCMCListClass, scroll_horizontal),
 770                               NULL, NULL,
 771                               claws_marshal_VOID__ENUM_FLOAT,
 772                               G_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, G_TYPE_FLOAT);
 773   clist_signals[ABORT_COLUMN_RESIZE] =
 774                 g_signal_new ("abort_column_resize",
 775                               G_TYPE_FROM_CLASS (object_class),
 776                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 777                               G_STRUCT_OFFSET (GtkCMCListClass, abort_column_resize),
 778                               NULL, NULL,
 779                               claws_marshal_VOID__VOID,
 780                               G_TYPE_NONE, 0);
 781
 782   binding_set = gtk_binding_set_by_class (klass);
 783   gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
 784                                 "scroll_vertical", 2,
 785                                 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
 786                                 G_TYPE_FLOAT, 0.0);
 787   gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,
 788                                 "scroll_vertical", 2,
 789                                 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
 790                                 G_TYPE_FLOAT, 0.0);
 791   gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,
 792                                 "scroll_vertical", 2,
 793                                 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
 794                                 G_TYPE_FLOAT, 0.0);
 795   gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, 0,
 796                                 "scroll_vertical", 2,
 797                                 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
 798                                 G_TYPE_FLOAT, 0.0);
 799   gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
 800                                 "scroll_vertical", 2,
 801                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
 802                                 G_TYPE_FLOAT, 0.0);
 803   gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, 0,
 804                                 "scroll_vertical", 2,
 805                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
 806                                 G_TYPE_FLOAT, 0.0);
 807   gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
 808                                 "scroll_vertical", 2,
 809                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
 810                                 G_TYPE_FLOAT, 0.0);
 811   gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, 0,
 812                                 "scroll_vertical", 2,
 813                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
 814                                 G_TYPE_FLOAT, 0.0);
 815   gtk_binding_entry_add_signal (binding_set, GDK_Home, GDK_CONTROL_MASK,
 816                                 "scroll_vertical", 2,
 817                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 818                                 G_TYPE_FLOAT, 0.0);
 819   gtk_binding_entry_add_signal (binding_set, GDK_KP_Home, GDK_CONTROL_MASK,
 820                                 "scroll_vertical", 2,
 821                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 822                                 G_TYPE_FLOAT, 0.0);
 823   gtk_binding_entry_add_signal (binding_set, GDK_End, GDK_CONTROL_MASK,
 824                                 "scroll_vertical", 2,
 825                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 826                                 G_TYPE_FLOAT, 1.0);
 827   gtk_binding_entry_add_signal (binding_set, GDK_KP_End, GDK_CONTROL_MASK,
 828                                 "scroll_vertical", 2,
 829                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 830                                 G_TYPE_FLOAT, 1.0);
 831
 832   gtk_binding_entry_add_signal (binding_set, GDK_Up, GDK_SHIFT_MASK,
 833                                 "extend_selection", 3,
 834                                 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
 835                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 836   gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, GDK_SHIFT_MASK,
 837                                 "extend_selection", 3,
 838                                 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
 839                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 840   gtk_binding_entry_add_signal (binding_set, GDK_Down, GDK_SHIFT_MASK,
 841                                 "extend_selection", 3,
 842                                 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
 843                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 844   gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, GDK_SHIFT_MASK,
 845                                 "extend_selection", 3,
 846                                 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
 847                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 848   gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, GDK_SHIFT_MASK,
 849                                 "extend_selection", 3,
 850                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
 851                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 852   gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, GDK_SHIFT_MASK,
 853                                 "extend_selection", 3,
 854                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
 855                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 856   gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, GDK_SHIFT_MASK,
 857                                 "extend_selection", 3,
 858                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
 859                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 860   gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, GDK_SHIFT_MASK,
 861                                 "extend_selection", 3,
 862                                 G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
 863                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 864   gtk_binding_entry_add_signal (binding_set, GDK_Home,
 865                                 GDK_SHIFT_MASK | GDK_CONTROL_MASK,
 866                                 "extend_selection", 3,
 867                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 868                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 869   gtk_binding_entry_add_signal (binding_set, GDK_KP_Home,
 870                                 GDK_SHIFT_MASK | GDK_CONTROL_MASK,
 871                                 "extend_selection", 3,
 872                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 873                                 G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
 874   gtk_binding_entry_add_signal (binding_set, GDK_End,
 875                                 GDK_SHIFT_MASK | GDK_CONTROL_MASK,
 876                                 "extend_selection", 3,
 877                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 878                                 G_TYPE_FLOAT, 1.0, G_TYPE_BOOLEAN, TRUE);
 879   gtk_binding_entry_add_signal (binding_set, GDK_KP_End,
 880                                 GDK_SHIFT_MASK | GDK_CONTROL_MASK,
 881                                 "extend_selection", 3,
 882                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 883                                 G_TYPE_FLOAT, 1.0, G_TYPE_BOOLEAN, TRUE);
 884
 885
 886   gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,
 887                                 "scroll_horizontal", 2,
 888                                 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
 889                                 G_TYPE_FLOAT, 0.0);
 890   gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0,
 891                                 "scroll_horizontal", 2,
 892                                 G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
 893                                 G_TYPE_FLOAT, 0.0);
 894
 895   gtk_binding_entry_add_signal (binding_set, GDK_Right, 0,
 896                                 "scroll_horizontal", 2,
 897                                 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
 898                                 G_TYPE_FLOAT, 0.0);
 899   gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0,
 900                                 "scroll_horizontal", 2,
 901                                 G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
 902                                 G_TYPE_FLOAT, 0.0);
 903
 904   gtk_binding_entry_add_signal (binding_set, GDK_Home, 0,
 905                                 "scroll_horizontal", 2,
 906                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 907                                 G_TYPE_FLOAT, 0.0);
 908   gtk_binding_entry_add_signal (binding_set, GDK_KP_Home, 0,
 909                                 "scroll_horizontal", 2,
 910                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 911                                 G_TYPE_FLOAT, 0.0);
 912
 913   gtk_binding_entry_add_signal (binding_set, GDK_End, 0,
 914                                 "scroll_horizontal", 2,
 915                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 916                                 G_TYPE_FLOAT, 1.0);
 917
 918   gtk_binding_entry_add_signal (binding_set, GDK_KP_End, 0,
 919                                 "scroll_horizontal", 2,
 920                                 G_TYPE_ENUM, GTK_SCROLL_JUMP,
 921                                 G_TYPE_FLOAT, 1.0);
 922
 923   gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
 924                                 "undo_selection", 0);
 925   gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
 926                                 "abort_column_resize", 0);
 927   gtk_binding_entry_add_signal (binding_set, GDK_space, 0,
 928                                 "toggle_focus_row", 0);
 929   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0,
 930                                 "toggle_focus_row", 0);
 931   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK,
 932                                 "toggle_add_mode", 0);
 933   gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_CONTROL_MASK,
 934                                 "toggle_add_mode", 0);
 935   gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK,
 936                                 "select_all", 0);
 937   gtk_binding_entry_add_signal (binding_set, GDK_KP_Divide, GDK_CONTROL_MASK,
 938                                 "select_all", 0);
 939   gtk_binding_entry_add_signal (binding_set, '\\', GDK_CONTROL_MASK,
 940                                 "unselect_all", 0);
 941   gtk_binding_entry_add_signal (binding_set, GDK_Shift_L,
 942                                 GDK_RELEASE_MASK | GDK_SHIFT_MASK,
 943                                 "end_selection", 0);
 944   gtk_binding_entry_add_signal (binding_set, GDK_Shift_R,
 945                                 GDK_RELEASE_MASK | GDK_SHIFT_MASK,
 946                                 "end_selection", 0);
 947   gtk_binding_entry_add_signal (binding_set, GDK_Shift_L,
 948                                 GDK_RELEASE_MASK | GDK_SHIFT_MASK |
 949                                 GDK_CONTROL_MASK,
 950                                 "end_selection", 0);
 951   gtk_binding_entry_add_signal (binding_set, GDK_Shift_R,
 952                                 GDK_RELEASE_MASK | GDK_SHIFT_MASK |
 953                                 GDK_CONTROL_MASK,
 954                                 "end_selection", 0);
 955 }
 956
 957 static void
 958 gtk_cmclist_set_arg (GObject *object,
 959                                 guint      arg_id,
 960                                 const GValue *value,
 961                                 GParamSpec *spec)
 962 {
 963   GtkCMCList *clist;
 964
 965   clist = GTK_CMCLIST (object);
 966
 967   switch (arg_id)
 968     {
 969     case ARG_N_COLUMNS: /* only set at construction time */
 970       clist->columns = MAX (1, g_value_get_uint (value));
 971       break;
 972     case ARG_SHADOW_TYPE:
 973       gtk_cmclist_set_shadow_type (clist, g_value_get_enum (value));
 974       break;
 975     case ARG_SELECTION_MODE:
 976       gtk_cmclist_set_selection_mode (clist, g_value_get_enum (value));
 977       break;
 978     case ARG_ROW_HEIGHT:
 979       gtk_cmclist_set_row_height (clist, g_value_get_uint (value));
 980       break;
 981     case ARG_REORDERABLE:
 982       gtk_cmclist_set_reorderable (clist, g_value_get_boolean (value));
 983       break;
 984     case ARG_TITLES_ACTIVE:
 985       if (g_value_get_boolean (value))
 986         gtk_cmclist_column_titles_active (clist);
 987       else
 988         gtk_cmclist_column_titles_passive (clist);
 989       break;
 990     case ARG_USE_DRAG_ICONS:
 991       gtk_cmclist_set_use_drag_icons (clist, g_value_get_boolean (value));
 992       break;
 993     case ARG_SORT_TYPE:
 994       gtk_cmclist_set_sort_type (clist, g_value_get_enum (value));
 995       break;
 996     }
 997 }
 998
 999 static void
1000 gtk_cmclist_get_arg (GObject *object,
1001                                 guint      arg_id,
1002                                 GValue *value,
1003                                 GParamSpec *spec)
1004 {
1005   GtkCMCList *clist;
1006
1007   clist = GTK_CMCLIST (object);
1008
1009   switch (arg_id)
1010     {
1011       guint i;
1012
1013     case ARG_N_COLUMNS:
1014       g_value_set_uint(value, clist->columns);
1015       break;
1016     case ARG_SHADOW_TYPE:
1017       g_value_set_enum(value, clist->shadow_type);
1018       break;
1019     case ARG_SELECTION_MODE:
1020       g_value_set_enum(value, clist->selection_mode);
1021       break;
1022     case ARG_ROW_HEIGHT:
1023       g_value_set_uint(value, GTK_CMCLIST_ROW_HEIGHT_SET(clist) ? clist->row_height : 0);
1024       break;
1025     case ARG_REORDERABLE:
1026       g_value_set_boolean(value, GTK_CMCLIST_REORDERABLE (clist));
1027       break;
1028     case ARG_TITLES_ACTIVE:
1029       g_value_set_boolean(value, TRUE);
1030       for (i = 0; i < clist->columns; i++)
1031         if (clist->column[i].button &&
1032             !GTK_WIDGET_SENSITIVE (clist->column[i].button))
1033           {
1034             g_value_set_boolean(value, FALSE);
1035             break;
1036           }
1037       break;
1038     case ARG_USE_DRAG_ICONS:
1039       g_value_set_boolean(value, GTK_CMCLIST_USE_DRAG_ICONS (clist));
1040       break;
1041     case ARG_SORT_TYPE:
1042       g_value_set_enum(value, clist->sort_type);
1043       break;
1044     default:
1045       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, arg_id, spec);
1046       break;
1047     }
1048 }
1049
1050 static void
1051 gtk_cmclist_init (GtkCMCList *clist)
1052 {
1053   clist->flags = 0;
1054
1055   GTK_WIDGET_UNSET_FLAGS (clist, GTK_NO_WINDOW);
1056   GTK_WIDGET_SET_FLAGS (clist, GTK_CAN_FOCUS);
1057   GTK_CMCLIST_SET_FLAG (clist, CMCLIST_DRAW_DRAG_LINE);
1058   GTK_CMCLIST_SET_FLAG (clist, CMCLIST_USE_DRAG_ICONS);
1059
1060
1061 #if !GLIB_CHECK_VERSION(2,10,0)
1062   clist->row_mem_chunk = NULL;
1063   clist->cell_mem_chunk = NULL;
1064 #endif
1065
1066   clist->freeze_count = 0;
1067
1068   clist->rows = 0;
1069   clist->row_height = 0;
1070   clist->row_list = NULL;
1071   clist->row_list_end = NULL;
1072
1073   clist->columns = 0;
1074
1075   clist->title_window = NULL;
1076   clist->column_title_area.x = 0;
1077   clist->column_title_area.y = 0;
1078   clist->column_title_area.width = 1;
1079   clist->column_title_area.height = 1;
1080
1081   clist->clist_window = NULL;
1082   clist->clist_window_width = 1;
1083   clist->clist_window_height = 1;
1084
1085   clist->hoffset = 0;
1086   clist->voffset = 0;
1087
1088   clist->shadow_type = GTK_SHADOW_IN;
1089   clist->vadjustment = NULL;
1090   clist->hadjustment = NULL;
1091
1092   clist->button_actions[0] = GTK_CMBUTTON_SELECTS | GTK_CMBUTTON_DRAGS;
1093   clist->button_actions[1] = GTK_CMBUTTON_IGNORED;
1094   clist->button_actions[2] = GTK_CMBUTTON_IGNORED;
1095   clist->button_actions[3] = GTK_CMBUTTON_IGNORED;
1096   clist->button_actions[4] = GTK_CMBUTTON_IGNORED;
1097
1098   clist->cursor_drag = NULL;
1099   clist->xor_gc = NULL;
1100   clist->fg_gc = NULL;
1101   clist->bg_gc = NULL;
1102   clist->x_drag = 0;
1103
1104   clist->selection_mode = GTK_SELECTION_SINGLE;
1105   clist->selection = NULL;
1106   clist->selection_end = NULL;
1107   clist->undo_selection = NULL;
1108   clist->undo_unselection = NULL;
1109
1110   clist->focus_row = -1;
1111   clist->focus_header_column = -1;
1112   clist->undo_anchor = -1;
1113
1114   clist->anchor = -1;
1115   clist->anchor_state = GTK_STATE_SELECTED;
1116   clist->drag_pos = -1;
1117   clist->htimer = 0;
1118   clist->vtimer = 0;
1119
1120   clist->click_cell.row = -1;
1121   clist->click_cell.column = -1;
1122
1123   clist->compare = default_compare;
1124   clist->sort_type = GTK_SORT_ASCENDING;
1125   clist->sort_column = 0;
1126
1127   clist->drag_highlight_row = -1;
1128 }
1129
1130 /* Constructor */
1131 static GObject*
1132 gtk_cmclist_constructor (GType                  type,
1133                        guint                  n_construct_properties,
1134                        GObjectConstructParam *construct_properties)
1135 {
1136   GObject *object = G_OBJECT_CLASS (parent_class)->constructor (type,
1137                                                                 n_construct_properties,
1138                                                                 construct_properties);
1139   GtkCMCList *clist = GTK_CMCLIST (object);
1140
1141 #if !GLIB_CHECK_VERSION(2,10,0)
1142   if (!clist->row_mem_chunk)
1143     clist->row_mem_chunk = g_mem_chunk_new ("clist row mem chunk",
1144                                             sizeof (GtkCMCListRow),
1145                                             sizeof (GtkCMCListRow) *
1146                                             CMCLIST_OPTIMUM_SIZE,
1147                                             G_ALLOC_AND_FREE);
1148
1149   if (!clist->cell_mem_chunk)
1150     clist->cell_mem_chunk = g_mem_chunk_new ("clist cell mem chunk",
1151                                              sizeof (GtkCMCell) * clist->columns,
1152                                              sizeof (GtkCMCell) * clist->columns *
1153                                              CMCLIST_OPTIMUM_SIZE,
1154                                              G_ALLOC_AND_FREE);
1155 #endif
1156
1157   /* allocate memory for columns */
1158   clist->column = columns_new (clist);
1159
1160   /* there needs to be at least one column button
1161    * because there is alot of code that will break if it
1162    * isn't there
1163    */
1164   column_button_create (clist, 0);
1165
1166   return object;
1167 }
1168
1169 /* GTKCLIST PUBLIC INTERFACE
1170  *   gtk_cmclist_new
1171  *   gtk_cmclist_new_with_titles
1172  *   gtk_cmclist_set_hadjustment
1173  *   gtk_cmclist_set_vadjustment
1174  *   gtk_cmclist_get_hadjustment
1175  *   gtk_cmclist_get_vadjustment
1176  *   gtk_cmclist_set_shadow_type
1177  *   gtk_cmclist_set_selection_mode
1178  *   gtk_cmclist_freeze
1179  *   gtk_cmclist_thaw
1180  */
1181 GtkWidget*
1182 gtk_cmclist_new (gint columns)
1183 {
1184   return gtk_cmclist_new_with_titles (columns, NULL);
1185 }
1186
1187 GtkWidget*
1188 gtk_cmclist_new_with_titles (gint   columns,
1189                            gchar *titles[])
1190 {
1191   GtkCMCList *clist;
1192
1193   clist = g_object_new (GTK_TYPE_CMCLIST,
1194                         "n_columns", columns,
1195                         NULL);
1196   if (titles)
1197     {
1198       guint i;
1199
1200       for (i = 0; i < clist->columns; i++)
1201         gtk_cmclist_set_column_title (clist, i, titles[i]);
1202       gtk_cmclist_column_titles_show (clist);
1203     }
1204   else
1205     gtk_cmclist_column_titles_hide (clist);
1206
1207   return GTK_WIDGET (clist);
1208 }
1209
1210 void
1211 gtk_cmclist_set_hadjustment (GtkCMCList      *clist,
1212                            GtkAdjustment *adjustment)
1213 {
1214   GtkAdjustment *old_adjustment;
1215
1216   g_return_if_fail (GTK_IS_CMCLIST (clist));
1217   if (adjustment)
1218     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
1219
1220   if (clist->hadjustment == adjustment)
1221     return;
1222
1223   old_adjustment = clist->hadjustment;
1224
1225   if (clist->hadjustment)
1226     {
1227       g_signal_handlers_disconnect_matched(G_OBJECT (clist->hadjustment), G_SIGNAL_MATCH_DATA,
1228                         0, 0, 0, 0, clist);
1229
1230       g_object_unref (G_OBJECT (clist->hadjustment));
1231     }
1232
1233   clist->hadjustment = adjustment;
1234
1235   if (clist->hadjustment)
1236     {
1237 #if GLIB_CHECK_VERSION(2,10,0)
1238       g_object_ref_sink (clist->hadjustment);
1239 #else
1240       gtk_object_ref (G_OBJECT (clist->hadjustment));
1241       gtk_object_sink (G_OBJECT (clist->hadjustment));
1242 #endif
1243       g_signal_connect (G_OBJECT (clist->hadjustment), "changed",
1244                           G_CALLBACK( hadjustment_changed),
1245                           (gpointer) clist);
1246       g_signal_connect (G_OBJECT (clist->hadjustment), "value_changed",
1247                           G_CALLBACK( hadjustment_value_changed),
1248                           (gpointer) clist);
1249     }
1250
1251   if (!clist->hadjustment || !old_adjustment)
1252     gtk_widget_queue_resize (GTK_WIDGET (clist));
1253 }
1254
1255 GtkAdjustment *
1256 gtk_cmclist_get_hadjustment (GtkCMCList *clist)
1257 {
1258   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
1259
1260   return clist->hadjustment;
1261 }
1262
1263 void
1264 gtk_cmclist_set_vadjustment (GtkCMCList      *clist,
1265                            GtkAdjustment *adjustment)
1266 {
1267   GtkAdjustment *old_adjustment;
1268
1269   g_return_if_fail (GTK_IS_CMCLIST (clist));
1270   if (adjustment)
1271     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
1272
1273   if (clist->vadjustment == adjustment)
1274     return;
1275
1276   old_adjustment = clist->vadjustment;
1277
1278   if (clist->vadjustment)
1279     {
1280       g_signal_handlers_disconnect_matched(G_OBJECT (clist->vadjustment), G_SIGNAL_MATCH_DATA,
1281                         0, 0, 0, 0, clist);
1282       g_object_unref (G_OBJECT (clist->vadjustment));
1283     }
1284
1285   clist->vadjustment = adjustment;
1286
1287   if (clist->vadjustment)
1288     {
1289 #if GLIB_CHECK_VERSION(2,10,0)
1290       g_object_ref_sink (clist->vadjustment);
1291 #else
1292       gtk_object_ref (G_OBJECT (clist->vadjustment));
1293       gtk_object_sink (G_OBJECT (clist->vadjustment));
1294 #endif
1295
1296       g_signal_connect (G_OBJECT (clist->vadjustment), "changed",
1297                           G_CALLBACK(vadjustment_changed),
1298                           (gpointer) clist);
1299       g_signal_connect (G_OBJECT (clist->vadjustment), "value_changed",
1300                           G_CALLBACK(vadjustment_value_changed),
1301                           (gpointer) clist);
1302     }
1303
1304   if (!clist->vadjustment || !old_adjustment)
1305     gtk_widget_queue_resize (GTK_WIDGET (clist));
1306 }
1307
1308 GtkAdjustment *
1309 gtk_cmclist_get_vadjustment (GtkCMCList *clist)
1310 {
1311   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
1312
1313   return clist->vadjustment;
1314 }
1315
1316 static void
1317 gtk_cmclist_set_scroll_adjustments (GtkCMCList      *clist,
1318                                   GtkAdjustment *hadjustment,
1319                                   GtkAdjustment *vadjustment)
1320 {
1321   if (clist->hadjustment != hadjustment)
1322     gtk_cmclist_set_hadjustment (clist, hadjustment);
1323   if (clist->vadjustment != vadjustment)
1324     gtk_cmclist_set_vadjustment (clist, vadjustment);
1325 }
1326
1327 void
1328 gtk_cmclist_set_shadow_type (GtkCMCList      *clist,
1329                            GtkShadowType  type)
1330 {
1331   g_return_if_fail (GTK_IS_CMCLIST (clist));
1332
1333   clist->shadow_type = type;
1334
1335   if (GTK_WIDGET_VISIBLE (clist))
1336     gtk_widget_queue_resize (GTK_WIDGET (clist));
1337 }
1338
1339 void
1340 gtk_cmclist_set_selection_mode (GtkCMCList         *clist,
1341                               GtkSelectionMode  mode)
1342 {
1343   g_return_if_fail (GTK_IS_CMCLIST (clist));
1344   g_return_if_fail (mode != GTK_SELECTION_NONE);
1345
1346   if (mode == clist->selection_mode)
1347     return;
1348
1349   clist->selection_mode = mode;
1350   clist->anchor = -1;
1351   clist->anchor_state = GTK_STATE_SELECTED;
1352   clist->drag_pos = -1;
1353   clist->undo_anchor = clist->focus_row;
1354
1355   g_list_free (clist->undo_selection);
1356   g_list_free (clist->undo_unselection);
1357   clist->undo_selection = NULL;
1358   clist->undo_unselection = NULL;
1359
1360   switch (mode)
1361     {
1362     case GTK_SELECTION_MULTIPLE:
1363       return;
1364     case GTK_SELECTION_BROWSE:
1365     case GTK_SELECTION_SINGLE:
1366       gtk_cmclist_unselect_all (clist);
1367       break;
1368     default:
1369       /* Someone set it by hand */
1370       g_assert_not_reached ();
1371     }
1372 }
1373
1374 void
1375 gtk_cmclist_freeze (GtkCMCList *clist)
1376 {
1377   g_return_if_fail (GTK_IS_CMCLIST (clist));
1378
1379   clist->freeze_count++;
1380 }
1381
1382 void
1383 gtk_cmclist_thaw (GtkCMCList *clist)
1384 {
1385   g_return_if_fail (GTK_IS_CMCLIST (clist));
1386
1387   if (clist->freeze_count)
1388     {
1389       clist->freeze_count--;
1390       CLIST_REFRESH (clist);
1391     }
1392 }
1393
1394 /* PUBLIC COLUMN FUNCTIONS
1395  *   gtk_cmclist_column_titles_show
1396  *   gtk_cmclist_column_titles_hide
1397  *   gtk_cmclist_column_title_active
1398  *   gtk_cmclist_column_title_passive
1399  *   gtk_cmclist_column_titles_active
1400  *   gtk_cmclist_column_titles_passive
1401  *   gtk_cmclist_set_column_title
1402  *   gtk_cmclist_get_column_title
1403  *   gtk_cmclist_set_column_widget
1404  *   gtk_cmclist_set_column_justification
1405  *   gtk_cmclist_set_column_visibility
1406  *   gtk_cmclist_set_column_resizeable
1407  *   gtk_cmclist_set_column_auto_resize
1408  *   gtk_cmclist_optimal_column_width
1409  *   gtk_cmclist_set_column_width
1410  *   gtk_cmclist_set_column_min_width
1411  *   gtk_cmclist_set_column_max_width
1412  */
1413 void
1414 gtk_cmclist_column_titles_show (GtkCMCList *clist)
1415 {
1416   g_return_if_fail (GTK_IS_CMCLIST (clist));
1417
1418   if (!GTK_CMCLIST_SHOW_TITLES(clist))
1419     {
1420       GTK_CMCLIST_SET_FLAG (clist, CMCLIST_SHOW_TITLES);
1421       if (clist->title_window)
1422         gdk_window_show (clist->title_window);
1423       gtk_widget_queue_resize (GTK_WIDGET (clist));
1424     }
1425 }
1426
1427 void
1428 gtk_cmclist_column_titles_hide (GtkCMCList *clist)
1429 {
1430   g_return_if_fail (GTK_IS_CMCLIST (clist));
1431
1432   if (GTK_CMCLIST_SHOW_TITLES(clist))
1433     {
1434       GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_SHOW_TITLES);
1435       if (clist->title_window)
1436         gdk_window_hide (clist->title_window);
1437       gtk_widget_queue_resize (GTK_WIDGET (clist));
1438     }
1439 }
1440
1441 void
1442 gtk_cmclist_column_title_active (GtkCMCList *clist,
1443                                gint      column)
1444 {
1445   g_return_if_fail (GTK_IS_CMCLIST (clist));
1446
1447   if (column < 0 || column >= clist->columns)
1448     return;
1449   if (!clist->column[column].button || !clist->column[column].button_passive)
1450     return;
1451
1452   clist->column[column].button_passive = FALSE;
1453
1454   g_signal_handlers_disconnect_matched(G_OBJECT (clist->column[column].button), G_SIGNAL_MATCH_FUNC,
1455                     0, 0, 0, column_title_passive_func, 0);
1456
1457   GTK_WIDGET_SET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
1458   if (GTK_WIDGET_VISIBLE (clist))
1459     gtk_widget_queue_draw (clist->column[column].button);
1460 }
1461
1462 void
1463 gtk_cmclist_column_title_passive (GtkCMCList *clist,
1464                                 gint      column)
1465 {
1466   GtkButton *button;
1467
1468   g_return_if_fail (GTK_IS_CMCLIST (clist));
1469
1470   if (column < 0 || column >= clist->columns)
1471     return;
1472   if (!clist->column[column].button || clist->column[column].button_passive)
1473     return;
1474
1475   button = GTK_BUTTON (clist->column[column].button);
1476
1477   clist->column[column].button_passive = TRUE;
1478
1479   if (button->button_down)
1480     gtk_button_released (button);
1481   if (button->in_button)
1482     gtk_button_leave (button);
1483
1484   g_signal_connect (G_OBJECT (clist->column[column].button), "event",
1485                       G_CALLBACK(column_title_passive_func), NULL);
1486
1487   GTK_WIDGET_UNSET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
1488   if (GTK_WIDGET_VISIBLE (clist))
1489     gtk_widget_queue_draw (clist->column[column].button);
1490 }
1491
1492 void
1493 gtk_cmclist_column_titles_active (GtkCMCList *clist)
1494 {
1495   gint i;
1496
1497   g_return_if_fail (GTK_IS_CMCLIST (clist));
1498
1499   for (i = 0; i < clist->columns; i++)
1500     gtk_cmclist_column_title_active (clist, i);
1501 }
1502
1503 void
1504 gtk_cmclist_column_titles_passive (GtkCMCList *clist)
1505 {
1506   gint i;
1507
1508   g_return_if_fail (GTK_IS_CMCLIST (clist));
1509
1510   for (i = 0; i < clist->columns; i++)
1511     gtk_cmclist_column_title_passive (clist, i);
1512 }
1513
1514 void
1515 gtk_cmclist_set_column_title (GtkCMCList    *clist,
1516                             gint         column,
1517                             const gchar *title)
1518 {
1519   gint new_button = 0;
1520   GtkWidget *old_widget;
1521   GtkWidget *alignment = NULL;
1522   GtkWidget *label;
1523
1524   g_return_if_fail (GTK_IS_CMCLIST (clist));
1525
1526   if (column < 0 || column >= clist->columns)
1527     return;
1528
1529   /* if the column button doesn't currently exist,
1530    * it has to be created first */
1531   if (!clist->column[column].button)
1532     {
1533       column_button_create (clist, column);
1534       new_button = 1;
1535     }
1536
1537   column_title_new (clist, column, title);
1538
1539   /* remove and destroy the old widget */
1540   old_widget = GTK_BIN (clist->column[column].button)->child;
1541   if (old_widget)
1542     gtk_container_remove (GTK_CONTAINER (clist->column[column].button), old_widget);
1543
1544   /* create new alignment based no column justification */
1545   switch (clist->column[column].justification)
1546     {
1547     case GTK_JUSTIFY_LEFT:
1548       alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
1549       break;
1550
1551     case GTK_JUSTIFY_RIGHT:
1552       alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);
1553       break;
1554
1555     case GTK_JUSTIFY_CENTER:
1556       alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
1557       break;
1558
1559     case GTK_JUSTIFY_FILL:
1560       alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
1561       break;
1562     }
1563
1564   gtk_widget_push_composite_child ();
1565   label = gtk_label_new (clist->column[column].title);
1566   gtk_widget_pop_composite_child ();
1567   gtk_container_add (GTK_CONTAINER (alignment), label);
1568   gtk_container_add (GTK_CONTAINER (clist->column[column].button), alignment);
1569   gtk_widget_show (label);
1570   gtk_widget_show (alignment);
1571
1572   /* if this button didn't previously exist, then the
1573    * column button positions have to be re-computed */
1574   if (GTK_WIDGET_VISIBLE (clist) && new_button)
1575     size_allocate_title_buttons (clist);
1576 }
1577
1578 gchar *
1579 gtk_cmclist_get_column_title (GtkCMCList *clist,
1580                             gint      column)
1581 {
1582   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
1583
1584   if (column < 0 || column >= clist->columns)
1585     return NULL;
1586
1587   return clist->column[column].title;
1588 }
1589
1590 void
1591 gtk_cmclist_set_column_widget (GtkCMCList  *clist,
1592                              gint       column,
1593                              GtkWidget *widget)
1594 {
1595   gint new_button = 0;
1596   GtkWidget *old_widget;
1597
1598   g_return_if_fail (GTK_IS_CMCLIST (clist));
1599
1600   if (column < 0 || column >= clist->columns)
1601     return;
1602
1603   /* if the column button doesn't currently exist,
1604    * it has to be created first */
1605   if (!clist->column[column].button)
1606     {
1607       column_button_create (clist, column);
1608       new_button = 1;
1609     }
1610
1611   column_title_new (clist, column, NULL);
1612
1613   /* remove and destroy the old widget */
1614   old_widget = GTK_BIN (clist->column[column].button)->child;
1615   if (old_widget)
1616     gtk_container_remove (GTK_CONTAINER (clist->column[column].button),
1617                           old_widget);
1618
1619   /* add and show the widget */
1620   if (widget)
1621     {
1622       gtk_container_add (GTK_CONTAINER (clist->column[column].button), widget);
1623       gtk_widget_show (widget);
1624     }
1625
1626   /* if this button didn't previously exist, then the
1627    * column button positions have to be re-computed */
1628   if (GTK_WIDGET_VISIBLE (clist) && new_button)
1629     size_allocate_title_buttons (clist);
1630 }
1631
1632 GtkWidget *
1633 gtk_cmclist_get_column_widget (GtkCMCList *clist,
1634                              gint      column)
1635 {
1636   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
1637
1638   if (column < 0 || column >= clist->columns)
1639     return NULL;
1640
1641   if (clist->column[column].button)
1642     return GTK_BIN (clist->column[column].button)->child;
1643
1644   return NULL;
1645 }
1646
1647 void
1648 gtk_cmclist_set_column_justification (GtkCMCList         *clist,
1649                                     gint              column,
1650                                     GtkJustification  justification)
1651 {
1652   GtkWidget *alignment;
1653
1654   g_return_if_fail (GTK_IS_CMCLIST (clist));
1655
1656   if (column < 0 || column >= clist->columns)
1657     return;
1658
1659   clist->column[column].justification = justification;
1660
1661   /* change the alinment of the button title if it's not a
1662    * custom widget */
1663   if (clist->column[column].title)
1664     {
1665       alignment = GTK_BIN (clist->column[column].button)->child;
1666
1667       switch (clist->column[column].justification)
1668         {
1669         case GTK_JUSTIFY_LEFT:
1670           gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.0, 0.5, 0.0, 0.0);
1671           break;
1672
1673         case GTK_JUSTIFY_RIGHT:
1674           gtk_alignment_set (GTK_ALIGNMENT (alignment), 1.0, 0.5, 0.0, 0.0);
1675           break;
1676
1677         case GTK_JUSTIFY_CENTER:
1678           gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.5, 0.5, 0.0, 0.0);
1679           break;
1680
1681         case GTK_JUSTIFY_FILL:
1682           gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.5, 0.5, 0.0, 0.0);
1683           break;
1684
1685         default:
1686           break;
1687         }
1688     }
1689
1690   if (CLIST_UNFROZEN (clist))
1691     draw_rows (clist, NULL);
1692 }
1693
1694 void
1695 gtk_cmclist_set_column_visibility (GtkCMCList *clist,
1696                                  gint      column,
1697                                  gboolean  visible)
1698 {
1699   g_return_if_fail (GTK_IS_CMCLIST (clist));
1700
1701   if (column < 0 || column >= clist->columns)
1702     return;
1703   if (clist->column[column].visible == visible)
1704     return;
1705
1706   /* don't hide last visible column */
1707   if (!visible)
1708     {
1709       gint i;
1710       gint vis_columns = 0;
1711
1712       for (i = 0, vis_columns = 0; i < clist->columns && vis_columns < 2; i++)
1713         if (clist->column[i].visible)
1714           vis_columns++;
1715
1716       if (vis_columns < 2)
1717         return;
1718     }
1719
1720   clist->column[column].visible = visible;
1721
1722   if (clist->column[column].button)
1723     {
1724       if (visible)
1725         gtk_widget_show (clist->column[column].button);
1726       else
1727         gtk_widget_hide (clist->column[column].button);
1728     }
1729
1730   gtk_widget_queue_resize (GTK_WIDGET(clist));
1731 }
1732
1733 void
1734 gtk_cmclist_set_column_resizeable (GtkCMCList *clist,
1735                                  gint      column,
1736                                  gboolean  resizeable)
1737 {
1738   g_return_if_fail (GTK_IS_CMCLIST (clist));
1739
1740   if (column < 0 || column >= clist->columns)
1741     return;
1742   if (clist->column[column].resizeable == resizeable)
1743     return;
1744
1745   clist->column[column].resizeable = resizeable;
1746   if (resizeable)
1747     clist->column[column].auto_resize = FALSE;
1748
1749   if (GTK_WIDGET_VISIBLE (clist))
1750     size_allocate_title_buttons (clist);
1751 }
1752
1753 void
1754 gtk_cmclist_set_column_auto_resize (GtkCMCList *clist,
1755                                   gint      column,
1756                                   gboolean  auto_resize)
1757 {
1758   g_return_if_fail (GTK_IS_CMCLIST (clist));
1759
1760   if (column < 0 || column >= clist->columns)
1761     return;
1762   if (clist->column[column].auto_resize == auto_resize)
1763     return;
1764
1765   clist->column[column].auto_resize = auto_resize;
1766   if (auto_resize)
1767     {
1768       clist->column[column].resizeable = FALSE;
1769       if (!GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1770         {
1771           gint width;
1772
1773           width = gtk_cmclist_optimal_column_width (clist, column);
1774           gtk_cmclist_set_column_width (clist, column, width);
1775         }
1776     }
1777
1778   if (GTK_WIDGET_VISIBLE (clist))
1779     size_allocate_title_buttons (clist);
1780 }
1781
1782 gint
1783 gtk_cmclist_columns_autosize (GtkCMCList *clist)
1784 {
1785   gint i;
1786   gint width;
1787
1788   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
1789
1790   gtk_cmclist_freeze (clist);
1791   width = 0;
1792   for (i = 0; i < clist->columns; i++)
1793     {
1794       gtk_cmclist_set_column_width (clist, i,
1795                                   gtk_cmclist_optimal_column_width (clist, i));
1796
1797       width += clist->column[i].width;
1798     }
1799
1800   gtk_cmclist_thaw (clist);
1801   return width;
1802 }
1803
1804 gint
1805 gtk_cmclist_optimal_column_width (GtkCMCList *clist,
1806                                 gint      column)
1807 {
1808   GtkRequisition requisition;
1809   GList *list;
1810   gint width;
1811
1812   g_return_val_if_fail (GTK_CMCLIST (clist), 0);
1813
1814   if (column < 0 || column >= clist->columns)
1815     return 0;
1816
1817   if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[column].button)
1818     width = (clist->column[column].button->requisition.width)
1819 #if 0
1820              (CELL_SPACING + (2 * COLUMN_INSET)))
1821 #endif
1822                 ;
1823   else
1824     width = 0;
1825
1826   for (list = clist->row_list; list; list = list->next)
1827     {
1828   GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
1829         (clist, GTK_CMCLIST_ROW (list), column, &requisition);
1830       width = MAX (width, requisition.width);
1831     }
1832
1833   return width;
1834 }
1835
1836 void
1837 gtk_cmclist_set_column_width (GtkCMCList *clist,
1838                             gint      column,
1839                             gint      width)
1840 {
1841   g_return_if_fail (GTK_IS_CMCLIST (clist));
1842
1843   if (column < 0 || column >= clist->columns)
1844     return;
1845
1846   g_signal_emit (G_OBJECT (clist), clist_signals[RESIZE_COLUMN], 0,
1847                    column, width);
1848 }
1849
1850 void
1851 gtk_cmclist_set_column_min_width (GtkCMCList *clist,
1852                                 gint      column,
1853                                 gint      min_width)
1854 {
1855   g_return_if_fail (GTK_IS_CMCLIST (clist));
1856
1857   if (column < 0 || column >= clist->columns)
1858     return;
1859   if (clist->column[column].min_width == min_width)
1860     return;
1861
1862   if (clist->column[column].max_width >= 0  &&
1863       clist->column[column].max_width < min_width)
1864     clist->column[column].min_width = clist->column[column].max_width;
1865   else
1866     clist->column[column].min_width = min_width;
1867
1868   if (clist->column[column].area.width < clist->column[column].min_width)
1869     gtk_cmclist_set_column_width (clist, column,clist->column[column].min_width);
1870 }
1871
1872 void
1873 gtk_cmclist_set_column_max_width (GtkCMCList *clist,
1874                                 gint      column,
1875                                 gint      max_width)
1876 {
1877   g_return_if_fail (GTK_IS_CMCLIST (clist));
1878
1879   if (column < 0 || column >= clist->columns)
1880     return;
1881   if (clist->column[column].max_width == max_width)
1882     return;
1883
1884   if (clist->column[column].min_width >= 0 && max_width >= 0 &&
1885       clist->column[column].min_width > max_width)
1886     clist->column[column].max_width = clist->column[column].min_width;
1887   else
1888     clist->column[column].max_width = max_width;
1889
1890   if (clist->column[column].area.width > clist->column[column].max_width)
1891     gtk_cmclist_set_column_width (clist, column,clist->column[column].max_width);
1892 }
1893
1894 /* PRIVATE COLUMN FUNCTIONS
1895  *   column_auto_resize
1896  *   real_resize_column
1897  *   abort_column_resize
1898  *   size_allocate_title_buttons
1899  *   size_allocate_columns
1900  *   list_requisition_width
1901  *   new_column_width
1902  *   column_button_create
1903  *   column_button_clicked
1904  *   column_title_passive_func
1905  */
1906 static void
1907 column_auto_resize (GtkCMCList    *clist,
1908                     GtkCMCListRow *clist_row,
1909                     gint         column,
1910                     gint         old_width)
1911 {
1912   /* resize column if needed for auto_resize */
1913   GtkRequisition requisition;
1914
1915   if (!clist->column[column].auto_resize ||
1916       GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
1917     return;
1918
1919   if (clist_row)
1920     GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
1921                                                    column, &requisition);
1922   else
1923     requisition.width = 0;
1924
1925   if (requisition.width > clist->column[column].width)
1926     gtk_cmclist_set_column_width (clist, column, requisition.width);
1927   else if (requisition.width < old_width &&
1928            old_width == clist->column[column].width)
1929     {
1930       GList *list;
1931       gint new_width = 0;
1932
1933       /* run a "gtk_cmclist_optimal_column_width" but break, if
1934        * the column doesn't shrink */
1935       if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[column].button)
1936         new_width = (clist->column[column].button->requisition.width -
1937                      (CELL_SPACING + (2 * COLUMN_INSET)));
1938       else
1939         new_width = 0;
1940
1941       for (list = clist->row_list; list; list = list->next)
1942         {
1943           GTK_CMCLIST_GET_CLASS (clist)->cell_size_request
1944             (clist, GTK_CMCLIST_ROW (list), column, &requisition);
1945           new_width = MAX (new_width, requisition.width);
1946           if (new_width == clist->column[column].width)
1947             break;
1948         }
1949       if (new_width < clist->column[column].width)
1950         gtk_cmclist_set_column_width
1951           (clist, column, MAX (new_width, clist->column[column].min_width));
1952     }
1953 }
1954
1955 static void
1956 real_resize_column (GtkCMCList *clist,
1957                     gint      column,
1958                     gint      width)
1959 {
1960   g_return_if_fail (GTK_IS_CMCLIST (clist));
1961
1962   if (column < 0 || column >= clist->columns)
1963     return;
1964
1965   if (width < MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width))
1966     width = MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width);
1967   if (clist->column[column].max_width >= 0 &&
1968       width > clist->column[column].max_width)
1969     width = clist->column[column].max_width;
1970
1971   clist->column[column].width = width;
1972   clist->column[column].width_set = TRUE;
1973
1974   /* FIXME: this is quite expensive to do if the widget hasn't
1975    *        been size_allocated yet, and pointless. Should
1976    *        a flag be kept
1977    */
1978   size_allocate_columns (clist, TRUE);
1979   size_allocate_title_buttons (clist);
1980
1981   CLIST_REFRESH (clist);
1982 }
1983
1984 static void
1985 abort_column_resize (GtkCMCList *clist)
1986 {
1987   g_return_if_fail (GTK_IS_CMCLIST (clist));
1988
1989   if (!GTK_CMCLIST_IN_DRAG(clist))
1990     return;
1991
1992   GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_IN_DRAG);
1993   gtk_grab_remove (GTK_WIDGET (clist));
1994   gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (clist)),
1995                               GDK_CURRENT_TIME);
1996   clist->drag_pos = -1;
1997
1998   if (clist->x_drag >= 0 && clist->x_drag <= clist->clist_window_width - 1)
1999     draw_xor_line (clist);
2000
2001   if (GTK_CMCLIST_ADD_MODE(clist))
2002     {
2003       gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_ON_OFF_DASH, 0,0);
2004       gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
2005     }
2006 }
2007
2008 static void
2009 size_allocate_title_buttons (GtkCMCList *clist)
2010 {
2011   GtkAllocation button_allocation;
2012   gint last_column;
2013   gint last_button = 0;
2014   gint i;
2015
2016   if (!GTK_WIDGET_REALIZED (clist))
2017     return;
2018
2019   button_allocation.x = clist->hoffset;
2020   button_allocation.y = 0;
2021   button_allocation.width = 0;
2022   button_allocation.height = clist->column_title_area.height;
2023
2024   /* find last visible column */
2025   for (last_column = clist->columns - 1; last_column >= 0; last_column--)
2026     if (clist->column[last_column].visible)
2027       break;
2028
2029   for (i = 0; i < last_column; i++)
2030     {
2031       if (!clist->column[i].visible)
2032         {
2033           last_button = i + 1;
2034           gdk_window_hide (clist->column[i].window);
2035           continue;
2036         }
2037
2038       button_allocation.width += (clist->column[i].area.width +
2039                                   CELL_SPACING + 2 * COLUMN_INSET);
2040
2041       if (!clist->column[i + 1].button)
2042         {
2043           gdk_window_hide (clist->column[i].window);
2044           continue;
2045         }
2046
2047       gtk_widget_size_allocate (clist->column[last_button].button,
2048                                 &button_allocation);
2049       button_allocation.x += button_allocation.width;
2050       button_allocation.width = 0;
2051
2052       if (clist->column[last_button].resizeable)
2053         {
2054           gdk_window_show (clist->column[last_button].window);
2055           gdk_window_move_resize (clist->column[last_button].window,
2056                                   button_allocation.x - (DRAG_WIDTH / 2),
2057                                   0, DRAG_WIDTH,
2058                                   clist->column_title_area.height);
2059         }
2060       else
2061         gdk_window_hide (clist->column[last_button].window);
2062
2063       last_button = i + 1;
2064     }
2065
2066   button_allocation.width += (clist->column[last_column].area.width +
2067                               2 * (CELL_SPACING + COLUMN_INSET));
2068   gtk_widget_size_allocate (clist->column[last_button].button,
2069                             &button_allocation);
2070
2071   if (clist->column[last_button].resizeable)
2072     {
2073       button_allocation.x += button_allocation.width;
2074
2075       gdk_window_show (clist->column[last_button].window);
2076       gdk_window_move_resize (clist->column[last_button].window,
2077                               button_allocation.x - (DRAG_WIDTH / 2),
2078                               0, DRAG_WIDTH, clist->column_title_area.height);
2079     }
2080   else
2081     gdk_window_hide (clist->column[last_button].window);
2082 }
2083
2084 static void
2085 size_allocate_columns (GtkCMCList *clist,
2086                        gboolean  block_resize)
2087 {
2088   gint xoffset = CELL_SPACING + COLUMN_INSET;
2089   gint last_column;
2090   gint i;
2091
2092   /* find last visible column and calculate correct column width */
2093   for (last_column = clist->columns - 1;
2094        last_column >= 0 && !clist->column[last_column].visible; last_column--);
2095
2096   if (last_column < 0)
2097     return;
2098
2099   for (i = 0; i <= last_column; i++)
2100     {
2101       if (!clist->column[i].visible)
2102         continue;
2103       clist->column[i].area.x = xoffset;
2104       if (clist->column[i].width_set)
2105         {
2106           if (!block_resize && GTK_CMCLIST_SHOW_TITLES(clist) &&
2107               clist->column[i].auto_resize && clist->column[i].button)
2108             {
2109               gint width;
2110
2111               width = (clist->column[i].button->requisition.width -
2112                        (CELL_SPACING + (2 * COLUMN_INSET)));
2113
2114               if (width > clist->column[i].width)
2115                 gtk_cmclist_set_column_width (clist, i, width);
2116             }
2117
2118           clist->column[i].area.width = clist->column[i].width;
2119           xoffset += clist->column[i].width + CELL_SPACING + (2* COLUMN_INSET);
2120         }
2121       else if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[i].button)
2122         {
2123           clist->column[i].area.width =
2124             clist->column[i].button->requisition.width -
2125             (CELL_SPACING + (2 * COLUMN_INSET));
2126           xoffset += clist->column[i].button->requisition.width;
2127         }
2128     }
2129
2130   clist->column[last_column].area.width = clist->column[last_column].area.width
2131     + MAX (0, clist->clist_window_width + COLUMN_INSET - xoffset);
2132 }
2133
2134 static gint
2135 list_requisition_width (GtkCMCList *clist)
2136 {
2137   gint width = CELL_SPACING;
2138   gint i;
2139
2140   for (i = clist->columns - 1; i >= 0; i--)
2141     {
2142       if (!clist->column[i].visible)
2143         continue;
2144
2145       if (clist->column[i].width_set)
2146         width += clist->column[i].width + CELL_SPACING + (2 * COLUMN_INSET);
2147       else if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[i].button)
2148         width += clist->column[i].button->requisition.width;
2149     }
2150
2151   return width;
2152 }
2153
2154 /* this function returns the new width of the column being resized given
2155  * the column and x position of the cursor; the x cursor position is passed
2156  * in as a pointer and automagicly corrected if it's beyond min/max limits */
2157 static gint
2158 new_column_width (GtkCMCList *clist,
2159                   gint      column,
2160                   gint     *x)
2161 {
2162   gint xthickness = GTK_WIDGET (clist)->style->xthickness;
2163   gint width;
2164   gint cx;
2165   gint dx;
2166   gint last_column;
2167
2168   /* first translate the x position from widget->window
2169    * to clist->clist_window */
2170   cx = *x - xthickness;
2171
2172   for (last_column = clist->columns - 1;
2173        last_column >= 0 && !clist->column[last_column].visible; last_column--);
2174
2175   /* calculate new column width making sure it doesn't end up
2176    * less than the minimum width */
2177   dx = (COLUMN_LEFT_XPIXEL (clist, column) + COLUMN_INSET +
2178         (column < last_column) * CELL_SPACING);
2179   width = cx - dx;
2180
2181   if (width < MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width))
2182     {
2183       width = MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width);
2184       cx = dx + width;
2185       *x = cx + xthickness;
2186     }
2187   else if (clist->column[column].max_width >= COLUMN_MIN_WIDTH &&
2188            width > clist->column[column].max_width)
2189     {
2190       width = clist->column[column].max_width;
2191       cx = dx + clist->column[column].max_width;
2192       *x = cx + xthickness;
2193     }
2194
2195   if (cx < 0 || cx > clist->clist_window_width)
2196     *x = -1;
2197
2198   return width;
2199 }
2200
2201 static void
2202 column_button_create (GtkCMCList *clist,
2203                       gint      column)
2204 {
2205   GtkWidget *button;
2206
2207   gtk_widget_push_composite_child ();
2208   button = clist->column[column].button = gtk_button_new ();
2209   gtk_container_set_border_width(GTK_CONTAINER(button), 0);
2210   gtk_widget_pop_composite_child ();
2211
2212   if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
2213     gtk_widget_set_parent_window (clist->column[column].button,
2214                                   clist->title_window);
2215   gtk_widget_set_parent (button, GTK_WIDGET (clist));
2216
2217   g_signal_connect (G_OBJECT (button), "clicked",
2218                       G_CALLBACK(column_button_clicked),
2219                       (gpointer) clist);
2220   gtk_widget_show (button);
2221 }
2222
2223 static void
2224 column_button_clicked (GtkWidget *widget,
2225                        gpointer   data)
2226 {
2227   gint i;
2228   GtkCMCList *clist;
2229
2230   g_return_if_fail (widget != NULL);
2231   g_return_if_fail (GTK_IS_CMCLIST (data));
2232
2233   clist = GTK_CMCLIST (data);
2234
2235   /* find the column who's button was pressed */
2236   for (i = 0; i < clist->columns; i++)
2237     if (clist->column[i].button == widget)
2238       break;
2239
2240   g_signal_emit (G_OBJECT (clist), clist_signals[CLICK_COLUMN], 0, i);
2241 }
2242
2243 static gint
2244 column_title_passive_func (GtkWidget *widget,
2245                            GdkEvent  *event,
2246                            gpointer   data)
2247 {
2248   g_return_val_if_fail (event != NULL, FALSE);
2249
2250   switch (event->type)
2251     {
2252     case GDK_MOTION_NOTIFY:
2253     case GDK_BUTTON_PRESS:
2254     case GDK_2BUTTON_PRESS:
2255     case GDK_3BUTTON_PRESS:
2256     case GDK_BUTTON_RELEASE:
2257     case GDK_ENTER_NOTIFY:
2258     case GDK_LEAVE_NOTIFY:
2259       return TRUE;
2260     default:
2261       break;
2262     }
2263   return FALSE;
2264 }
2265
2266
2267 /* PUBLIC CELL FUNCTIONS
2268  *   gtk_cmclist_get_cell_type
2269  *   gtk_cmclist_set_text
2270  *   gtk_cmclist_get_text
2271  *   gtk_cmclist_set_pixmap
2272  *   gtk_cmclist_get_pixmap
2273  *   gtk_cmclist_set_pixtext
2274  *   gtk_cmclist_get_pixtext
2275  *   gtk_cmclist_set_shift
2276  */
2277 GtkCMCellType
2278 gtk_cmclist_get_cell_type (GtkCMCList *clist,
2279                          gint      row,
2280                          gint      column)
2281 {
2282   GtkCMCListRow *clist_row;
2283
2284   g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
2285
2286   if (row < 0 || row >= clist->rows)
2287     return -1;
2288   if (column < 0 || column >= clist->columns)
2289     return -1;
2290
2291   clist_row = ROW_ELEMENT (clist, row)->data;
2292
2293   return clist_row->cell[column].type;
2294 }
2295
2296 void
2297 gtk_cmclist_set_text (GtkCMCList    *clist,
2298                     gint         row,
2299                     gint         column,
2300                     const gchar *text)
2301 {
2302   GtkCMCListRow *clist_row;
2303
2304   g_return_if_fail (GTK_IS_CMCLIST (clist));
2305
2306   if (row < 0 || row >= clist->rows)
2307     return;
2308   if (column < 0 || column >= clist->columns)
2309     return;
2310
2311   clist_row = ROW_ELEMENT (clist, row)->data;
2312
2313   /* if text is null, then the cell is empty */
2314   GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
2315     (clist, clist_row, column, GTK_CMCELL_TEXT, text, 0, NULL, NULL);
2316
2317   /* redraw the list if it's not frozen */
2318   if (CLIST_UNFROZEN (clist))
2319     {
2320       if (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
2321         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
2322     }
2323 }
2324
2325 gint
2326 gtk_cmclist_get_text (GtkCMCList  *clist,
2327                     gint       row,
2328                     gint       column,
2329                     gchar    **text)
2330 {
2331   GtkCMCListRow *clist_row;
2332
2333   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
2334
2335   if (row < 0 || row >= clist->rows)
2336     return 0;
2337   if (column < 0 || column >= clist->columns)
2338     return 0;
2339
2340   clist_row = ROW_ELEMENT (clist, row)->data;
2341
2342   if (clist_row->cell[column].type != GTK_CMCELL_TEXT)
2343     return 0;
2344
2345   if (text)
2346     *text = GTK_CMCELL_TEXT (clist_row->cell[column])->text;
2347
2348   return 1;
2349 }
2350
2351 void
2352 gtk_cmclist_set_pixmap (GtkCMCList  *clist,
2353                       gint       row,
2354                       gint       column,
2355                       GdkPixmap *pixmap,
2356                       GdkBitmap *mask)
2357 {
2358   GtkCMCListRow *clist_row;
2359
2360   g_return_if_fail (GTK_IS_CMCLIST (clist));
2361
2362   if (row < 0 || row >= clist->rows)
2363     return;
2364   if (column < 0 || column >= clist->columns)
2365     return;
2366
2367   clist_row = ROW_ELEMENT (clist, row)->data;
2368
2369   g_object_ref (pixmap);
2370
2371   if (mask) g_object_ref (mask);
2372
2373   GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
2374     (clist, clist_row, column, GTK_CMCELL_PIXMAP, NULL, 0, pixmap, mask);
2375
2376   /* redraw the list if it's not frozen */
2377   if (CLIST_UNFROZEN (clist))
2378     {
2379       if (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
2380         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
2381     }
2382 }
2383
2384 gint
2385 gtk_cmclist_get_pixmap (GtkCMCList   *clist,
2386                       gint        row,
2387                       gint        column,
2388                       GdkPixmap **pixmap,
2389                       GdkBitmap **mask)
2390 {
2391   GtkCMCListRow *clist_row;
2392
2393   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
2394
2395   if (row < 0 || row >= clist->rows)
2396     return 0;
2397   if (column < 0 || column >= clist->columns)
2398     return 0;
2399
2400   clist_row = ROW_ELEMENT (clist, row)->data;
2401
2402   if (clist_row->cell[column].type != GTK_CMCELL_PIXMAP)
2403     return 0;
2404
2405   if (pixmap)
2406   {
2407     *pixmap = GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap;
2408     /* mask can be NULL */
2409     *mask = GTK_CMCELL_PIXMAP (clist_row->cell[column])->mask;
2410   }
2411
2412   return 1;
2413 }
2414
2415 void
2416 gtk_cmclist_set_pixtext (GtkCMCList    *clist,
2417                        gint         row,
2418                        gint         column,
2419                        const gchar *text,
2420                        guint8       spacing,
2421                        GdkPixmap   *pixmap,
2422                        GdkBitmap   *mask)
2423 {
2424   GtkCMCListRow *clist_row;
2425
2426   g_return_if_fail (GTK_IS_CMCLIST (clist));
2427
2428   if (row < 0 || row >= clist->rows)
2429     return;
2430   if (column < 0 || column >= clist->columns)
2431     return;
2432
2433   clist_row = ROW_ELEMENT (clist, row)->data;
2434
2435   g_object_ref (pixmap);
2436   if (mask) g_object_ref (mask);
2437   GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
2438     (clist, clist_row, column, GTK_CMCELL_PIXTEXT, text, spacing, pixmap, mask);
2439
2440   /* redraw the list if it's not frozen */
2441   if (CLIST_UNFROZEN (clist))
2442     {
2443       if (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
2444         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
2445     }
2446 }
2447
2448 gint
2449 gtk_cmclist_get_pixtext (GtkCMCList   *clist,
2450                        gint        row,
2451                        gint        column,
2452                        gchar     **text,
2453                        guint8     *spacing,
2454                        GdkPixmap **pixmap,
2455                        GdkBitmap **mask)
2456 {
2457   GtkCMCListRow *clist_row;
2458
2459   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
2460
2461   if (row < 0 || row >= clist->rows)
2462     return 0;
2463   if (column < 0 || column >= clist->columns)
2464     return 0;
2465
2466   clist_row = ROW_ELEMENT (clist, row)->data;
2467
2468   if (clist_row->cell[column].type != GTK_CMCELL_PIXTEXT)
2469     return 0;
2470
2471   if (text)
2472     *text = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->text;
2473   if (spacing)
2474     *spacing = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->spacing;
2475   if (pixmap)
2476     *pixmap = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap;
2477
2478   /* mask can be NULL */
2479   if (mask)
2480     *mask = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->mask;
2481
2482   return 1;
2483 }
2484
2485 void
2486 gtk_cmclist_set_shift (GtkCMCList *clist,
2487                      gint      row,
2488                      gint      column,
2489                      gint      vertical,
2490                      gint      horizontal)
2491 {
2492   GtkRequisition requisition = { 0 };
2493   GtkCMCListRow *clist_row;
2494
2495   g_return_if_fail (GTK_IS_CMCLIST (clist));
2496
2497   if (row < 0 || row >= clist->rows)
2498     return;
2499   if (column < 0 || column >= clist->columns)
2500     return;
2501
2502   clist_row = ROW_ELEMENT (clist, row)->data;
2503
2504   if (clist->column[column].auto_resize &&
2505       !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
2506     GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
2507                                                    column, &requisition);
2508
2509   clist_row->cell[column].vertical = vertical;
2510   clist_row->cell[column].horizontal = horizontal;
2511
2512   column_auto_resize (clist, clist_row, column, requisition.width);
2513
2514   if (CLIST_UNFROZEN (clist) && gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
2515     GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
2516 }
2517
2518 /* PRIVATE CELL FUNCTIONS
2519  *   set_cell_contents
2520  *   cell_size_request
2521  */
2522 static void
2523 set_cell_contents (GtkCMCList    *clist,
2524                    GtkCMCListRow *clist_row,
2525                    gint         column,
2526                    GtkCMCellType  type,
2527                    const gchar *text,
2528                    guint8       spacing,
2529                    GdkPixmap   *pixmap,
2530                    GdkBitmap   *mask)
2531 {
2532   GtkRequisition requisition;
2533   gchar *old_text = NULL;
2534   GdkPixmap *old_pixmap = NULL;
2535   GdkBitmap *old_mask = NULL;
2536
2537   g_return_if_fail (GTK_IS_CMCLIST (clist));
2538   g_return_if_fail (clist_row != NULL);
2539
2540   if (clist->column[column].auto_resize &&
2541       !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
2542     GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
2543                                                    column, &requisition);
2544
2545   switch (clist_row->cell[column].type)
2546     {
2547     case GTK_CMCELL_EMPTY:
2548       break;
2549     case GTK_CMCELL_TEXT:
2550       old_text = GTK_CMCELL_TEXT (clist_row->cell[column])->text;
2551       break;
2552     case GTK_CMCELL_PIXMAP:
2553       old_pixmap = GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap;
2554       old_mask = GTK_CMCELL_PIXMAP (clist_row->cell[column])->mask;
2555       break;
2556     case GTK_CMCELL_PIXTEXT:
2557       old_text = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->text;
2558       old_pixmap = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap;
2559       old_mask = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->mask;
2560       break;
2561     case GTK_CMCELL_WIDGET:
2562       /* unimplemented */
2563       break;
2564     default:
2565       break;
2566     }
2567
2568   clist_row->cell[column].type = GTK_CMCELL_EMPTY;
2569
2570   /* Note that pixmap and mask were already ref'ed by the caller
2571    */
2572   switch (type)
2573     {
2574     case GTK_CMCELL_TEXT:
2575       if (text)
2576         {
2577           clist_row->cell[column].type = GTK_CMCELL_TEXT;
2578           GTK_CMCELL_TEXT (clist_row->cell[column])->text = g_strdup (text);
2579         }
2580       break;
2581     case GTK_CMCELL_PIXMAP:
2582       if (pixmap)
2583         {
2584           clist_row->cell[column].type = GTK_CMCELL_PIXMAP;
2585           GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap = pixmap;
2586           /* We set the mask even if it is NULL */
2587           GTK_CMCELL_PIXMAP (clist_row->cell[column])->mask = mask;
2588         }
2589       break;
2590     case GTK_CMCELL_PIXTEXT:
2591       if (text && pixmap)
2592         {
2593           clist_row->cell[column].type = GTK_CMCELL_PIXTEXT;
2594           GTK_CMCELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
2595           GTK_CMCELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
2596           GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
2597           GTK_CMCELL_PIXTEXT (clist_row->cell[column])->mask = mask;
2598         }
2599       break;
2600     default:
2601       break;
2602     }
2603
2604   if (clist->column[column].auto_resize &&
2605       !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
2606     column_auto_resize (clist, clist_row, column, requisition.width);
2607
2608   g_free (old_text);
2609   if (old_pixmap)
2610     g_object_unref (old_pixmap);
2611   if (old_mask)
2612     g_object_unref (old_mask);
2613 }
2614
2615 PangoLayout *
2616 _gtk_cmclist_create_cell_layout (GtkCMCList       *clist,
2617                                GtkCMCListRow    *clist_row,
2618                                gint            column)
2619 {
2620   PangoLayout *layout;
2621   GtkStyle *style;
2622   GtkCMCell *cell;
2623   gchar *text;
2624
2625   get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
2626                   NULL, NULL);
2627
2628
2629   cell = &clist_row->cell[column];
2630   switch (cell->type)
2631     {
2632     case GTK_CMCELL_TEXT:
2633     case GTK_CMCELL_PIXTEXT:
2634       text = ((cell->type == GTK_CMCELL_PIXTEXT) ?
2635               GTK_CMCELL_PIXTEXT (*cell)->text :
2636               GTK_CMCELL_TEXT (*cell)->text);
2637
2638       if (!text)
2639         return NULL;
2640
2641       layout = gtk_widget_create_pango_layout (GTK_WIDGET (clist),
2642                                                ((cell->type == GTK_CMCELL_PIXTEXT) ?
2643                                                 GTK_CMCELL_PIXTEXT (*cell)->text :
2644                                                 GTK_CMCELL_TEXT (*cell)->text));
2645       pango_layout_set_font_description (layout, style->font_desc);
2646
2647       return layout;
2648
2649     default:
2650       return NULL;
2651     }
2652 }
2653
2654 static void
2655 cell_size_request (GtkCMCList       *clist,
2656                    GtkCMCListRow    *clist_row,
2657                    gint            column,
2658                    GtkRequisition *requisition)
2659 {
2660   gint width;
2661   gint height;
2662   PangoLayout *layout;
2663   PangoRectangle logical_rect;
2664
2665   g_return_if_fail (GTK_IS_CMCLIST (clist));
2666   g_return_if_fail (requisition != NULL);
2667
2668   layout = _gtk_cmclist_create_cell_layout (clist, clist_row, column);
2669   if (layout)
2670     {
2671       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
2672
2673       requisition->width = logical_rect.width;
2674       requisition->height = logical_rect.height;
2675
2676       g_object_unref (G_OBJECT (layout));
2677     }
2678   else
2679     {
2680       requisition->width  = 0;
2681       requisition->height = 0;
2682     }
2683
2684   if (layout && clist_row->cell[column].type == GTK_CMCELL_PIXTEXT)
2685     requisition->width += GTK_CMCELL_PIXTEXT (clist_row->cell[column])->spacing;
2686
2687   switch (clist_row->cell[column].type)
2688     {
2689     case GTK_CMCELL_PIXTEXT:
2690       gdk_drawable_get_size (GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap,
2691                            &width, &height);
2692       requisition->width += width;
2693       requisition->height = MAX (requisition->height, height);
2694       break;
2695     case GTK_CMCELL_PIXMAP:
2696       gdk_drawable_get_size (GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap,
2697                            &width, &height);
2698       requisition->width += width;
2699       requisition->height = MAX (requisition->height, height);
2700       break;
2701
2702     default:
2703       break;
2704     }
2705
2706   requisition->width  += clist_row->cell[column].horizontal;
2707   requisition->height += clist_row->cell[column].vertical;
2708 }
2709
2710 /* PUBLIC INSERT/REMOVE ROW FUNCTIONS
2711  *   gtk_cmclist_prepend
2712  *   gtk_cmclist_append
2713  *   gtk_cmclist_insert
2714  *   gtk_cmclist_remove
2715  *   gtk_cmclist_clear
2716  */
2717 gint
2718 gtk_cmclist_prepend (GtkCMCList    *clist,
2719                    gchar       *text[])
2720 {
2721   g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
2722   g_return_val_if_fail (text != NULL, -1);
2723
2724   return GTK_CMCLIST_GET_CLASS (clist)->insert_row (clist, 0, text);
2725 }
2726
2727 gint
2728 gtk_cmclist_append (GtkCMCList    *clist,
2729                   gchar       *text[])
2730 {
2731   g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
2732   g_return_val_if_fail (text != NULL, -1);
2733
2734   return GTK_CMCLIST_GET_CLASS (clist)->insert_row (clist, clist->rows, text);
2735 }
2736
2737 gint
2738 gtk_cmclist_insert (GtkCMCList    *clist,
2739                   gint         row,
2740                   gchar       *text[])
2741 {
2742   g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
2743   g_return_val_if_fail (text != NULL, -1);
2744
2745   if (row < 0 || row > clist->rows)
2746     row = clist->rows;
2747
2748   return GTK_CMCLIST_GET_CLASS (clist)->insert_row (clist, row, text);
2749 }
2750
2751 void
2752 gtk_cmclist_remove (GtkCMCList *clist,
2753                   gint      row)
2754 {
2755   GTK_CMCLIST_GET_CLASS (clist)->remove_row (clist, row);
2756 }
2757
2758 void
2759 gtk_cmclist_clear (GtkCMCList *clist)
2760 {
2761   g_return_if_fail (GTK_IS_CMCLIST (clist));
2762
2763   GTK_CMCLIST_GET_CLASS (clist)->clear (clist);
2764 }
2765
2766 /* PRIVATE INSERT/REMOVE ROW FUNCTIONS
2767  *   real_insert_row
2768  *   real_remove_row
2769  *   real_clear
2770  *   real_row_move
2771  */
2772 static gint
2773 real_insert_row (GtkCMCList *clist,
2774                  gint      row,
2775                  gchar    *text[])
2776 {
2777   gint i;
2778   GtkCMCListRow *clist_row;
2779
2780   g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
2781   g_return_val_if_fail (text != NULL, -1);
2782
2783   /* return if out of bounds */
2784   if (row < 0 || row > clist->rows)
2785     return -1;
2786
2787   /* create the row */
2788   clist_row = row_new (clist);
2789
2790   /* set the text in the row's columns */
2791   for (i = 0; i < clist->columns; i++)
2792     if (text[i])
2793       GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
2794         (clist, clist_row, i, GTK_CMCELL_TEXT, text[i], 0, NULL ,NULL);
2795
2796   if (!clist->rows)
2797     {
2798       clist->row_list = g_list_append (clist->row_list, clist_row);
2799       clist->row_list_end = clist->row_list;
2800     }
2801   else
2802     {
2803       if (GTK_CMCLIST_AUTO_SORT(clist))   /* override insertion pos */
2804         {
2805           GList *work;
2806
2807           row = 0;
2808           work = clist->row_list;
2809
2810           if (clist->sort_type == GTK_SORT_ASCENDING)
2811             {
2812               while (row < clist->rows &&
2813                      clist->compare (clist, clist_row,
2814                                      GTK_CMCLIST_ROW (work)) > 0)
2815                 {
2816                   row++;
2817                   work = work->next;
2818                 }
2819             }
2820           else
2821             {
2822               while (row < clist->rows &&
2823                      clist->compare (clist, clist_row,
2824                                      GTK_CMCLIST_ROW (work)) < 0)
2825                 {
2826                   row++;
2827                   work = work->next;
2828                 }
2829             }
2830         }
2831
2832       /* reset the row end pointer if we're inserting at the end of the list */
2833       if (row == clist->rows)
2834         clist->row_list_end = (g_list_append (clist->row_list_end,
2835                                               clist_row))->next;
2836       else
2837         clist->row_list = g_list_insert (clist->row_list, clist_row, row);
2838
2839     }
2840   clist->rows++;
2841
2842   if (row < ROW_FROM_YPIXEL (clist, 0))
2843     clist->voffset -= (clist->row_height + CELL_SPACING);
2844
2845   /* syncronize the selection list */
2846   sync_selection (clist, row, SYNC_INSERT);
2847
2848   if (clist->rows == 1)
2849     {
2850       clist->focus_row = 0;
2851       if (clist->selection_mode == GTK_SELECTION_BROWSE)
2852         gtk_cmclist_select_row (clist, 0, -1);
2853     }
2854
2855   /* redraw the list if it isn't frozen */
2856   if (CLIST_UNFROZEN (clist))
2857     {
2858       adjust_adjustments (clist, FALSE);
2859
2860       if (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
2861         draw_rows (clist, NULL);
2862     }
2863
2864   return row;
2865 }
2866
2867 static void
2868 real_remove_row (GtkCMCList *clist,
2869                  gint      row)
2870 {
2871   gint was_visible;
2872   GList *list;
2873   GtkCMCListRow *clist_row;
2874
2875   g_return_if_fail (GTK_IS_CMCLIST (clist));
2876
2877   /* return if out of bounds */
2878   if (row < 0 || row > (clist->rows - 1))
2879     return;
2880
2881   was_visible = (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE);
2882
2883   /* get the row we're going to delete */
2884   list = ROW_ELEMENT (clist, row);
2885   g_assert (list != NULL);
2886   clist_row = list->data;
2887
2888   /* if we're removing a selected row, we have to make sure
2889    * it's properly unselected, and then sync up the clist->selected
2890    * list to reflect the deincrimented indexies of rows after the
2891    * removal */
2892   if (clist_row->state == GTK_STATE_SELECTED)
2893     g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
2894                      row, -1, NULL);
2895
2896   sync_selection (clist, row, SYNC_REMOVE);
2897
2898   /* reset the row end pointer if we're removing at the end of the list */
2899   clist->rows--;
2900   if (clist->row_list == list)
2901     clist->row_list = g_list_next (list);
2902   if (clist->row_list_end == list)
2903     clist->row_list_end = g_list_previous (list);
2904   list = g_list_remove (list, clist_row);
2905
2906   if (row < ROW_FROM_YPIXEL (clist, 0))
2907     clist->voffset += clist->row_height + CELL_SPACING;
2908
2909   if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
2910       clist->focus_row >= 0)
2911     g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
2912                      clist->focus_row, -1, NULL);
2913
2914   /* toast the row */
2915   row_delete (clist, clist_row);
2916
2917   /* redraw the row if it isn't frozen */
2918   if (CLIST_UNFROZEN (clist))
2919     {
2920       adjust_adjustments (clist, FALSE);
2921
2922       if (was_visible)
2923         draw_rows (clist, NULL);
2924     }
2925 }
2926
2927 static void
2928 real_clear (GtkCMCList *clist)
2929 {
2930   GList *list;
2931   GList *free_list;
2932   gint i;
2933
2934   g_return_if_fail (GTK_IS_CMCLIST (clist));
2935
2936   /* free up the selection list */
2937   g_list_free (clist->selection);
2938   g_list_free (clist->undo_selection);
2939   g_list_free (clist->undo_unselection);
2940
2941   clist->selection = NULL;
2942   clist->selection_end = NULL;
2943   clist->undo_selection = NULL;
2944   clist->undo_unselection = NULL;
2945   clist->voffset = 0;
2946   clist->focus_row = -1;
2947   clist->anchor = -1;
2948   clist->undo_anchor = -1;
2949   clist->anchor_state = GTK_STATE_SELECTED;
2950   clist->drag_pos = -1;
2951
2952   /* remove all the rows */
2953   GTK_CMCLIST_SET_FLAG (clist, CMCLIST_AUTO_RESIZE_BLOCKED);
2954   free_list = clist->row_list;
2955   clist->row_list = NULL;
2956   clist->row_list_end = NULL;
2957   clist->rows = 0;
2958   for (list = free_list; list; list = list->next)
2959     row_delete (clist, GTK_CMCLIST_ROW (list));
2960   g_list_free (free_list);
2961   GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_AUTO_RESIZE_BLOCKED);
2962   for (i = 0; i < clist->columns; i++)
2963     if (clist->column[i].auto_resize)
2964       {
2965         if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[i].button)
2966           gtk_cmclist_set_column_width
2967             (clist, i, (clist->column[i].button->requisition.width -
2968                         (CELL_SPACING + (2 * COLUMN_INSET))));
2969         else
2970           gtk_cmclist_set_column_width (clist, i, 0);
2971       }
2972   /* zero-out the scrollbars */
2973   if (clist->vadjustment)
2974     {
2975       gtk_adjustment_set_value (clist->vadjustment, 0.0);
2976       CLIST_REFRESH (clist);
2977     }
2978   else
2979     gtk_widget_queue_resize (GTK_WIDGET (clist));
2980 }
2981
2982 static void
2983 real_row_move (GtkCMCList *clist,
2984                gint      source_row,
2985                gint      dest_row)
2986 {
2987   GtkCMCListRow *clist_row;
2988   GList *list;
2989   gint first, last;
2990   gint d;
2991
2992   g_return_if_fail (GTK_IS_CMCLIST (clist));
2993
2994   if (GTK_CMCLIST_AUTO_SORT(clist))
2995     return;
2996
2997   if (source_row < 0 || source_row >= clist->rows ||
2998       dest_row   < 0 || dest_row   >= clist->rows ||
2999       source_row == dest_row)
3000     return;
3001
3002   gtk_cmclist_freeze (clist);
3003
3004   /* unlink source row */
3005   clist_row = ROW_ELEMENT (clist, source_row)->data;
3006   if (source_row == clist->rows - 1)
3007     clist->row_list_end = clist->row_list_end->prev;
3008   clist->row_list = g_list_remove (clist->row_list, clist_row);
3009   clist->rows--;
3010
3011   /* relink source row */
3012   clist->row_list = g_list_insert (clist->row_list, clist_row, dest_row);
3013   if (dest_row == clist->rows)
3014     clist->row_list_end = clist->row_list_end->next;
3015   clist->rows++;
3016
3017   /* sync selection */
3018   if (source_row > dest_row)
3019     {
3020       first = dest_row;
3021       last  = source_row;
3022       d = 1;
3023     }
3024   else
3025     {
3026       first = source_row;
3027       last  = dest_row;
3028       d = -1;
3029     }
3030
3031   for (list = clist->selection; list; list = list->next)
3032     {
3033       if (list->data == GINT_TO_POINTER (source_row))
3034         list->data = GINT_TO_POINTER (dest_row);
3035       else if (first <= GPOINTER_TO_INT (list->data) &&
3036                last >= GPOINTER_TO_INT (list->data))
3037         list->data = GINT_TO_POINTER (GPOINTER_TO_INT (list->data) + d);
3038     }
3039
3040   if (clist->focus_row == source_row)
3041     clist->focus_row = dest_row;
3042   else if (clist->focus_row > first)
3043     clist->focus_row += d;
3044
3045   gtk_cmclist_thaw (clist);
3046 }
3047
3048 /* PUBLIC ROW FUNCTIONS
3049  *   gtk_cmclist_moveto
3050  *   gtk_cmclist_set_row_height
3051  *   gtk_cmclist_set_row_data
3052  *   gtk_cmclist_set_row_data_full
3053  *   gtk_cmclist_get_row_data
3054  *   gtk_cmclist_find_row_from_data
3055  *   gtk_cmclist_swap_rows
3056  *   gtk_cmclist_row_move
3057  *   gtk_cmclist_row_is_visible
3058  *   gtk_cmclist_set_foreground
3059  *   gtk_cmclist_set_background
3060  */
3061 void
3062 gtk_cmclist_moveto (GtkCMCList *clist,
3063                   gint      row,
3064                   gint      column,
3065                   gfloat    row_align,
3066                   gfloat    col_align)
3067 {
3068   g_return_if_fail (GTK_IS_CMCLIST (clist));
3069
3070   if (row < -1 || row >= clist->rows)
3071     return;
3072   if (column < -1 || column >= clist->columns)
3073     return;
3074
3075   row_align = CLAMP (row_align, 0, 1);
3076   col_align = CLAMP (col_align, 0, 1);
3077
3078   /* adjust horizontal scrollbar */
3079   if (clist->hadjustment && column >= 0)
3080     {
3081       gint x;
3082
3083       x = (COLUMN_LEFT (clist, column) - CELL_SPACING - COLUMN_INSET -
3084            (col_align * (clist->clist_window_width - 2 * COLUMN_INSET -
3085                          CELL_SPACING - clist->column[column].area.width)));
3086       if (x < 0)
3087         gtk_adjustment_set_value (clist->hadjustment, 0.0);
3088       else if (x > LIST_WIDTH (clist) - clist->clist_window_width)
3089         gtk_adjustment_set_value
3090           (clist->hadjustment, LIST_WIDTH (clist) - clist->clist_window_width);
3091       else
3092         gtk_adjustment_set_value (clist->hadjustment, x);
3093     }
3094
3095   /* adjust vertical scrollbar */
3096   if (clist->vadjustment && row >= 0)
3097     move_vertical (clist, row, row_align);
3098 }
3099
3100 void
3101 gtk_cmclist_set_row_height (GtkCMCList *clist,
3102                           guint     height)
3103 {
3104   GtkWidget *widget;
3105
3106   g_return_if_fail (GTK_IS_CMCLIST (clist));
3107
3108   widget = GTK_WIDGET (clist);
3109
3110   if (height > 0)
3111     {
3112       clist->row_height = height;
3113       GTK_CMCLIST_SET_FLAG (clist, CMCLIST_ROW_HEIGHT_SET);
3114     }
3115   else
3116     {
3117       GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_ROW_HEIGHT_SET);
3118       clist->row_height = 0;
3119     }
3120
3121   if (widget->style->font_desc)
3122     {
3123       PangoContext *context = gtk_widget_get_pango_context (widget);
3124       PangoFontMetrics *metrics;
3125
3126       metrics = pango_context_get_metrics (context,
3127                                            widget->style->font_desc,
3128                                            pango_context_get_language (context));
3129
3130       if (!GTK_CMCLIST_ROW_HEIGHT_SET(clist))
3131         {
3132           clist->row_height = (pango_font_metrics_get_ascent (metrics) +
3133                                pango_font_metrics_get_descent (metrics));
3134           clist->row_height = PANGO_PIXELS (clist->row_height);
3135         }
3136
3137       pango_font_metrics_unref (metrics);
3138     }
3139
3140   CLIST_REFRESH (clist);
3141 }
3142
3143 void
3144 gtk_cmclist_set_row_data (GtkCMCList *clist,
3145                         gint      row,
3146                         gpointer  data)
3147 {
3148   gtk_cmclist_set_row_data_full (clist, row, data, NULL);
3149 }
3150
3151 void
3152 gtk_cmclist_set_row_data_full (GtkCMCList         *clist,
3153                              gint              row,
3154                              gpointer          data,
3155                              GDestroyNotify  destroy)
3156 {
3157   GtkCMCListRow *clist_row;
3158
3159   g_return_if_fail (GTK_IS_CMCLIST (clist));
3160
3161   if (row < 0 || row > (clist->rows - 1))
3162     return;
3163
3164   clist_row = ROW_ELEMENT (clist, row)->data;
3165
3166   if (clist_row->destroy)
3167     clist_row->destroy (clist_row->data);
3168
3169   clist_row->data = data;
3170   clist_row->destroy = destroy;
3171 }
3172
3173 gpointer
3174 gtk_cmclist_get_row_data (GtkCMCList *clist,
3175                         gint      row)
3176 {
3177   GtkCMCListRow *clist_row;
3178
3179   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
3180
3181   if (row < 0 || row > (clist->rows - 1))
3182     return NULL;
3183
3184   clist_row = ROW_ELEMENT (clist, row)->data;
3185   return clist_row->data;
3186 }
3187
3188 gint
3189 gtk_cmclist_find_row_from_data (GtkCMCList *clist,
3190                               gpointer  data)
3191 {
3192   GList *list;
3193   gint n;
3194
3195   g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
3196
3197   for (n = 0, list = clist->row_list; list; n++, list = list->next)
3198     if (GTK_CMCLIST_ROW (list)->data == data)
3199       return n;
3200
3201   return -1;
3202 }
3203
3204 void
3205 gtk_cmclist_swap_rows (GtkCMCList *clist,
3206                      gint      row1,
3207                      gint      row2)
3208 {
3209   gint first, last;
3210
3211   g_return_if_fail (GTK_IS_CMCLIST (clist));
3212   g_return_if_fail (row1 != row2);
3213
3214   if (GTK_CMCLIST_AUTO_SORT(clist))
3215     return;
3216
3217   gtk_cmclist_freeze (clist);
3218
3219   first = MIN (row1, row2);
3220   last  = MAX (row1, row2);
3221
3222   gtk_cmclist_row_move (clist, last, first);
3223   gtk_cmclist_row_move (clist, first + 1, last);
3224
3225   gtk_cmclist_thaw (clist);
3226 }
3227
3228 void
3229 gtk_cmclist_row_move (GtkCMCList *clist,
3230                     gint      source_row,
3231                     gint      dest_row)
3232 {
3233   g_return_if_fail (GTK_IS_CMCLIST (clist));
3234
3235   if (GTK_CMCLIST_AUTO_SORT(clist))
3236     return;
3237
3238   if (source_row < 0 || source_row >= clist->rows ||
3239       dest_row   < 0 || dest_row   >= clist->rows ||
3240       source_row == dest_row)
3241     return;
3242
3243   g_signal_emit (G_OBJECT (clist), clist_signals[ROW_MOVE], 0,
3244                    source_row, dest_row);
3245 }
3246
3247 GtkVisibility
3248 gtk_cmclist_row_is_visible (GtkCMCList *clist,
3249                           gint      row)
3250 {
3251   gint top;
3252
3253   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
3254
3255   if (row < 0 || row >= clist->rows)
3256     return GTK_VISIBILITY_NONE;
3257
3258   if (clist->row_height == 0)
3259     return GTK_VISIBILITY_NONE;
3260
3261   if (row < ROW_FROM_YPIXEL (clist, 0))
3262     return GTK_VISIBILITY_NONE;
3263
3264   if (row > ROW_FROM_YPIXEL (clist, clist->clist_window_height))
3265     return GTK_VISIBILITY_NONE;
3266
3267   top = ROW_TOP_YPIXEL (clist, row);
3268
3269   if ((top < 0)
3270       || ((top + clist->row_height) >= clist->clist_window_height))
3271     return GTK_VISIBILITY_PARTIAL;
3272
3273   return GTK_VISIBILITY_FULL;
3274 }
3275
3276 void
3277 gtk_cmclist_set_foreground (GtkCMCList       *clist,
3278                           gint            row,
3279                           const GdkColor *color)
3280 {
3281   GtkCMCListRow *clist_row;
3282
3283   g_return_if_fail (GTK_IS_CMCLIST (clist));
3284
3285   if (row < 0 || row >= clist->rows)
3286     return;
3287
3288   clist_row = ROW_ELEMENT (clist, row)->data;
3289
3290   if (color)
3291     {
3292       clist_row->foreground = *color;
3293       clist_row->fg_set = TRUE;
3294       if (GTK_WIDGET_REALIZED (clist))
3295         gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (clist)),
3296                          &clist_row->foreground, TRUE, TRUE);
3297     }
3298   else
3299     clist_row->fg_set = FALSE;
3300
3301   if (CLIST_UNFROZEN (clist) && gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
3302     GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
3303 }
3304
3305 void
3306 gtk_cmclist_set_background (GtkCMCList       *clist,
3307                           gint            row,
3308                           const GdkColor *color)
3309 {
3310   GtkCMCListRow *clist_row;
3311
3312   g_return_if_fail (GTK_IS_CMCLIST (clist));
3313
3314   if (row < 0 || row >= clist->rows)
3315     return;
3316
3317   clist_row = ROW_ELEMENT (clist, row)->data;
3318
3319   if (color)
3320     {
3321       clist_row->background = *color;
3322       clist_row->bg_set = TRUE;
3323       if (GTK_WIDGET_REALIZED (clist))
3324         gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (clist)),
3325                          &clist_row->background, TRUE, TRUE);
3326     }
3327   else
3328     clist_row->bg_set = FALSE;
3329
3330   if (CLIST_UNFROZEN (clist)
3331       && (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
3332     GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
3333 }
3334
3335 /* PUBLIC ROW/CELL STYLE FUNCTIONS
3336  *   gtk_cmclist_set_cell_style
3337  *   gtk_cmclist_get_cell_style
3338  *   gtk_cmclist_set_row_style
3339  *   gtk_cmclist_get_row_style
3340  */
3341 void
3342 gtk_cmclist_set_cell_style (GtkCMCList *clist,
3343                           gint      row,
3344                           gint      column,
3345                           GtkStyle *style)
3346 {
3347   GtkRequisition requisition = { 0 };
3348   GtkCMCListRow *clist_row;
3349
3350   g_return_if_fail (GTK_IS_CMCLIST (clist));
3351
3352   if (row < 0 || row >= clist->rows)
3353     return;
3354   if (column < 0 || column >= clist->columns)
3355     return;
3356
3357   clist_row = ROW_ELEMENT (clist, row)->data;
3358
3359   if (clist_row->cell[column].style == style)
3360     return;
3361
3362   if (clist->column[column].auto_resize &&
3363       !GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
3364     GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
3365                                                    column, &requisition);
3366
3367   if (clist_row->cell[column].style)
3368     {
3369       if (GTK_WIDGET_REALIZED (clist))
3370         gtk_style_detach (clist_row->cell[column].style);
3371       g_object_unref (clist_row->cell[column].style);
3372     }
3373
3374   clist_row->cell[column].style = style;
3375
3376   if (clist_row->cell[column].style)
3377     {
3378       g_object_ref (clist_row->cell[column].style);
3379
3380       if (GTK_WIDGET_REALIZED (clist))
3381         clist_row->cell[column].style =
3382           gtk_style_attach (clist_row->cell[column].style,
3383                             clist->clist_window);
3384     }
3385
3386   column_auto_resize (clist, clist_row, column, requisition.width);
3387
3388   /* redraw the list if it's not frozen */
3389   if (CLIST_UNFROZEN (clist))
3390     {
3391       if (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
3392         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
3393     }
3394 }
3395
3396 GtkStyle *
3397 gtk_cmclist_get_cell_style (GtkCMCList *clist,
3398                           gint      row,
3399                           gint      column)
3400 {
3401   GtkCMCListRow *clist_row;
3402
3403   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
3404
3405   if (row < 0 || row >= clist->rows || column < 0 || column >= clist->columns)
3406     return NULL;
3407
3408   clist_row = ROW_ELEMENT (clist, row)->data;
3409
3410   return clist_row->cell[column].style;
3411 }
3412
3413 void
3414 gtk_cmclist_set_row_style (GtkCMCList *clist,
3415                          gint      row,
3416                          GtkStyle *style)
3417 {
3418   GtkRequisition requisition;
3419   GtkCMCListRow *clist_row;
3420   gint *old_width;
3421   gint i;
3422
3423   g_return_if_fail (GTK_IS_CMCLIST (clist));
3424
3425   if (row < 0 || row >= clist->rows)
3426     return;
3427
3428   clist_row = ROW_ELEMENT (clist, row)->data;
3429
3430   if (clist_row->style == style)
3431     return;
3432
3433   old_width = g_new (gint, clist->columns);
3434
3435   if (!GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
3436     {
3437       for (i = 0; i < clist->columns; i++)
3438         if (clist->column[i].auto_resize)
3439           {
3440             GTK_CMCLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
3441                                                            i, &requisition);
3442             old_width[i] = requisition.width;
3443           }
3444     }
3445
3446   if (clist_row->style)
3447     {
3448       if (GTK_WIDGET_REALIZED (clist))
3449         gtk_style_detach (clist_row->style);
3450       g_object_unref (clist_row->style);
3451     }
3452
3453   clist_row->style = style;
3454
3455   if (clist_row->style)
3456     {
3457       g_object_ref (clist_row->style);
3458
3459       if (GTK_WIDGET_REALIZED (clist))
3460         clist_row->style = gtk_style_attach (clist_row->style,
3461                                              clist->clist_window);
3462     }
3463
3464   if (GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
3465     for (i = 0; i < clist->columns; i++)
3466       column_auto_resize (clist, clist_row, i, old_width[i]);
3467
3468   g_free (old_width);
3469
3470   /* redraw the list if it's not frozen */
3471   if (CLIST_UNFROZEN (clist))
3472     {
3473       if (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
3474         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
3475     }
3476 }
3477
3478 GtkStyle *
3479 gtk_cmclist_get_row_style (GtkCMCList *clist,
3480                          gint      row)
3481 {
3482   GtkCMCListRow *clist_row;
3483
3484   g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
3485
3486   if (row < 0 || row >= clist->rows)
3487     return NULL;
3488
3489   clist_row = ROW_ELEMENT (clist, row)->data;
3490
3491   return clist_row->style;
3492 }
3493
3494 /* PUBLIC SELECTION FUNCTIONS
3495  *   gtk_cmclist_set_selectable
3496  *   gtk_cmclist_get_selectable
3497  *   gtk_cmclist_select_row
3498  *   gtk_cmclist_unselect_row
3499  *   gtk_cmclist_select_all
3500  *   gtk_cmclist_unselect_all
3501  *   gtk_cmclist_undo_selection
3502  */
3503 void
3504 gtk_cmclist_set_selectable (GtkCMCList *clist,
3505                           gint      row,
3506                           gboolean  selectable)
3507 {
3508   GtkCMCListRow *clist_row;
3509
3510   g_return_if_fail (GTK_IS_CMCLIST (clist));
3511
3512   if (row < 0 || row >= clist->rows)
3513     return;
3514
3515   clist_row = ROW_ELEMENT (clist, row)->data;
3516
3517   if (selectable == clist_row->selectable)
3518     return;
3519
3520   clist_row->selectable = selectable;
3521
3522   if (!selectable && clist_row->state == GTK_STATE_SELECTED)
3523     {
3524       if (clist->anchor >= 0 &&
3525           clist->selection_mode == GTK_SELECTION_MULTIPLE)
3526         {
3527           clist->drag_button = 0;
3528           remove_grab (clist);
3529           GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
3530         }
3531       g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
3532                        row, -1, NULL);
3533     }
3534 }
3535
3536 gboolean
3537 gtk_cmclist_get_selectable (GtkCMCList *clist,
3538                           gint      row)
3539 {
3540   g_return_val_if_fail (GTK_IS_CMCLIST (clist), FALSE);
3541
3542   if (row < 0 || row >= clist->rows)
3543     return FALSE;
3544
3545   return GTK_CMCLIST_ROW (ROW_ELEMENT (clist, row))->selectable;
3546 }
3547
3548 void
3549 gtk_cmclist_select_row (GtkCMCList *clist,
3550                       gint      row,
3551                       gint      column)
3552 {
3553   g_return_if_fail (GTK_IS_CMCLIST (clist));
3554
3555   if (row < 0 || row >= clist->rows)
3556     return;
3557   if (column < -1 || column >= clist->columns)
3558     return;
3559
3560   g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
3561                    row, column, NULL);
3562 }
3563
3564 void
3565 gtk_cmclist_unselect_row (GtkCMCList *clist,
3566                         gint      row,
3567                         gint      column)
3568 {
3569   g_return_if_fail (GTK_IS_CMCLIST (clist));
3570
3571   if (row < 0 || row >= clist->rows)
3572     return;
3573   if (column < -1 || column >= clist->columns)
3574     return;
3575
3576   g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
3577                    row, column, NULL);
3578 }
3579
3580 void
3581 gtk_cmclist_select_all (GtkCMCList *clist)
3582 {
3583   g_return_if_fail (GTK_IS_CMCLIST (clist));
3584
3585   GTK_CMCLIST_GET_CLASS (clist)->select_all (clist);
3586 }
3587
3588 void
3589 gtk_cmclist_unselect_all (GtkCMCList *clist)
3590 {
3591   g_return_if_fail (GTK_IS_CMCLIST (clist));
3592
3593   GTK_CMCLIST_GET_CLASS (clist)->unselect_all (clist);
3594 }
3595
3596 void
3597 gtk_cmclist_undo_selection (GtkCMCList *clist)
3598 {
3599   g_return_if_fail (GTK_IS_CMCLIST (clist));
3600
3601   if (clist->selection_mode == GTK_SELECTION_MULTIPLE &&
3602       (clist->undo_selection || clist->undo_unselection))
3603     g_signal_emit (G_OBJECT (clist), clist_signals[UNDO_SELECTION], 0);
3604 }
3605
3606 /* PRIVATE SELECTION FUNCTIONS
3607  *   selection_find
3608  *   toggle_row
3609  *   fake_toggle_row
3610  *   toggle_focus_row
3611  *   toggle_add_mode
3612  *   real_select_row
3613  *   real_unselect_row
3614  *   real_select_all
3615  *   real_unselect_all
3616  *   fake_unselect_all
3617  *   real_undo_selection
3618  *   set_anchor
3619  *   resync_selection
3620  *   update_extended_selection
3621  *   start_selection
3622  *   end_selection
3623  *   extend_selection
3624  *   sync_selection
3625  */
3626 static GList *
3627 selection_find (GtkCMCList *clist,
3628                 gint      row_number,
3629                 GList    *row_list_element)
3630 {
3631   return g_list_find (clist->selection, GINT_TO_POINTER (row_number));
3632 }
3633
3634 static void
3635 toggle_row (GtkCMCList *clist,
3636             gint      row,
3637             gint      column,
3638             GdkEvent *event)
3639 {
3640   GtkCMCListRow *clist_row;
3641
3642   switch (clist->selection_mode)
3643     {
3644     case GTK_SELECTION_MULTIPLE:
3645     case GTK_SELECTION_SINGLE:
3646       clist_row = ROW_ELEMENT (clist, row)->data;
3647
3648       if (!clist_row)
3649         return;
3650
3651       if (clist_row->state == GTK_STATE_SELECTED)
3652         {
3653           g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
3654                            row, column, event);
3655           return;
3656         }
3657     case GTK_SELECTION_BROWSE:
3658       g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
3659                        row, column, event);
3660       break;
3661     default:
3662       g_assert_not_reached ();
3663     }
3664 }
3665
3666 static void
3667 fake_toggle_row (GtkCMCList *clist,
3668                  gint      row)
3669 {
3670   GList *work;
3671
3672   work = ROW_ELEMENT (clist, row);
3673
3674   if (!work || !GTK_CMCLIST_ROW (work)->selectable)
3675     return;
3676
3677   if (GTK_CMCLIST_ROW (work)->state == GTK_STATE_NORMAL)
3678     clist->anchor_state = GTK_CMCLIST_ROW (work)->state = GTK_STATE_SELECTED;
3679   else
3680     clist->anchor_state = GTK_CMCLIST_ROW (work)->state = GTK_STATE_NORMAL;
3681
3682   if (CLIST_UNFROZEN (clist) &&
3683       gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
3684     GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
3685                                           GTK_CMCLIST_ROW (work));
3686 }
3687
3688 static gboolean
3689 clist_has_grab (GtkCMCList *clist)
3690 {
3691   return (GTK_WIDGET_HAS_GRAB (clist) &&
3692           gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))));
3693 }
3694
3695 static void
3696 toggle_focus_row (GtkCMCList *clist)
3697 {
3698   g_return_if_fail (clist != 0);
3699   g_return_if_fail (GTK_IS_CMCLIST (clist));
3700
3701   if (clist_has_grab (clist) ||
3702       clist->focus_row < 0 || clist->focus_row >= clist->rows)
3703     return;
3704
3705   switch (clist->selection_mode)
3706     {
3707     case  GTK_SELECTION_SINGLE:
3708       toggle_row (clist, clist->focus_row, 0, NULL);
3709       break;
3710     case GTK_SELECTION_MULTIPLE:
3711       g_list_free (clist->undo_selection);
3712       g_list_free (clist->undo_unselection);
3713       clist->undo_selection = NULL;
3714       clist->undo_unselection = NULL;
3715
3716       clist->anchor = clist->focus_row;
3717       clist->drag_pos = clist->focus_row;
3718       clist->undo_anchor = clist->focus_row;
3719
3720       if (GTK_CMCLIST_ADD_MODE(clist))
3721         fake_toggle_row (clist, clist->focus_row);
3722       else
3723         GTK_CMCLIST_GET_CLASS (clist)->fake_unselect_all (clist,clist->focus_row);
3724
3725       GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
3726       break;
3727     default:
3728       break;
3729     }
3730 }
3731
3732 static void
3733 toggle_add_mode (GtkCMCList *clist)
3734 {
3735   g_return_if_fail (clist != 0);
3736   g_return_if_fail (GTK_IS_CMCLIST (clist));
3737
3738   if (clist_has_grab (clist) ||
3739       clist->selection_mode != GTK_SELECTION_MULTIPLE)
3740     return;
3741
3742   gtk_cmclist_draw_focus (GTK_WIDGET (clist));
3743   if (!GTK_CMCLIST_ADD_MODE(clist))
3744     {
3745       GTK_CMCLIST_SET_FLAG (clist, CMCLIST_ADD_MODE);
3746       gdk_gc_set_line_attributes (clist->xor_gc, 1,
3747                                   GDK_LINE_ON_OFF_DASH, 0, 0);
3748       gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
3749     }
3750   else
3751     {
3752       GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_ADD_MODE);
3753       gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_SOLID, 0, 0);
3754       clist->anchor_state = GTK_STATE_SELECTED;
3755     }
3756   gtk_cmclist_draw_focus (GTK_WIDGET (clist));
3757 }
3758
3759 static void
3760 real_select_row (GtkCMCList *clist,
3761                  gint      row,
3762                  gint      column,
3763                  GdkEvent *event)
3764 {
3765   GtkCMCListRow *clist_row;
3766   GList *list;
3767   gint sel_row;
3768   gboolean row_selected;
3769
3770   g_return_if_fail (GTK_IS_CMCLIST (clist));
3771
3772   if (row < 0 || row > (clist->rows - 1))
3773     return;
3774
3775   switch (clist->selection_mode)
3776     {
3777     case GTK_SELECTION_SINGLE:
3778     case GTK_SELECTION_BROWSE:
3779
3780       row_selected = FALSE;
3781       list = clist->selection;
3782
3783       while (list)
3784         {
3785           sel_row = GPOINTER_TO_INT (list->data);
3786           list = list->next;
3787
3788           if (row == sel_row)
3789             row_selected = TRUE;
3790           else
3791             g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
3792                              sel_row, column, event);
3793         }
3794
3795       if (row_selected)
3796         return;
3797
3798     default:
3799       break;
3800     }
3801
3802   clist_row = ROW_ELEMENT (clist, row)->data;
3803
3804   if (clist_row->state != GTK_STATE_NORMAL || !clist_row->selectable)
3805     return;
3806
3807   clist_row->state = GTK_STATE_SELECTED;
3808   if (!clist->selection)
3809     {
3810       clist->selection = g_list_append (clist->selection,
3811                                         GINT_TO_POINTER (row));
3812       clist->selection_end = clist->selection;
3813     }
3814   else
3815     clist->selection_end =
3816       g_list_append (clist->selection_end, GINT_TO_POINTER (row))->next;
3817
3818   if (CLIST_UNFROZEN (clist)
3819       && (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
3820     GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
3821 }
3822
3823 static void
3824 real_unselect_row (GtkCMCList *clist,
3825                    gint      row,
3826                    gint      column,
3827                    GdkEvent *event)
3828 {
3829   GtkCMCListRow *clist_row;
3830
3831   g_return_if_fail (GTK_IS_CMCLIST (clist));
3832
3833   if (row < 0 || row > (clist->rows - 1))
3834     return;
3835
3836   clist_row = ROW_ELEMENT (clist, row)->data;
3837
3838   if (clist_row->state == GTK_STATE_SELECTED)
3839     {
3840       clist_row->state = GTK_STATE_NORMAL;
3841
3842       if (clist->selection_end &&
3843           clist->selection_end->data == GINT_TO_POINTER (row))
3844         clist->selection_end = clist->selection_end->prev;
3845
3846       clist->selection = g_list_remove (clist->selection,
3847                                         GINT_TO_POINTER (row));
3848
3849       if (CLIST_UNFROZEN (clist)
3850           && (gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
3851         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
3852     }
3853 }
3854
3855 static void
3856 real_select_all (GtkCMCList *clist)
3857 {
3858   g_return_if_fail (GTK_IS_CMCLIST (clist));
3859
3860   if (clist_has_grab (clist))
3861     return;
3862
3863   switch (clist->selection_mode)
3864     {
3865     case GTK_SELECTION_SINGLE:
3866     case GTK_SELECTION_BROWSE:
3867       return;
3868
3869     case GTK_SELECTION_MULTIPLE:
3870       g_list_free (clist->undo_selection);
3871       g_list_free (clist->undo_unselection);
3872       clist->undo_selection = NULL;
3873       clist->undo_unselection = NULL;
3874
3875       if (clist->rows &&
3876           ((GtkCMCListRow *) (clist->row_list->data))->state !=
3877           GTK_STATE_SELECTED)
3878         fake_toggle_row (clist, 0);
3879
3880       clist->anchor_state =  GTK_STATE_SELECTED;
3881       clist->anchor = 0;
3882       clist->drag_pos = 0;
3883       clist->undo_anchor = clist->focus_row;
3884       update_extended_selection (clist, clist->rows);
3885       GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
3886       return;
3887     default:
3888       g_assert_not_reached ();
3889     }
3890 }
3891
3892 static void
3893 real_unselect_all (GtkCMCList *clist)
3894 {
3895   GList *list;
3896   gint i;
3897
3898   g_return_if_fail (GTK_IS_CMCLIST (clist));
3899
3900   if (clist_has_grab (clist))
3901     return;
3902
3903   switch (clist->selection_mode)
3904     {
3905     case GTK_SELECTION_BROWSE:
3906       if (clist->focus_row >= 0)
3907         {
3908           g_signal_emit (G_OBJECT (clist),
3909                            clist_signals[SELECT_ROW], 0,
3910                            clist->focus_row, -1, NULL);
3911           return;
3912         }
3913       break;
3914     case GTK_SELECTION_MULTIPLE:
3915       g_list_free (clist->undo_selection);
3916       g_list_free (clist->undo_unselection);
3917       clist->undo_selection = NULL;
3918       clist->undo_unselection = NULL;
3919
3920       clist->anchor = -1;
3921       clist->drag_pos = -1;
3922       clist->undo_anchor = clist->focus_row;
3923       break;
3924     default:
3925       break;
3926     }
3927
3928   list = clist->selection;
3929   while (list)
3930     {
3931       i = GPOINTER_TO_INT (list->data);
3932       list = list->next;
3933       g_signal_emit (G_OBJECT (clist),
3934                        clist_signals[UNSELECT_ROW], 0, i, -1, NULL);
3935     }
3936 }
3937
3938 static void
3939 fake_unselect_all (GtkCMCList *clist,
3940                    gint      row)
3941 {
3942   GList *list;
3943   GList *work;
3944   gint i;
3945
3946   if (row >= 0 && (work = ROW_ELEMENT (clist, row)))
3947     {
3948       if (GTK_CMCLIST_ROW (work)->state == GTK_STATE_NORMAL &&
3949           GTK_CMCLIST_ROW (work)->selectable)
3950         {
3951           GTK_CMCLIST_ROW (work)->state = GTK_STATE_SELECTED;
3952
3953           if (CLIST_UNFROZEN (clist) &&
3954               gtk_cmclist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
3955             GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
3956                                                   GTK_CMCLIST_ROW (work));
3957         }
3958     }
3959
3960   clist->undo_selection = clist->selection;
3961   clist->selection = NULL;
3962   clist->selection_end = NULL;
3963
3964   for (list = clist->undo_selection; list; list = list->next)
3965     {
3966       if ((i = GPOINTER_TO_INT (list->data)) == row ||
3967           !(work = g_list_nth (clist->row_list, i)))
3968         continue;
3969
3970       GTK_CMCLIST_ROW (work)->state = GTK_STATE_NORMAL;
3971       if (CLIST_UNFROZEN (clist) &&
3972           gtk_cmclist_row_is_visible (clist, i) != GTK_VISIBILITY_NONE)
3973         GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, NULL, i,
3974                                               GTK_CMCLIST_ROW (work));
3975     }
3976 }
3977
3978 static void
3979 real_undo_selection (GtkCMCList *clist)
3980 {
3981   GList *work;
3982
3983   g_return_if_fail (GTK_IS_CMCLIST (clist));
3984
3985   if (clist_has_grab (clist) ||
3986       clist->selection_mode != GTK_SELECTION_MULTIPLE)
3987     return;
3988
3989   GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
3990
3991   if (!(clist->undo_selection || clist->undo_unselection))
3992     {
3993       gtk_cmclist_unselect_all (clist);
3994       return;
3995     }
3996
3997   for (work = clist->undo_selection; work; work = work->next)
3998     g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
3999                      GPOINTER_TO_INT (work->data), -1, NULL);
4000
4001   for (work = clist->undo_unselection; work; work = work->next)
4002     {
4003       /* g_print ("unselect %d\n",GPOINTER_TO_INT (work->data)); */
4004       g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
4005                        GPOINTER_TO_INT (work->data), -1, NULL);
4006     }
4007
4008   if (GTK_WIDGET_HAS_FOCUS(clist) && clist->focus_row != clist->undo_anchor)
4009     {
4010       gtk_cmclist_draw_focus (GTK_WIDGET (clist));
4011       clist->focus_row = clist->undo_anchor;
4012       gtk_cmclist_draw_focus (GTK_WIDGET (clist));
4013     }
4014   else
4015     clist->focus_row = clist->undo_anchor;
4016
4017   clist->undo_anchor = -1;
4018
4019   g_list_free (clist->undo_selection);
4020   g_list_free (clist->undo_unselection);
4021   clist->undo_selection = NULL;
4022   clist->undo_unselection = NULL;
4023
4024   if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
4025       clist->clist_window_height)
4026     gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
4027   else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
4028     gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
4029 }
4030
4031 static void
4032 set_anchor (GtkCMCList *clist,
4033             gboolean  add_mode,
4034             gint      anchor,
4035             gint      undo_anchor)
4036 {
4037   g_return_if_fail (GTK_IS_CMCLIST (clist));
4038
4039   if (clist->selection_mode != GTK_SELECTION_MULTIPLE || clist->anchor >= 0)
4040     return;
4041
4042   g_list_free (clist->undo_selection);
4043   g_list_free (clist->undo_unselection);
4044   clist->undo_selection = NULL;
4045   clist->undo_unselection = NULL;
4046
4047   if (add_mode)
4048     fake_toggle_row (clist, anchor);
4049   else
4050     {
4051       GTK_CMCLIST_GET_CLASS (clist)->fake_unselect_all (clist, anchor);
4052       clist->anchor_state = GTK_STATE_SELECTED;
4053     }
4054
4055   clist->anchor = anchor;
4056   clist->drag_pos = anchor;
4057   clist->undo_anchor = undo_anchor;
4058 }
4059
4060 static void
4061 resync_selection (GtkCMCList *clist,
4062                   GdkEvent *event)
4063 {
4064   gint i;
4065   gint e;
4066   gint row;
4067   GList *list;
4068   GtkCMCListRow *clist_row;
4069
4070   if (clist->selection_mode != GTK_SELECTION_MULTIPLE)
4071     return;
4072
4073   if (clist->anchor < 0 || clist->drag_pos < 0)
4074     return;
4075
4076   gtk_cmclist_freeze (clist);
4077
4078   i = MIN (clist->anchor, clist->drag_pos);
4079   e = MAX (clist->anchor, clist->drag_pos);
4080
4081   if (clist->undo_selection)
4082     {
4083       list = clist->selection;
4084       clist->selection = clist->undo_selection;
4085       clist->selection_end = g_list_last (clist->selection);
4086       clist->undo_selection = list;
4087       list = clist->selection;
4088       while (list)
4089         {
4090           row = GPOINTER_TO_INT (list->data);
4091           list = list->next;
4092           if (row < i || row > e)
4093             {
4094               clist_row = g_list_nth (clist->row_list, row)->data;
4095               if (clist_row->selectable)
4096                 {
4097                   clist_row->state = GTK_STATE_SELECTED;
4098                   g_signal_emit (G_OBJECT (clist),
4099                                    clist_signals[UNSELECT_ROW], 0,
4100                                    row, -1, event);
4101                   clist->undo_selection = g_list_prepend
4102                     (clist->undo_selection, GINT_TO_POINTER (row));
4103                 }
4104             }
4105         }
4106     }
4107
4108   if (clist->anchor < clist->drag_pos)
4109     {
4110       for (list = g_list_nth (clist->row_list, i); i <= e;
4111            i++, list = list->next)
4112         if (GTK_CMCLIST_ROW (list)->selectable)
4113           {
4114             if (g_list_find (clist->selection, GINT_TO_POINTER(i)))
4115               {
4116                 if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_NORMAL)
4117                   {
4118                     GTK_CMCLIST_ROW (list)->state = GTK_STATE_SELECTED;
4119                     g_signal_emit (G_OBJECT (clist),
4120                                      clist_signals[UNSELECT_ROW], 0,
4121                                      i, -1, event);
4122                     clist->undo_selection =
4123                       g_list_prepend (clist->undo_selection,
4124                                       GINT_TO_POINTER (i));
4125                   }
4126               }
4127             else if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_SELECTED)
4128               {
4129                 GTK_CMCLIST_ROW (list)->state = GTK_STATE_NORMAL;
4130                 clist->undo_unselection =
4131                   g_list_prepend (clist->undo_unselection,
4132                                   GINT_TO_POINTER (i));
4133               }
4134           }
4135     }
4136   else
4137     {
4138       for (list = g_list_nth (clist->row_list, e); i <= e;
4139            e--, list = list->prev)
4140         if (GTK_CMCLIST_ROW (list)->selectable)
4141           {
4142             if (g_list_find (clist->selection, GINT_TO_POINTER(e)))
4143               {
4144                 if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_NORMAL)
4145                   {
4146                     GTK_CMCLIST_ROW (list)->state = GTK_STATE_SELECTED;
4147                     g_signal_emit (G_OBJECT (clist),
4148                                      clist_signals[UNSELECT_ROW], 0,
4149                                      e, -1, event);
4150                     clist->undo_selection =
4151                       g_list_prepend (clist->undo_selection,
4152                                       GINT_TO_POINTER (e));
4153                   }
4154               }
4155             else if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_SELECTED)
4156               {
4157                 GTK_CMCLIST_ROW (list)->state = GTK_STATE_NORMAL;
4158                 clist->undo_unselection =
4159                   g_list_prepend (clist->undo_unselection,
4160                                   GINT_TO_POINTER (e));
4161               }
4162           }
4163     }
4164
4165   clist->undo_unselection = g_list_reverse (clist->undo_unselection);
4166   for (list = clist->undo_unselection; list; list = list->next)
4167     g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
4168                      GPOINTER_TO_INT (list->data), -1, event);
4169
4170   clist->anchor = -1;
4171   clist->drag_pos = -1;
4172
4173   gtk_cmclist_thaw (clist);
4174 }
4175
4176 static void
4177 update_extended_selection (GtkCMCList *clist,
4178                            gint      row)
4179 {
4180   gint i;
4181   GList *list;
4182   GdkRectangle area;
4183   gint s1 = -1;
4184   gint s2 = -1;
4185   gint e1 = -1;
4186   gint e2 = -1;
4187   gint y1 = clist->clist_window_height;
4188   gint y2 = clist->clist_window_height;
4189   gint h1 = 0;
4190   gint h2 = 0;
4191   gint top;
4192
4193   if (clist->selection_mode != GTK_SELECTION_MULTIPLE || clist->anchor == -1)
4194     return;
4195
4196   if (row < 0)
4197     row = 0;
4198   if (row >= clist->rows)
4199     row = clist->rows - 1;
4200
4201   /* extending downwards */
4202   if (row > clist->drag_pos && clist->anchor <= clist->drag_pos)
4203     {
4204       s2 = clist->drag_pos + 1;
4205       e2 = row;
4206     }
4207   /* extending upwards */
4208   else if (row < clist->drag_pos && clist->anchor >= clist->drag_pos)
4209     {
4210       s2 = row;
4211       e2 = clist->drag_pos - 1;
4212     }
4213   else if (row < clist->drag_pos && clist->anchor < clist->drag_pos)
4214     {
4215       e1 = clist->drag_pos;
4216       /* row and drag_pos on different sides of anchor :
4217          take back the selection between anchor and drag_pos,
4218          select between anchor and row */
4219       if (row < clist->anchor)
4220         {
4221           s1 = clist->anchor + 1;
4222           s2 = row;
4223           e2 = clist->anchor - 1;
4224         }
4225       /* take back the selection between anchor and drag_pos */
4226       else
4227         s1 = row + 1;
4228     }
4229   else if (row > clist->drag_pos && clist->anchor > clist->drag_pos)
4230     {
4231       s1 = clist->drag_pos;
4232       /* row and drag_pos on different sides of anchor :
4233          take back the selection between anchor and drag_pos,
4234          select between anchor and row */
4235       if (row > clist->anchor)
4236         {
4237           e1 = clist->anchor - 1;
4238           s2 = clist->anchor + 1;
4239           e2 = row;
4240         }
4241       /* take back the selection between anchor and drag_pos */
4242       else
4243         e1 = row - 1;
4244     }
4245
4246   clist->drag_pos = row;
4247
4248   area.x = 0;
4249   area.width = clist->clist_window_width;
4250
4251   /* restore the elements between s1 and e1 */
4252   if (s1 >= 0)
4253     {
4254       for (i = s1, list = g_list_nth (clist->row_list, i); i <= e1;
4255            i++, list = list->next)
4256         if (GTK_CMCLIST_ROW (list)->selectable)
4257           {
4258             if (GTK_CMCLIST_GET_CLASS (clist)->selection_find (clist, i, list))
4259               GTK_CMCLIST_ROW (list)->state = GTK_STATE_SELECTED;
4260             else
4261               GTK_CMCLIST_ROW (list)->state = GTK_STATE_NORMAL;
4262           }
4263
4264       top = ROW_TOP_YPIXEL (clist, clist->focus_row);
4265
4266       if (top + clist->row_height <= 0)
4267         {
4268           area.y = 0;
4269           area.height = ROW_TOP_YPIXEL (clist, e1) + clist->row_height;
4270           draw_rows (clist, &area);
4271           gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
4272         }
4273       else if (top >= clist->clist_window_height)
4274         {
4275           area.y = ROW_TOP_YPIXEL (clist, s1) - 1;
4276           area.height = clist->clist_window_height - area.y;
4277           draw_rows (clist, &area);
4278           gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
4279         }
4280       else if (top < 0)
4281         gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
4282       else if (top + clist->row_height > clist->clist_window_height)
4283         gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
4284
4285       y1 = ROW_TOP_YPIXEL (clist, s1) - 1;
4286       h1 = (e1 - s1 + 1) * (clist->row_height + CELL_SPACING);
4287     }
4288
4289   /* extend the selection between s2 and e2 */
4290   if (s2 >= 0)
4291     {
4292       for (i = s2, list = g_list_nth (clist->row_list, i); i <= e2;
4293            i++, list = list->next)
4294         if (GTK_CMCLIST_ROW (list)->selectable &&
4295             GTK_CMCLIST_ROW (list)->state != clist->anchor_state)
4296           GTK_CMCLIST_ROW (list)->state = clist->anchor_state;
4297
4298       top = ROW_TOP_YPIXEL (clist, clist->focus_row);
4299
4300       if (top + clist->row_height <= 0)
4301         {
4302           area.y = 0;
4303           area.height = ROW_TOP_YPIXEL (clist, e2) + clist->row_height;
4304           draw_rows (clist, &area);
4305           gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
4306         }
4307       else if (top >= clist->clist_window_height)
4308         {
4309           area.y = ROW_TOP_YPIXEL (clist, s2) - 1;
4310           area.height = clist->clist_window_height - area.y;
4311           draw_rows (clist, &area);
4312           gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
4313         }
4314       else if (top < 0)
4315         gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
4316       else if (top + clist->row_height > clist->clist_window_height)
4317         gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
4318
4319       y2 = ROW_TOP_YPIXEL (clist, s2) - 1;
4320       h2 = (e2 - s2 + 1) * (clist->row_height + CELL_SPACING);
4321     }
4322
4323   area.y = MAX (0, MIN (y1, y2));
4324   if (area.y > clist->clist_window_height)
4325     area.y = 0;
4326   area.height = MIN (clist->clist_window_height, h1 + h2);
4327   if (s1 >= 0 && s2 >= 0)
4328     area.height += (clist->row_height + CELL_SPACING);
4329   draw_rows (clist, &area);
4330 }
4331
4332 static void
4333 start_selection (GtkCMCList *clist)
4334 {
4335   g_return_if_fail (GTK_IS_CMCLIST (clist));
4336
4337   if (clist_has_grab (clist))
4338     return;
4339
4340   set_anchor (clist, GTK_CMCLIST_ADD_MODE(clist), clist->focus_row,
4341               clist->focus_row);
4342 }
4343
4344 static void
4345 end_selection (GtkCMCList *clist)
4346 {
4347   g_return_if_fail (GTK_IS_CMCLIST (clist));
4348
4349   if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) &&
4350       GTK_WIDGET_HAS_FOCUS (clist))
4351     return;
4352
4353   GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
4354 }
4355
4356 static void
4357 extend_selection (GtkCMCList      *clist,
4358                   GtkScrollType  scroll_type,
4359                   gfloat         position,
4360                   gboolean       auto_start_selection)
4361 {
4362   g_return_if_fail (GTK_IS_CMCLIST (clist));
4363
4364   if (clist_has_grab (clist) ||
4365       clist->selection_mode != GTK_SELECTION_MULTIPLE)
4366     return;
4367
4368   if (auto_start_selection)
4369     set_anchor (clist, GTK_CMCLIST_ADD_MODE(clist), clist->focus_row,
4370                 clist->focus_row);
4371   else if (clist->anchor == -1)
4372     return;
4373
4374   move_focus_row (clist, scroll_type, position);
4375
4376   if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
4377       clist->clist_window_height)
4378     gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
4379   else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
4380     gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
4381
4382   update_extended_selection (clist, clist->focus_row);
4383 }
4384
4385 static void
4386 sync_selection (GtkCMCList *clist,
4387                 gint      row,
4388                 gint      mode)
4389 {
4390   GList *list;
4391   gint d;
4392
4393   if (mode == SYNC_INSERT)
4394     d = 1;
4395   else
4396     d = -1;
4397
4398   if (clist->focus_row >= row)
4399     {
4400       if (d > 0 || clist->focus_row > row)
4401         clist->focus_row += d;
4402       if (clist->focus_row == -1 && clist->rows >= 1)
4403         clist->focus_row = 0;
4404       else if (d < 0 && clist->focus_row >= clist->rows - 1)
4405         clist->focus_row = clist->rows - 2;
4406       else if (clist->focus_row >= clist->rows) /* Paranoia */
4407         clist->focus_row = clist->rows - 1;
4408     }
4409
4410   GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
4411
4412   g_list_free (clist->undo_selection);
4413   g_list_free (clist->undo_unselection);
4414   clist->undo_selection = NULL;
4415   clist->undo_unselection = NULL;
4416
4417   clist->anchor = -1;
4418   clist->drag_pos = -1;
4419   clist->undo_anchor = clist->focus_row;
4420
4421   list = clist->selection;
4422
4423   while (list)
4424     {
4425       if (GPOINTER_TO_INT (list->data) >= row)
4426         list->data = ((gchar*) list->data) + d;
4427       list = list->next;
4428     }
4429 }
4430
4431 /* GTKOBJECT
4432  *   gtk_cmclist_destroy
4433  *   gtk_cmclist_finalize
4434  */
4435 static void
4436 gtk_cmclist_destroy (GtkObject *object)
4437 {
4438   gint i;
4439   GtkCMCList *clist;
4440
4441   g_return_if_fail (GTK_IS_CMCLIST (object));
4442
4443   clist = GTK_CMCLIST (object);
4444
4445   /* freeze the list */
4446   clist->freeze_count++;
4447
4448   /* get rid of all the rows */
4449   gtk_cmclist_clear (clist);
4450
4451   /* Since we don't have a _remove method, unparent the children
4452    * instead of destroying them so the focus will be unset properly.
4453    * (For other containers, the _remove method takes care of the
4454    * unparent) The destroy will happen when the refcount drops
4455    * to zero.
4456    */
4457
4458   /* unref adjustments */
4459   if (clist->hadjustment)
4460     {
4461       g_signal_handlers_disconnect_matched(G_OBJECT (clist->hadjustment), G_SIGNAL_MATCH_DATA,
4462                         0, 0, 0, 0, clist);
4463       g_object_unref (G_OBJECT (clist->hadjustment));
4464       clist->hadjustment = NULL;
4465     }
4466   if (clist->vadjustment)
4467     {
4468       g_signal_handlers_disconnect_matched(G_OBJECT (clist->vadjustment), G_SIGNAL_MATCH_DATA,
4469                         0, 0, 0, 0, clist);
4470       g_object_unref (G_OBJECT (clist->vadjustment));
4471       clist->vadjustment = NULL;
4472     }
4473
4474   remove_grab (clist);
4475
4476   /* destroy the column buttons */
4477   for (i = 0; i < clist->columns; i++)
4478     if (clist->column[i].button)
4479       {
4480         gtk_widget_unparent (clist->column[i].button);
4481         clist->column[i].button = NULL;
4482       }
4483
4484   if (GTK_OBJECT_CLASS (parent_class)->destroy)
4485     (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
4486 }
4487
4488 static void
4489 gtk_cmclist_finalize (GObject *object)
4490 {
4491   GtkCMCList *clist;
4492
4493   g_return_if_fail (GTK_IS_CMCLIST (object));
4494
4495   clist = GTK_CMCLIST (object);
4496
4497   columns_delete (clist);
4498
4499 #if !GLIB_CHECK_VERSION(2,10,0)
4500   g_mem_chunk_destroy (clist->cell_mem_chunk);
4501   g_mem_chunk_destroy (clist->row_mem_chunk);
4502 #endif
4503   G_OBJECT_CLASS (parent_class)->finalize (object);
4504 }
4505
4506 /* GTKWIDGET
4507  *   gtk_cmclist_realize
4508  *   gtk_cmclist_unrealize
4509  *   gtk_cmclist_map
4510  *   gtk_cmclist_unmap
4511  *   gtk_cmclist_expose
4512  *   gtk_cmclist_style_set
4513  *   gtk_cmclist_button_press
4514  *   gtk_cmclist_button_release
4515  *   gtk_cmclist_motion
4516  *   gtk_cmclist_size_request
4517  *   gtk_cmclist_size_allocate
4518  */
4519 static void
4520 gtk_cmclist_realize (GtkWidget *widget)
4521 {
4522   GtkCMCList *clist;
4523   GdkWindowAttr attributes;
4524   GdkGCValues values;
4525   GtkCMCListRow *clist_row;
4526   GList *list;
4527   gint attributes_mask;
4528   gint border_width;
4529   gint i;
4530   gint j;
4531
4532   g_return_if_fail (GTK_IS_CMCLIST (widget));
4533
4534   clist = GTK_CMCLIST (widget);
4535
4536   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
4537
4538   border_width = GTK_CONTAINER (widget)->border_width;
4539
4540   attributes.window_type = GDK_WINDOW_CHILD;
4541   attributes.x = widget->allocation.x + border_width;
4542   attributes.y = widget->allocation.y + border_width;
4543   attributes.width = widget->allocation.width - border_width * 2;
4544   attributes.height = widget->allocation.height - border_width * 2;
4545   attributes.wclass = GDK_INPUT_OUTPUT;
4546   attributes.visual = gtk_widget_get_visual (widget);
4547   attributes.colormap = gtk_widget_get_colormap (widget);
4548   attributes.event_mask = gtk_widget_get_events (widget);
4549   attributes.event_mask |= (GDK_EXPOSURE_MASK |
4550                             GDK_BUTTON_PRESS_MASK |
4551                             GDK_BUTTON_RELEASE_MASK |
4552                             GDK_KEY_RELEASE_MASK);
4553   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
4554
4555   /* main window */
4556   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
4557                                    &attributes, attributes_mask);
4558   gdk_window_set_user_data (widget->window, clist);
4559
4560   widget->style = gtk_style_attach (widget->style, widget->window);
4561
4562   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
4563
4564   /* column-title window */
4565
4566   attributes.x = clist->column_title_area.x;
4567   attributes.y = clist->column_title_area.y;
4568   attributes.width = clist->column_title_area.width;
4569   attributes.height = clist->column_title_area.height;
4570
4571   clist->title_window = gdk_window_new (widget->window, &attributes,
4572                                         attributes_mask);
4573   gdk_window_set_user_data (clist->title_window, clist);
4574
4575   gtk_style_set_background (widget->style, clist->title_window,
4576                             GTK_STATE_NORMAL);
4577   gdk_window_show (clist->title_window);
4578
4579   /* set things up so column buttons are drawn in title window */
4580   for (i = 0; i < clist->columns; i++)
4581     if (clist->column[i].button)
4582       gtk_widget_set_parent_window (clist->column[i].button,
4583                                     clist->title_window);
4584
4585   /* clist-window */
4586   attributes.x = (clist->internal_allocation.x +
4587                   widget->style->xthickness);
4588   attributes.y = (clist->internal_allocation.y +
4589                   widget->style->ythickness +
4590                   clist->column_title_area.height);
4591   attributes.width = clist->clist_window_width;
4592   attributes.height = clist->clist_window_height;
4593
4594   clist->clist_window = gdk_window_new (widget->window, &attributes,
4595                                         attributes_mask);
4596   gdk_window_set_user_data (clist->clist_window, clist);
4597
4598   gdk_window_set_background (clist->clist_window,
4599                              &widget->style->base[GTK_STATE_NORMAL]);
4600   gdk_window_show (clist->clist_window);
4601   gdk_drawable_get_size (clist->clist_window, &clist->clist_window_width,
4602                        &clist->clist_window_height);
4603
4604   /* create resize windows */
4605   attributes.wclass = GDK_INPUT_ONLY;
4606   attributes.event_mask = (GDK_BUTTON_PRESS_MASK |
4607                            GDK_BUTTON_RELEASE_MASK |
4608                            GDK_POINTER_MOTION_MASK |
4609                            GDK_POINTER_MOTION_HINT_MASK);
4610   attributes_mask = GDK_WA_CURSOR;
4611   attributes.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
4612                                                   GDK_SB_H_DOUBLE_ARROW);
4613   clist->cursor_drag = attributes.cursor;
4614
4615   attributes.x =  LIST_WIDTH (clist) + 1;
4616   attributes.y = 0;
4617   attributes.width = 0;
4618   attributes.height = 0;
4619
4620   for (i = 0; i < clist->columns; i++)
4621     {
4622       clist->column[i].window = gdk_window_new (clist->title_window,
4623                                                 &attributes, attributes_mask);
4624       gdk_window_set_user_data (clist->column[i].window, clist);
4625     }
4626
4627   /* This is slightly less efficient than creating them with the
4628    * right size to begin with, but easier
4629    */
4630   size_allocate_title_buttons (clist);
4631
4632   /* GCs */
4633   clist->fg_gc = gdk_gc_new (widget->window);
4634   clist->bg_gc = gdk_gc_new (widget->window);
4635
4636   /* We'll use this gc to do scrolling as well */
4637   gdk_gc_set_exposures (clist->fg_gc, TRUE);
4638
4639   values.foreground = (widget->style->white.pixel==0 ?
4640                        widget->style->black:widget->style->white);
4641   values.function = GDK_XOR;
4642   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
4643   clist->xor_gc = gdk_gc_new_with_values (widget->window,
4644                                           &values,
4645                                           GDK_GC_FOREGROUND |
4646                                           GDK_GC_FUNCTION |
4647                                           GDK_GC_SUBWINDOW);
4648
4649   /* attach optional row/cell styles, allocate foreground/background colors */
4650   list = clist->row_list;
4651   for (i = 0; i < clist->rows; i++)
4652     {
4653       clist_row = list->data;
4654       list = list->next;
4655
4656       if (clist_row->style)
4657         clist_row->style = gtk_style_attach (clist_row->style,
4658                                              clist->clist_window);
4659
4660       if (clist_row->fg_set || clist_row->bg_set)
4661         {
4662           GdkColormap *colormap;
4663
4664           colormap = gtk_widget_get_colormap (widget);
4665           if (clist_row->fg_set)
4666             gdk_colormap_alloc_color (colormap, &clist_row->foreground, TRUE, TRUE);
4667           if (clist_row->bg_set)
4668             gdk_colormap_alloc_color (colormap, &clist_row->background, TRUE, TRUE);
4669         }
4670
4671       for (j = 0; j < clist->columns; j++)
4672         if  (clist_row->cell[j].style)
4673           clist_row->cell[j].style =
4674             gtk_style_attach (clist_row->cell[j].style, clist->clist_window);
4675     }
4676 }
4677
4678 static void
4679 gtk_cmclist_unrealize (GtkWidget *widget)
4680 {
4681   gint i;
4682   GtkCMCList *clist;
4683
4684   g_return_if_fail (GTK_IS_CMCLIST (widget));
4685
4686   clist = GTK_CMCLIST (widget);
4687
4688   /* freeze the list */
4689   clist->freeze_count++;
4690
4691   if (GTK_WIDGET_MAPPED (widget))
4692     gtk_cmclist_unmap (widget);
4693
4694   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
4695
4696   /* detach optional row/cell styles */
4697   if (GTK_WIDGET_REALIZED (widget))
4698     {
4699       GtkCMCListRow *clist_row;
4700       GList *list;
4701       gint j;
4702
4703       list = clist->row_list;
4704       for (i = 0; i < clist->rows; i++)
4705         {
4706           clist_row = list->data;
4707           list = list->next;
4708
4709           if (clist_row->style)
4710             gtk_style_detach (clist_row->style);
4711           for (j = 0; j < clist->columns; j++)
4712             if  (clist_row->cell[j].style)
4713               gtk_style_detach (clist_row->cell[j].style);
4714         }
4715     }
4716
4717   gdk_cursor_unref (clist->cursor_drag);
4718   g_object_unref (clist->xor_gc);
4719   g_object_unref (clist->fg_gc);
4720   g_object_unref (clist->bg_gc);
4721
4722   for (i = 0; i < clist->columns; i++)
4723     {
4724       if (clist->column[i].button)
4725         gtk_widget_unrealize (clist->column[i].button);
4726       if (clist->column[i].window)
4727         {
4728           gdk_window_set_user_data (clist->column[i].window, NULL);
4729           gdk_window_destroy (clist->column[i].window);
4730           clist->column[i].window = NULL;
4731         }
4732     }
4733
4734   gdk_window_set_user_data (clist->clist_window, NULL);
4735   gdk_window_destroy (clist->clist_window);
4736   clist->clist_window = NULL;
4737
4738   gdk_window_set_user_data (clist->title_window, NULL);
4739   gdk_window_destroy (clist->title_window);
4740   clist->title_window = NULL;
4741
4742   clist->cursor_drag = NULL;
4743   clist->xor_gc = NULL;
4744   clist->fg_gc = NULL;
4745   clist->bg_gc = NULL;
4746
4747   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
4748     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
4749 }
4750
4751 static void
4752 gtk_cmclist_map (GtkWidget *widget)
4753 {
4754   gint i;
4755   GtkCMCList *clist;
4756
4757   g_return_if_fail (GTK_IS_CMCLIST (widget));
4758
4759   clist = GTK_CMCLIST (widget);
4760
4761   if (!GTK_WIDGET_MAPPED (widget))
4762     {
4763       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
4764
4765       /* map column buttons */
4766       for (i = 0; i < clist->columns; i++)
4767         {
4768           if (clist->column[i].button &&
4769               GTK_WIDGET_VISIBLE (clist->column[i].button) &&
4770               !GTK_WIDGET_MAPPED (clist->column[i].button))
4771             gtk_widget_map (clist->column[i].button);
4772         }
4773
4774       for (i = 0; i < clist->columns; i++)
4775         if (clist->column[i].window && clist->column[i].button)
4776           {
4777             gdk_window_raise (clist->column[i].window);
4778             gdk_window_show (clist->column[i].window);
4779           }
4780
4781       gdk_window_show (clist->title_window);
4782       gdk_window_show (clist->clist_window);
4783       gdk_window_show (widget->window);
4784
4785       /* unfreeze the list */
4786       clist->freeze_count = 0;
4787     }
4788 }
4789
4790 static void
4791 gtk_cmclist_unmap (GtkWidget *widget)
4792 {
4793   gint i;
4794   GtkCMCList *clist;
4795
4796   g_return_if_fail (GTK_IS_CMCLIST (widget));
4797
4798   clist = GTK_CMCLIST (widget);
4799
4800   if (GTK_WIDGET_MAPPED (widget))
4801     {
4802       GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
4803
4804       if (clist_has_grab (clist))
4805         {
4806           remove_grab (clist);
4807
4808           GTK_CMCLIST_GET_CLASS (widget)->resync_selection (clist, NULL);
4809
4810           clist->click_cell.row = -1;
4811           clist->click_cell.column = -1;
4812           clist->drag_button = 0;
4813
4814           if (GTK_CMCLIST_IN_DRAG(clist))
4815             {
4816               gpointer drag_data;
4817
4818               GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_IN_DRAG);
4819               drag_data = g_object_get_data (G_OBJECT (clist),
4820                                                "gtk-site-data");
4821               if (drag_data)
4822                 g_signal_handlers_unblock_matched(G_OBJECT(clist), G_SIGNAL_MATCH_DATA,
4823                                         0, 0, 0, 0, drag_data);
4824             }
4825         }
4826
4827       for (i = 0; i < clist->columns; i++)
4828         if (clist->column[i].window)
4829           gdk_window_hide (clist->column[i].window);
4830
4831       gdk_window_hide (clist->clist_window);
4832       gdk_window_hide (clist->title_window);
4833       gdk_window_hide (widget->window);
4834
4835       /* unmap column buttons */
4836       for (i = 0; i < clist->columns; i++)
4837         if (clist->column[i].button &&
4838             GTK_WIDGET_MAPPED (clist->column[i].button))
4839           gtk_widget_unmap (clist->column[i].button);
4840
4841       /* freeze the list */
4842       clist->freeze_count++;
4843     }
4844 }
4845
4846 static gint
4847 gtk_cmclist_expose (GtkWidget      *widget,
4848                   GdkEventExpose *event)
4849 {
4850   GtkCMCList *clist;
4851
4852   g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
4853   g_return_val_if_fail (event != NULL, FALSE);
4854
4855   if (GTK_WIDGET_DRAWABLE (widget))
4856     {
4857       clist = GTK_CMCLIST (widget);
4858
4859       /* draw border */
4860       if (event->window == widget->window)
4861         gtk_paint_shadow (widget->style, widget->window,
4862                          GTK_STATE_NORMAL, clist->shadow_type,
4863                          NULL, NULL, NULL,
4864                          0, 0,
4865                          clist->clist_window_width +
4866                          (2 * widget->style->xthickness),
4867                          clist->clist_window_height +
4868                          (2 * widget->style->ythickness) +
4869                          clist->column_title_area.height);
4870
4871       /* exposure events on the list */
4872       if (event->window == clist->clist_window)
4873         draw_rows (clist, &event->area);
4874
4875       if (event->window == clist->clist_window &&
4876           clist->drag_highlight_row >= 0)
4877         GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
4878           (clist, g_list_nth (clist->row_list,
4879                               clist->drag_highlight_row)->data,
4880            clist->drag_highlight_row, clist->drag_highlight_pos);
4881
4882       if (event->window == clist->title_window)
4883         {
4884           gint i;
4885
4886           for (i = 0; i < clist->columns; i++)
4887             {
4888               if (clist->column[i].button)
4889                 gtk_container_propagate_expose (GTK_CONTAINER (clist),
4890                                                 clist->column[i].button,
4891                                                 event);
4892             }
4893         }
4894     }
4895
4896   return FALSE;
4897 }
4898
4899 static void
4900 gtk_cmclist_style_set (GtkWidget *widget,
4901                      GtkStyle  *previous_style)
4902 {
4903   GtkCMCList *clist;
4904
4905   g_return_if_fail (GTK_IS_CMCLIST (widget));
4906
4907   if (GTK_WIDGET_CLASS (parent_class)->style_set)
4908     (*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
4909
4910   clist = GTK_CMCLIST (widget);
4911
4912   if (GTK_WIDGET_REALIZED (widget))
4913     {
4914       gtk_style_set_background (widget->style, widget->window, widget->state);
4915       gtk_style_set_background (widget->style, clist->title_window, GTK_STATE_NORMAL);
4916       gdk_window_set_background (clist->clist_window, &widget->style->base[GTK_STATE_NORMAL]);
4917     }
4918
4919   /* Fill in data after widget has correct style */
4920
4921   /* text properties */
4922   if (!GTK_CMCLIST_ROW_HEIGHT_SET(clist))
4923     /* Reset clist->row_height */
4924     gtk_cmclist_set_row_height (clist, 0);
4925
4926   /* Column widths */
4927   if (!GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
4928     {
4929       gint width;
4930       gint i;
4931
4932       for (i = 0; i < clist->columns; i++)
4933         if (clist->column[i].auto_resize)
4934           {
4935             width = gtk_cmclist_optimal_column_width (clist, i);
4936             if (width != clist->column[i].width)
4937               gtk_cmclist_set_column_width (clist, i, width);
4938           }
4939     }
4940 }
4941
4942 static gint
4943 gtk_cmclist_button_press (GtkWidget      *widget,
4944                         GdkEventButton *event)
4945 {
4946   gint i;
4947   GtkCMCList *clist;
4948   gint x;
4949   gint y;
4950   gint row;
4951   gint column;
4952   gint button_actions;
4953
4954   g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
4955   g_return_val_if_fail (event != NULL, FALSE);
4956
4957   clist = GTK_CMCLIST (widget);
4958
4959   button_actions = clist->button_actions[event->button - 1];
4960
4961   if (button_actions == GTK_CMBUTTON_IGNORED)
4962     return FALSE;
4963
4964   /* selections on the list */
4965   if (event->window == clist->clist_window)
4966     {
4967       x = event->x;
4968       y = event->y;
4969
4970       if (get_selection_info (clist, x, y, &row, &column))
4971         {
4972           gint old_row = clist->focus_row;
4973
4974           if (clist->focus_row == -1)
4975             old_row = row;
4976
4977           if (event->type == GDK_BUTTON_PRESS)
4978             {
4979               GdkEventMask mask = ((1 << (4 + event->button)) |
4980                                    GDK_POINTER_MOTION_HINT_MASK |
4981                                    GDK_BUTTON_RELEASE_MASK);
4982
4983               if (gdk_pointer_grab (clist->clist_window, FALSE, mask,
4984                                     NULL, NULL, event->time))
4985                 return FALSE;
4986               gtk_grab_add (widget);
4987
4988               clist->click_cell.row = row;
4989               clist->click_cell.column = column;
4990               clist->drag_button = event->button;
4991             }
4992           else
4993             {
4994               clist->click_cell.row = -1;
4995               clist->click_cell.column = -1;
4996
4997               clist->drag_button = 0;
4998               remove_grab (clist);
4999             }
5000
5001           if (button_actions & GTK_CMBUTTON_SELECTS)
5002             {
5003               if (GTK_CMCLIST_ADD_MODE(clist))
5004                 {
5005                   GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_ADD_MODE);
5006                   if (GTK_WIDGET_HAS_FOCUS(widget))
5007                     {
5008                       gtk_cmclist_draw_focus (widget);
5009                       gdk_gc_set_line_attributes (clist->xor_gc, 1,
5010                                                   GDK_LINE_SOLID, 0, 0);
5011                       clist->focus_row = row;
5012                       gtk_cmclist_draw_focus (widget);
5013                     }
5014                   else
5015                     {
5016                       gdk_gc_set_line_attributes (clist->xor_gc, 1,
5017                                                   GDK_LINE_SOLID, 0, 0);
5018                       clist->focus_row = row;
5019                     }
5020                 }
5021               else if (row != clist->focus_row)
5022                 {
5023                   if (GTK_WIDGET_HAS_FOCUS(widget))
5024                     {
5025                       gtk_cmclist_draw_focus (widget);
5026                       clist->focus_row = row;
5027                       gtk_cmclist_draw_focus (widget);
5028                     }
5029                   else
5030                     clist->focus_row = row;
5031                 }
5032             }
5033
5034           if (!GTK_WIDGET_HAS_FOCUS(widget))
5035             gtk_widget_grab_focus (widget);
5036
5037           if (button_actions & GTK_CMBUTTON_SELECTS)
5038             {
5039               switch (clist->selection_mode)
5040                 {
5041                 case GTK_SELECTION_SINGLE:
5042                   if (event->type != GDK_BUTTON_PRESS)
5043                     {
5044                       g_signal_emit (G_OBJECT (clist),
5045                                        clist_signals[SELECT_ROW], 0,
5046                                        row, column, event);
5047                       clist->anchor = -1;
5048                     }
5049                   else
5050                     clist->anchor = row;
5051                   break;
5052                 case GTK_SELECTION_BROWSE:
5053                   g_signal_emit (G_OBJECT (clist),
5054                                    clist_signals[SELECT_ROW], 0,
5055                                    row, column, event);
5056                   break;
5057                 case GTK_SELECTION_MULTIPLE:
5058                   if (event->type != GDK_BUTTON_PRESS)
5059                     {
5060                       if (clist->anchor != -1)
5061                         {
5062                           update_extended_selection (clist, clist->focus_row);
5063                           GTK_CMCLIST_GET_CLASS (clist)->resync_selection
5064                             (clist, (GdkEvent *) event);
5065                         }
5066                       g_signal_emit (G_OBJECT (clist),
5067                                        clist_signals[SELECT_ROW], 0,
5068                                        row, column, event);
5069                       break;
5070                     }
5071
5072                   if (event->state & GDK_CONTROL_MASK)
5073                     {
5074                       if (event->state & GDK_SHIFT_MASK)
5075                         {
5076                           if (clist->anchor < 0)
5077                             {
5078                               g_list_free (clist->undo_selection);
5079                               g_list_free (clist->undo_unselection);
5080                               clist->undo_selection = NULL;
5081                               clist->undo_unselection = NULL;
5082                               clist->anchor = old_row;
5083                               clist->drag_pos = old_row;
5084                               clist->undo_anchor = old_row;
5085                             }
5086                           update_extended_selection (clist, clist->focus_row);
5087                         }
5088                       else
5089                         {
5090                           if (clist->anchor == -1)
5091                             set_anchor (clist, TRUE, row, old_row);
5092                           else
5093                             update_extended_selection (clist,
5094                                                        clist->focus_row);
5095                         }
5096                       break;
5097                     }
5098
5099                   if (event->state & GDK_SHIFT_MASK)
5100                     {
5101                       set_anchor (clist, FALSE, old_row, old_row);
5102                       update_extended_selection (clist, clist->focus_row);
5103                       break;
5104                     }
5105
5106                   if (clist->anchor == -1)
5107                     set_anchor (clist, FALSE, row, old_row);
5108                   else
5109                     update_extended_selection (clist, clist->focus_row);
5110                   break;
5111                 default:
5112                   break;
5113                 }
5114             }
5115         }
5116       return TRUE;
5117     }
5118
5119   /* press on resize windows */
5120   for (i = 0; i < clist->columns; i++)
5121     if (clist->column[i].resizeable && clist->column[i].window &&
5122         event->window == clist->column[i].window)
5123       {
5124         gpointer drag_data;
5125
5126         if (gdk_pointer_grab (clist->column[i].window, FALSE,
5127                               GDK_POINTER_MOTION_HINT_MASK |
5128                               GDK_BUTTON1_MOTION_MASK |
5129                               GDK_BUTTON_RELEASE_MASK,
5130                               NULL, NULL, event->time))
5131           return FALSE;
5132
5133         gtk_grab_add (widget);
5134         GTK_CMCLIST_SET_FLAG (clist, CMCLIST_IN_DRAG);
5135
5136         /* block attached dnd signal handler */
5137         drag_data = g_object_get_data (G_OBJECT (clist), "gtk-site-data");
5138         if (drag_data)
5139                 g_signal_handlers_block_matched(G_OBJECT(clist), G_SIGNAL_MATCH_DATA,
5140                                         0, 0, 0, 0, drag_data);
5141
5142         if (!GTK_WIDGET_HAS_FOCUS(widget))
5143           gtk_widget_grab_focus (widget);
5144
5145         clist->drag_pos = i;
5146         clist->x_drag = (COLUMN_LEFT_XPIXEL(clist, i) + COLUMN_INSET +
5147                          clist->column[i].area.width + CELL_SPACING);
5148
5149         if (GTK_CMCLIST_ADD_MODE(clist))
5150           gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_SOLID, 0, 0);
5151         draw_xor_line (clist);
5152
5153         return TRUE;
5154       }
5155
5156   return FALSE;
5157 }
5158
5159 static gint
5160 gtk_cmclist_button_release (GtkWidget      *widget,
5161                           GdkEventButton *event)
5162 {
5163   GtkCMCList *clist;
5164   gint button_actions;
5165
5166   g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
5167   g_return_val_if_fail (event != NULL, FALSE);
5168
5169   clist = GTK_CMCLIST (widget);
5170
5171   button_actions = clist->button_actions[event->button - 1];
5172   if (button_actions == GTK_CMBUTTON_IGNORED)
5173     return FALSE;
5174
5175   /* release on resize windows */
5176   if (GTK_CMCLIST_IN_DRAG(clist))
5177     {
5178       gpointer drag_data;
5179       gint width;
5180       gint x;
5181       gint i;
5182
5183       i = clist->drag_pos;
5184       clist->drag_pos = -1;
5185
5186       /* unblock attached dnd signal handler */
5187       drag_data = g_object_get_data (G_OBJECT (clist), "gtk-site-data");
5188       if (drag_data)
5189                 g_signal_handlers_unblock_matched(G_OBJECT(clist), G_SIGNAL_MATCH_DATA,
5190                                         0, 0, 0, 0, drag_data);
5191
5192       GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_IN_DRAG);
5193       gtk_widget_get_pointer (widget, &x, NULL);
5194       gtk_grab_remove (widget);
5195       gdk_display_pointer_ungrab (gtk_widget_get_display (widget), event->time);
5196
5197       if (clist->x_drag >= 0)
5198         draw_xor_line (clist);
5199
5200       if (GTK_CMCLIST_ADD_MODE(clist))
5201         {
5202           gdk_gc_set_line_attributes (clist->xor_gc, 1,
5203                                       GDK_LINE_ON_OFF_DASH, 0, 0);
5204           gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
5205         }
5206
5207       width = new_column_width (clist, i, &x);
5208       gtk_cmclist_set_column_width (clist, i, width);
5209
5210       return TRUE;
5211     }
5212
5213   if (clist->drag_button == event->button)
5214     {
5215       gint row;
5216       gint column;
5217
5218       clist->drag_button = 0;
5219       clist->click_cell.row = -1;
5220       clist->click_cell.column = -1;
5221
5222       remove_grab (clist);
5223
5224       if (button_actions & GTK_CMBUTTON_SELECTS)
5225         {
5226           switch (clist->selection_mode)
5227             {
5228             case GTK_SELECTION_MULTIPLE:
5229               if (!(event->state & GDK_SHIFT_MASK) ||
5230                   !GTK_WIDGET_CAN_FOCUS (widget) ||
5231                   event->x < 0 || event->x >= clist->clist_window_width ||
5232                   event->y < 0 || event->y >= clist->clist_window_height)
5233                 GTK_CMCLIST_GET_CLASS (clist)->resync_selection
5234                   (clist, (GdkEvent *) event);
5235               break;
5236             case GTK_SELECTION_SINGLE:
5237               if (get_selection_info (clist, event->x, event->y,
5238                                       &row, &column))
5239                 {
5240                   if (row >= 0 && row < clist->rows && clist->anchor == row)
5241                     toggle_row (clist, row, column, (GdkEvent *) event);
5242                 }
5243               clist->anchor = -1;
5244               break;
5245             default:
5246               break;
5247             }
5248         }
5249
5250       return TRUE;
5251     }
5252
5253   return FALSE;
5254 }
5255
5256 static gint
5257 gtk_cmclist_motion (GtkWidget      *widget,
5258                   GdkEventMotion *event)
5259 {
5260   GtkCMCList *clist;
5261   gint x;
5262   gint y;
5263   gint row;
5264   gint new_width;
5265   gint button_actions = 0;
5266
5267   g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
5268
5269   clist = GTK_CMCLIST (widget);
5270   if (!clist_has_grab (clist))
5271     return FALSE;
5272
5273   if (clist->drag_button > 0)
5274     button_actions = clist->button_actions[clist->drag_button - 1];
5275
5276   if (GTK_CMCLIST_IN_DRAG(clist))
5277     {
5278       if (event->is_hint || event->window != widget->window)
5279         gtk_widget_get_pointer (widget, &x, NULL);
5280       else
5281         x = event->x;
5282
5283       new_width = new_column_width (clist, clist->drag_pos, &x);
5284       if (x != clist->x_drag)
5285         {
5286           /* x_drag < 0 indicates that the xor line is already invisible */
5287           if (clist->x_drag >= 0)
5288             draw_xor_line (clist);
5289
5290           clist->x_drag = x;
5291
5292           if (clist->x_drag >= 0)
5293             draw_xor_line (clist);
5294         }
5295
5296       if (new_width <= MAX (COLUMN_MIN_WIDTH + 1,
5297                             clist->column[clist->drag_pos].min_width + 1))
5298         {
5299           if (COLUMN_LEFT_XPIXEL (clist, clist->drag_pos) < 0 && x < 0)
5300             gtk_cmclist_moveto (clist, -1, clist->drag_pos, 0, 0);
5301           return FALSE;
5302         }
5303       if (clist->column[clist->drag_pos].max_width >= COLUMN_MIN_WIDTH &&
5304           new_width >= clist->column[clist->drag_pos].max_width)
5305         {
5306           if (COLUMN_LEFT_XPIXEL (clist, clist->drag_pos) + new_width >
5307               clist->clist_window_width && x < 0)
5308             move_horizontal (clist,
5309                              COLUMN_LEFT_XPIXEL (clist, clist->drag_pos) +
5310                              new_width - clist->clist_window_width +
5311                              COLUMN_INSET + CELL_SPACING);
5312           return FALSE;
5313         }
5314     }
5315
5316   if (event->is_hint || event->window != clist->clist_window)
5317     gdk_window_get_pointer (clist->clist_window, &x, &y, NULL);
5318   else
5319     {
5320       x = event->x;
5321       y = event->y;
5322     }
5323
5324   if (GTK_CMCLIST_REORDERABLE(clist) && button_actions & GTK_CMBUTTON_DRAGS)
5325     {
5326       /* delayed drag start */
5327       if (event->window == clist->clist_window &&
5328           clist->click_cell.row >= 0 && clist->click_cell.column >= 0 &&
5329           (y < 0 || y >= clist->clist_window_height ||
5330            x < 0 || x >= clist->clist_window_width  ||
5331            y < ROW_TOP_YPIXEL (clist, clist->click_cell.row) ||
5332            y >= (ROW_TOP_YPIXEL (clist, clist->click_cell.row) +
5333                  clist->row_height) ||
5334            x < COLUMN_LEFT_XPIXEL (clist, clist->click_cell.column) ||
5335            x >= (COLUMN_LEFT_XPIXEL(clist, clist->click_cell.column) +
5336                  clist->column[clist->click_cell.column].area.width)))
5337         {
5338           GtkTargetList  *target_list;
5339
5340           target_list = gtk_target_list_new (&clist_target_table, 1);
5341           gtk_drag_begin (widget, target_list, GDK_ACTION_MOVE,
5342                           clist->drag_button, (GdkEvent *)event);
5343
5344         }
5345       return TRUE;
5346     }
5347
5348   /* horizontal autoscrolling */
5349   if (clist->hadjustment && LIST_WIDTH (clist) > clist->clist_window_width &&
5350       (x < 0 || x >= clist->clist_window_width))
5351     {
5352       if (clist->htimer)
5353         return FALSE;
5354
5355 #if GTK_CHECK_VERSION(2,12,0)
5356       clist->htimer = gdk_threads_add_timeout
5357         (SCROLL_TIME, (GSourceFunc) horizontal_timeout, clist);
5358 #else
5359       clist->htimer = g_timeout_add
5360         (SCROLL_TIME, (GSourceFunc) horizontal_timeout, clist);
5361 #endif
5362       if (!((x < 0 && clist->hadjustment->value == 0) ||
5363             (x >= clist->clist_window_width &&
5364              clist->hadjustment->value ==
5365              LIST_WIDTH (clist) - clist->clist_window_width)))
5366         {
5367           if (x < 0)
5368             move_horizontal (clist, -1 + (x/2));
5369           else
5370             move_horizontal (clist, 1 + (x - clist->clist_window_width) / 2);
5371         }
5372     }
5373
5374   if (GTK_CMCLIST_IN_DRAG(clist))
5375     return FALSE;
5376
5377   /* vertical autoscrolling */
5378   row = ROW_FROM_YPIXEL (clist, y);
5379
5380   /* don't scroll on last pixel row if it's a cell spacing */
5381   if (y == clist->clist_window_height - 1 &&
5382       y == ROW_TOP_YPIXEL (clist, row-1) + clist->row_height)
5383     return FALSE;
5384
5385   if (LIST_HEIGHT (clist) > clist->clist_window_height &&
5386       (y < 0 || y >= clist->clist_window_height))
5387     {
5388       if (clist->vtimer)
5389         return FALSE;
5390 #if GTK_CHECK_VERSION(2,12,0)
5391       clist->vtimer = gdk_threads_add_timeout (SCROLL_TIME,
5392                                      (GSourceFunc) vertical_timeout, clist);
5393 #else
5394       clist->vtimer = g_timeout_add (SCROLL_TIME,
5395                                      (GSourceFunc) vertical_timeout, clist);
5396 #endif
5397       if (clist->drag_button &&
5398           ((y < 0 && clist->focus_row == 0) ||
5399            (y >= clist->clist_window_height &&
5400             clist->focus_row == clist->rows - 1)))
5401         return FALSE;
5402     }
5403
5404   row = CLAMP (row, 0, clist->rows - 1);
5405
5406   if (button_actions & GTK_CMBUTTON_SELECTS &
5407       !g_object_get_data (G_OBJECT (widget), "gtk-site-data"))
5408     {
5409       if (row == clist->focus_row)
5410         return FALSE;
5411
5412       gtk_cmclist_draw_focus (widget);
5413       clist->focus_row = row;
5414       gtk_cmclist_draw_focus (widget);
5415
5416       switch (clist->selection_mode)
5417         {
5418         case GTK_SELECTION_BROWSE:
5419           g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
5420                            clist->focus_row, -1, event);
5421           break;
5422         case GTK_SELECTION_MULTIPLE:
5423           update_extended_selection (clist, clist->focus_row);
5424           break;
5425         default:
5426           break;
5427         }
5428     }
5429
5430   if (ROW_TOP_YPIXEL(clist, row) < 0)
5431     move_vertical (clist, row, 0);
5432   else if (ROW_TOP_YPIXEL(clist, row) + clist->row_height >
5433            clist->clist_window_height)
5434     move_vertical (clist, row, 1);
5435
5436   return FALSE;
5437 }
5438
5439 static void
5440 gtk_cmclist_size_request (GtkWidget      *widget,
5441                         GtkRequisition *requisition)
5442 {
5443   GtkCMCList *clist;
5444   gint i;
5445   gint font_height = 0;
5446   g_return_if_fail (GTK_IS_CMCLIST (widget));
5447   g_return_if_fail (requisition != NULL);
5448
5449   clist = GTK_CMCLIST (widget);
5450
5451   requisition->width = 0;
5452   requisition->height = 0;
5453
5454   /* compute the size of the column title (title) area */
5455   clist->column_title_area.height = 0;
5456   if (GTK_CMCLIST_SHOW_TITLES(clist)) {
5457     font_height = (pango_font_description_get_size((GTK_WIDGET(clist)->style)->font_desc)/PANGO_SCALE)*2+4;
5458     for (i = 0; i < clist->columns; i++)
5459       if (clist->column[i].button)
5460         {
5461           GtkRequisition child_requisition;
5462
5463           gtk_widget_size_request (clist->column[i].button,
5464                                    &child_requisition);
5465           clist->column_title_area.height =
5466             MAX (clist->column_title_area.height,
5467                  child_requisition.height - 2);
5468         }
5469     clist->column_title_area.height = font_height;
5470   }
5471   requisition->width += (widget->style->xthickness +
5472                          GTK_CONTAINER (widget)->border_width) * 2;
5473   requisition->height += (clist->column_title_area.height +
5474                           (widget->style->ythickness +
5475                            GTK_CONTAINER (widget)->border_width) * 2);
5476
5477   /* if (!clist->hadjustment) */
5478   requisition->width += list_requisition_width (clist);
5479   /* if (!clist->vadjustment) */
5480   requisition->height += LIST_HEIGHT (clist);
5481 }
5482
5483 static void
5484 gtk_cmclist_size_allocate (GtkWidget     *widget,
5485                          GtkAllocation *allocation)
5486 {
5487   GtkCMCList *clist;
5488   GtkAllocation clist_allocation;
5489   gint border_width;
5490
5491   g_return_if_fail (GTK_IS_CMCLIST (widget));
5492   g_return_if_fail (allocation != NULL);
5493
5494   clist = GTK_CMCLIST (widget);
5495   widget->allocation = *allocation;
5496   border_width = GTK_CONTAINER (widget)->border_width;
5497
5498   if (GTK_WIDGET_REALIZED (widget))
5499     {
5500       gdk_window_move_resize (widget->window,
5501                               allocation->x + border_width,
5502                               allocation->y + border_width,
5503                               allocation->width - border_width * 2,
5504                               allocation->height - border_width * 2);
5505     }
5506
5507   /* use internal allocation structure for all the math
5508    * because it's easier than always subtracting the container
5509    * border width */
5510   clist->internal_allocation.x = 0;
5511   clist->internal_allocation.y = 0;
5512   clist->internal_allocation.width = MAX (1, (gint)allocation->width -
5513                                           border_width * 2);
5514   clist->internal_allocation.height = MAX (1, (gint)allocation->height -
5515                                            border_width * 2);
5516
5517   /* allocate clist window assuming no scrollbars */
5518   clist_allocation.x = (clist->internal_allocation.x +
5519                         widget->style->xthickness);
5520   clist_allocation.y = (clist->internal_allocation.y +
5521                         widget->style->ythickness +
5522                         clist->column_title_area.height);
5523   clist_allocation.width = MAX (1, (gint)clist->internal_allocation.width -
5524                                 (2 * (gint)widget->style->xthickness));
5525   clist_allocation.height = MAX (1, (gint)clist->internal_allocation.height -
5526                                  (2 * (gint)widget->style->ythickness) -
5527                                  (gint)clist->column_title_area.height);
5528
5529   clist->clist_window_width = clist_allocation.width;
5530   clist->clist_window_height = clist_allocation.height;
5531
5532   if (GTK_WIDGET_REALIZED (widget))
5533     {
5534       gdk_window_move_resize (clist->clist_window,
5535                               clist_allocation.x,
5536                               clist_allocation.y,
5537                               clist_allocation.width,
5538                               clist_allocation.height);
5539     }
5540
5541   /* position the window which holds the column title buttons */
5542   clist->column_title_area.x = widget->style->xthickness;
5543   clist->column_title_area.y = widget->style->ythickness;
5544   clist->column_title_area.width = clist_allocation.width;
5545
5546   if (GTK_WIDGET_REALIZED (widget))
5547     {
5548       gdk_window_move_resize (clist->title_window,
5549                               clist->column_title_area.x,
5550                               clist->column_title_area.y,
5551                               clist->column_title_area.width,
5552                               clist->column_title_area.height);
5553     }
5554
5555   /* column button allocation */
5556   size_allocate_columns (clist, FALSE);
5557   size_allocate_title_buttons (clist);
5558
5559   adjust_adjustments (clist, TRUE);
5560 }
5561
5562 /* GTKCONTAINER
5563  *   gtk_cmclist_forall
5564  */
5565 static void
5566 gtk_cmclist_forall (GtkContainer *container,
5567                   gboolean      include_internals,
5568                   GtkCallback   callback,
5569                   gpointer      callback_data)
5570 {
5571   GtkCMCList *clist;
5572   guint i;
5573
5574   g_return_if_fail (GTK_IS_CMCLIST (container));
5575   g_return_if_fail (callback != NULL);
5576
5577   if (!include_internals)
5578     return;
5579
5580   clist = GTK_CMCLIST (container);
5581
5582   /* callback for the column buttons */
5583   for (i = 0; i < clist->columns; i++)
5584     if (clist->column[i].button)
5585       (*callback) (clist->column[i].button, callback_data);
5586 }
5587
5588 /* PRIVATE DRAWING FUNCTIONS
5589  *   get_cell_style
5590  *   draw_cell_pixmap
5591  *   draw_row
5592  *   draw_rows
5593  *   draw_xor_line
5594  *   clist_refresh
5595  */
5596 static void
5597 get_cell_style (GtkCMCList     *clist,
5598                 GtkCMCListRow  *clist_row,
5599                 gint          state,
5600                 gint          column,
5601                 GtkStyle    **style,
5602                 GdkGC       **fg_gc,
5603                 GdkGC       **bg_gc)
5604 {
5605   gint fg_state;
5606
5607   if ((state == GTK_STATE_NORMAL) &&
5608       (GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
5609     fg_state = GTK_STATE_INSENSITIVE;
5610   else
5611     fg_state = state;
5612
5613   if (clist_row->cell[column].style)
5614     {
5615       if (style)
5616         *style = clist_row->cell[column].style;
5617       if (fg_gc)
5618         *fg_gc = clist_row->cell[column].style->fg_gc[fg_state];
5619       if (bg_gc) {
5620         if (state == GTK_STATE_SELECTED)
5621           *bg_gc = clist_row->cell[column].style->bg_gc[state];
5622         else
5623           *bg_gc = clist_row->cell[column].style->base_gc[state];
5624       }
5625     }
5626   else if (clist_row->style)
5627     {
5628       if (style)
5629         *style = clist_row->style;
5630       if (fg_gc)
5631         *fg_gc = clist_row->style->fg_gc[fg_state];
5632       if (bg_gc) {
5633         if (state == GTK_STATE_SELECTED)
5634           *bg_gc = clist_row->style->bg_gc[state];
5635         else
5636           *bg_gc = clist_row->style->base_gc[state];
5637       }
5638     }
5639   else
5640     {
5641       if (style)
5642         *style = GTK_WIDGET (clist)->style;
5643       if (fg_gc)
5644         *fg_gc = GTK_WIDGET (clist)->style->fg_gc[fg_state];
5645       if (bg_gc) {
5646         if (state == GTK_STATE_SELECTED)
5647           *bg_gc = GTK_WIDGET (clist)->style->bg_gc[state];
5648         else
5649           *bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
5650       }
5651
5652       if (state != GTK_STATE_SELECTED)
5653         {
5654           if (fg_gc && clist_row->fg_set)
5655             *fg_gc = clist->fg_gc;
5656           if (bg_gc && clist_row->bg_set)
5657             *bg_gc = clist->bg_gc;
5658         }
5659     }
5660 }
5661
5662 static gint
5663 draw_cell_pixmap (GdkWindow    *window,
5664                   GdkRectangle *clip_rectangle,
5665                   GdkGC        *fg_gc,
5666                   GdkPixmap    *pixmap,
5667                   GdkBitmap    *mask,
5668                   gint          x,
5669                   gint          y,
5670                   gint          width,
5671                   gint          height)
5672 {
5673   gint xsrc = 0;
5674   gint ysrc = 0;
5675
5676   if (mask)
5677     {
5678       gdk_gc_set_clip_mask (fg_gc, mask);
5679       gdk_gc_set_clip_origin (fg_gc, x, y);
5680     }
5681
5682   if (x < clip_rectangle->x)
5683     {
5684       xsrc = clip_rectangle->x - x;
5685       width -= xsrc;
5686       x = clip_rectangle->x;
5687     }
5688   if (x + width > clip_rectangle->x + clip_rectangle->width)
5689     width = clip_rectangle->x + clip_rectangle->width - x;
5690
5691   if (y < clip_rectangle->y)
5692     {
5693       ysrc = clip_rectangle->y - y;
5694       height -= ysrc;
5695       y = clip_rectangle->y;
5696     }
5697   if (y + height > clip_rectangle->y + clip_rectangle->height)
5698     height = clip_rectangle->y + clip_rectangle->height - y;
5699
5700   gdk_draw_drawable (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
5701   gdk_gc_set_clip_origin (fg_gc, 0, 0);
5702   if (mask)
5703     gdk_gc_set_clip_mask (fg_gc, NULL);
5704
5705   return x + MAX (width, 0);
5706 }
5707
5708 static void
5709 draw_row (GtkCMCList     *clist,
5710           GdkRectangle *area,
5711           gint          row,
5712           GtkCMCListRow  *clist_row)
5713 {
5714   GtkWidget *widget;
5715   GdkRectangle *rect;
5716   GdkRectangle row_rectangle;
5717   GdkRectangle cell_rectangle;
5718   GdkRectangle clip_rectangle;
5719   GdkRectangle intersect_rectangle;
5720   gint last_column;
5721   gint state;
5722   gint i;
5723
5724   g_return_if_fail (clist != NULL);
5725
5726   /* bail now if we arn't drawable yet */
5727   if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
5728     return;
5729
5730   widget = GTK_WIDGET (clist);
5731
5732   /* if the function is passed the pointer to the row instead of null,
5733    * it avoids this expensive lookup */
5734   if (!clist_row)
5735     clist_row = ROW_ELEMENT (clist, row)->data;
5736
5737   /* rectangle of the entire row */
5738   row_rectangle.x = 0;
5739   row_rectangle.y = ROW_TOP_YPIXEL (clist, row);
5740   row_rectangle.width = clist->clist_window_width;
5741   row_rectangle.height = clist->row_height;
5742
5743   /* rectangle of the cell spacing above the row */
5744   cell_rectangle.x = 0;
5745   cell_rectangle.y = row_rectangle.y - CELL_SPACING;
5746   cell_rectangle.width = row_rectangle.width;
5747   cell_rectangle.height = CELL_SPACING;
5748
5749   /* rectangle used to clip drawing operations, its y and height
5750    * positions only need to be set once, so we set them once here.
5751    * the x and width are set withing the drawing loop below once per
5752    * column */
5753   clip_rectangle.y = row_rectangle.y;
5754   clip_rectangle.height = row_rectangle.height;
5755
5756   if (clist_row->state == GTK_STATE_NORMAL)
5757     {
5758       if (clist_row->fg_set)
5759         gdk_gc_set_foreground (clist->fg_gc, &clist_row->foreground);
5760       if (clist_row->bg_set)
5761         gdk_gc_set_foreground (clist->bg_gc, &clist_row->background);
5762     }
5763
5764   state = clist_row->state;
5765
5766   /* draw the cell borders and background */
5767   if (area)
5768     {
5769       rect = &intersect_rectangle;
5770       if (gdk_rectangle_intersect (area, &cell_rectangle,
5771                                    &intersect_rectangle))
5772         gdk_draw_rectangle (clist->clist_window,
5773                             widget->style->base_gc[GTK_STATE_NORMAL],
5774                             TRUE,
5775                             intersect_rectangle.x,
5776                             intersect_rectangle.y,
5777                             intersect_rectangle.width,
5778                             intersect_rectangle.height);
5779
5780       /* the last row has to clear its bottom cell spacing too */
5781       if (clist_row == clist->row_list_end->data)
5782         {
5783           cell_rectangle.y += clist->row_height + CELL_SPACING;
5784
5785           if (gdk_rectangle_intersect (area, &cell_rectangle,
5786                                        &intersect_rectangle))
5787             gdk_draw_rectangle (clist->clist_window,
5788                                 widget->style->base_gc[GTK_STATE_NORMAL],
5789                                 TRUE,
5790                                 intersect_rectangle.x,
5791                                 intersect_rectangle.y,
5792                                 intersect_rectangle.width,
5793                                 intersect_rectangle.height);
5794         }
5795
5796       if (!gdk_rectangle_intersect (area, &row_rectangle,&intersect_rectangle))
5797         return;
5798
5799     }
5800   else
5801     {
5802       rect = &clip_rectangle;
5803       gdk_draw_rectangle (clist->clist_window,
5804                           widget->style->base_gc[GTK_STATE_NORMAL],
5805                           TRUE,
5806                           cell_rectangle.x,
5807                           cell_rectangle.y,
5808                           cell_rectangle.width,
5809                           cell_rectangle.height);
5810
5811       /* the last row has to clear its bottom cell spacing too */
5812       if (clist_row == clist->row_list_end->data)
5813         {
5814           cell_rectangle.y += clist->row_height + CELL_SPACING;
5815
5816           gdk_draw_rectangle (clist->clist_window,
5817                               widget->style->base_gc[GTK_STATE_NORMAL],
5818                               TRUE,
5819                               cell_rectangle.x,
5820                               cell_rectangle.y,
5821                               cell_rectangle.width,
5822                               cell_rectangle.height);
5823         }
5824     }
5825
5826   for (last_column = clist->columns - 1;
5827        last_column >= 0 && !clist->column[last_column].visible; last_column--)
5828     ;
5829
5830   /* iterate and draw all the columns (row cells) and draw their contents */
5831   for (i = 0; i < clist->columns; i++)
5832     {
5833       GtkStyle *style;
5834       GdkGC *fg_gc;
5835       GdkGC *bg_gc;
5836       PangoLayout *layout;
5837       PangoRectangle logical_rect;
5838
5839       gint width;
5840       gint height;
5841       gint pixmap_width;
5842       gint offset = 0;
5843
5844       if (!clist->column[i].visible)
5845         continue;
5846
5847       get_cell_style (clist, clist_row, state, i, &style, &fg_gc, &bg_gc);
5848
5849       clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
5850       clip_rectangle.width = clist->column[i].area.width;
5851
5852       /* calculate clipping region clipping region */
5853       clip_rectangle.x -= COLUMN_INSET + CELL_SPACING;
5854       clip_rectangle.width += (2 * COLUMN_INSET + CELL_SPACING +
5855                                (i == last_column) * CELL_SPACING);
5856
5857       if (area && !gdk_rectangle_intersect (area, &clip_rectangle,
5858                                             &intersect_rectangle))
5859         continue;
5860
5861       gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
5862                           rect->x, rect->y, rect->width, rect->height);
5863
5864       clip_rectangle.x += COLUMN_INSET + CELL_SPACING;
5865       clip_rectangle.width -= (2 * COLUMN_INSET + CELL_SPACING +
5866                                (i == last_column) * CELL_SPACING);
5867
5868
5869       /* calculate real width for column justification */
5870
5871       layout = _gtk_cmclist_create_cell_layout (clist, clist_row, i);
5872       if (layout)
5873         {
5874           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
5875           width = logical_rect.width;
5876         }
5877       else
5878         width = 0;
5879
5880       pixmap_width = 0;
5881       offset = 0;
5882       switch (clist_row->cell[i].type)
5883         {
5884         case GTK_CMCELL_PIXMAP:
5885           gdk_drawable_get_size (GTK_CMCELL_PIXMAP (clist_row->cell[i])->pixmap,
5886                                &pixmap_width, &height);
5887           width += pixmap_width;
5888           break;
5889         case GTK_CMCELL_PIXTEXT:
5890           gdk_drawable_get_size (GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixmap,
5891                                &pixmap_width, &height);
5892           width += pixmap_width + GTK_CMCELL_PIXTEXT (clist_row->cell[i])->spacing;
5893           break;
5894         default:
5895           break;
5896         }
5897
5898       switch (clist->column[i].justification)
5899         {
5900         case GTK_JUSTIFY_LEFT:
5901           offset = clip_rectangle.x + clist_row->cell[i].horizontal;
5902           break;
5903         case GTK_JUSTIFY_RIGHT:
5904           offset = (clip_rectangle.x + clist_row->cell[i].horizontal +
5905                     clip_rectangle.width - width);
5906           break;
5907         case GTK_JUSTIFY_CENTER:
5908         case GTK_JUSTIFY_FILL:
5909           offset = (clip_rectangle.x + clist_row->cell[i].horizontal +
5910                     (clip_rectangle.width / 2) - (width / 2));
5911           break;
5912         };
5913
5914       /* Draw Text and/or Pixmap */
5915       switch (clist_row->cell[i].type)
5916         {
5917         case GTK_CMCELL_PIXMAP:
5918           draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
5919                             GTK_CMCELL_PIXMAP (clist_row->cell[i])->pixmap,
5920                             GTK_CMCELL_PIXMAP (clist_row->cell[i])->mask,
5921                             offset,
5922                             clip_rectangle.y + clist_row->cell[i].vertical +
5923                             (clip_rectangle.height - height) / 2,
5924                             pixmap_width, height);
5925           break;
5926         case GTK_CMCELL_PIXTEXT:
5927           offset =
5928             draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
5929                               GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixmap,
5930                               GTK_CMCELL_PIXTEXT (clist_row->cell[i])->mask,
5931                               offset,
5932                               clip_rectangle.y + clist_row->cell[i].vertical+
5933                               (clip_rectangle.height - height) / 2,
5934                               pixmap_width, height);
5935           offset += GTK_CMCELL_PIXTEXT (clist_row->cell[i])->spacing;
5936
5937           /* Fall through */
5938         case GTK_CMCELL_TEXT:
5939           if (layout)
5940             {
5941               gint row_center_offset = (clist->row_height - logical_rect.height - 1) / 2;
5942
5943               gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
5944               gdk_draw_layout (clist->clist_window, fg_gc,
5945                                offset,
5946                                row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
5947                                layout);
5948               g_object_unref (G_OBJECT (layout));
5949               gdk_gc_set_clip_rectangle (fg_gc, NULL);
5950             }
5951           break;
5952         default:
5953           break;
5954         }
5955     }
5956
5957   /* draw focus rectangle */
5958   if (clist->focus_row == row &&
5959       GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS(widget))
5960     {
5961       if (!area)
5962         gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
5963                             row_rectangle.x, row_rectangle.y,
5964                             row_rectangle.width - 1, row_rectangle.height - 1);
5965       else if (gdk_rectangle_intersect (area, &row_rectangle,
5966                                         &intersect_rectangle))
5967         {
5968           gdk_gc_set_clip_rectangle (clist->xor_gc, &intersect_rectangle);
5969           gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
5970                               row_rectangle.x, row_rectangle.y,
5971                               row_rectangle.width - 1,
5972                               row_rectangle.height - 1);
5973           gdk_gc_set_clip_rectangle (clist->xor_gc, NULL);
5974         }
5975     }
5976 }
5977
5978 static void
5979 draw_rows (GtkCMCList     *clist,
5980            GdkRectangle *area)
5981 {
5982   GList *list;
5983   GtkCMCListRow *clist_row;
5984   gint i;
5985   gint first_row;
5986   gint last_row;
5987
5988   g_return_if_fail (GTK_IS_CMCLIST (clist));
5989
5990   if (clist->row_height == 0 ||
5991       !GTK_WIDGET_DRAWABLE (clist))
5992     return;
5993
5994   if (area)
5995     {
5996       first_row = ROW_FROM_YPIXEL (clist, area->y);
5997       last_row = ROW_FROM_YPIXEL (clist, area->y + area->height);
5998     }
5999   else
6000     {
6001       first_row = ROW_FROM_YPIXEL (clist, 0);
6002       last_row = ROW_FROM_YPIXEL (clist, clist->clist_window_height);
6003     }
6004
6005   /* this is a small special case which exposes the bottom cell line
6006    * on the last row -- it might go away if I change the wall the cell
6007    * spacings are drawn
6008    */
6009   if (clist->rows == first_row)
6010     first_row--;
6011
6012   list = ROW_ELEMENT (clist, first_row);
6013   i = first_row;
6014   while (list)
6015     {
6016       clist_row = list->data;
6017       list = list->next;
6018
6019       if (i > last_row)
6020         return;
6021
6022       GTK_CMCLIST_GET_CLASS (clist)->draw_row (clist, area, i, clist_row);
6023       i++;
6024     }
6025
6026   if (!area)
6027     gdk_window_clear_area (clist->clist_window, 0,
6028                            ROW_TOP_YPIXEL (clist, i), 0, 0);
6029 }
6030
6031 static void
6032 draw_xor_line (GtkCMCList *clist)
6033 {
6034   GtkWidget *widget;
6035
6036   g_return_if_fail (clist != NULL);
6037
6038   widget = GTK_WIDGET (clist);
6039
6040   gdk_draw_line (widget->window, clist->xor_gc,
6041                  clist->x_drag,
6042                  widget->style->ythickness,
6043                  clist->x_drag,
6044                  clist->column_title_area.height +
6045                  clist->clist_window_height + 1);
6046 }
6047
6048 static void
6049 clist_refresh (GtkCMCList *clist)
6050 {
6051   g_return_if_fail (GTK_IS_CMCLIST (clist));
6052
6053   if (CLIST_UNFROZEN (clist))
6054     {
6055       adjust_adjustments (clist, FALSE);
6056       draw_rows (clist, NULL);
6057     }
6058 }
6059
6060 /* get cell from coordinates
6061  *   get_selection_info
6062  *   gtk_cmclist_get_selection_info
6063  */
6064 static gint
6065 get_selection_info (GtkCMCList *clist,
6066                     gint      x,
6067                     gint      y,
6068                     gint     *row,
6069                     gint     *column)
6070 {
6071   gint trow, tcol;
6072
6073   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
6074
6075   /* bounds checking, return false if the user clicked
6076    * on a blank area */
6077   trow = ROW_FROM_YPIXEL (clist, y);
6078   if (trow >= clist->rows)
6079     return 0;
6080
6081   if (row)
6082     *row = trow;
6083
6084   tcol = COLUMN_FROM_XPIXEL (clist, x);
6085   if (tcol >= clist->columns)
6086     return 0;
6087
6088   if (column)
6089     *column = tcol;
6090
6091   return 1;
6092 }
6093
6094 gint
6095 gtk_cmclist_get_selection_info (GtkCMCList *clist,
6096                               gint      x,
6097                               gint      y,
6098                               gint     *row,
6099                               gint     *column)
6100 {
6101   g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
6102   return get_selection_info (clist, x, y, row, column);
6103 }
6104
6105 /* PRIVATE ADJUSTMENT FUNCTIONS
6106  *   adjust_adjustments
6107  *   vadjustment_changed
6108  *   hadjustment_changed
6109  *   vadjustment_value_changed
6110  *   hadjustment_value_changed
6111  *   check_exposures
6112  */
6113 static void
6114 adjust_adjustments (GtkCMCList *clist,
6115                     gboolean  block_resize)
6116 {
6117   if (clist->vadjustment)
6118     {
6119       clist->vadjustment->page_size = clist->clist_window_height;
6120       clist->vadjustment->step_increment = clist->row_height;
6121       clist->vadjustment->page_increment =
6122         MAX (clist->vadjustment->page_size - clist->vadjustment->step_increment,
6123              clist->vadjustment->page_size / 2);
6124       clist->vadjustment->lower = 0;
6125       clist->vadjustment->upper = LIST_HEIGHT (clist);
6126
6127       if (clist->clist_window_height - clist->voffset > LIST_HEIGHT (clist) ||
6128           (clist->voffset + (gint)clist->vadjustment->value) != 0)
6129         {
6130           clist->vadjustment->value = MAX (0, (LIST_HEIGHT (clist) -
6131                                                clist->clist_window_height));
6132           g_signal_emit_by_name (G_OBJECT (clist->vadjustment),
6133                                    "value_changed");
6134         }
6135       g_signal_emit_by_name (G_OBJECT (clist->vadjustment), "changed");
6136     }
6137
6138   if (clist->hadjustment)
6139     {
6140       clist->hadjustment->page_size = clist->clist_window_width;
6141       clist->hadjustment->step_increment = 10;
6142       clist->hadjustment->page_increment =
6143         MAX (clist->hadjustment->page_size - clist->hadjustment->step_increment,
6144              clist->hadjustment->page_size / 2);
6145       clist->hadjustment->lower = 0;
6146       clist->hadjustment->upper = LIST_WIDTH (clist);
6147
6148       if (clist->clist_window_width - clist->hoffset > LIST_WIDTH (clist) ||
6149           (clist->hoffset + (gint)clist->hadjustment->value) != 0)
6150         {
6151           clist->hadjustment->value = MAX (0, (LIST_WIDTH (clist) -
6152                                                clist->clist_window_width));
6153           g_signal_emit_by_name (G_OBJECT (clist->hadjustment),
6154                                    "value_changed");
6155         }
6156       g_signal_emit_by_name (G_OBJECT (clist->hadjustment), "changed");
6157     }
6158
6159   if (!block_resize && (!clist->vadjustment || !clist->hadjustment))
6160     {
6161       GtkWidget *widget;
6162       GtkRequisition requisition;
6163
6164       widget = GTK_WIDGET (clist);
6165       gtk_widget_size_request (widget, &requisition);
6166
6167       if ((!clist->hadjustment &&
6168            requisition.width != widget->allocation.width) ||
6169           (!clist->vadjustment &&
6170            requisition.height != widget->allocation.height))
6171         gtk_widget_queue_resize (widget);
6172     }
6173 }
6174
6175 static void
6176 vadjustment_changed (GtkAdjustment *adjustment,
6177                      gpointer       data)
6178 {
6179   GtkCMCList *clist;
6180
6181   g_return_if_fail (adjustment != NULL);
6182   g_return_if_fail (data != NULL);
6183
6184   clist = GTK_CMCLIST (data);
6185 }
6186
6187 static void
6188 hadjustment_changed (GtkAdjustment *adjustment,
6189                      gpointer       data)
6190 {
6191   GtkCMCList *clist;
6192
6193   g_return_if_fail (adjustment != NULL);
6194   g_return_if_fail (data != NULL);
6195
6196   clist = GTK_CMCLIST (data);
6197 }
6198
6199 static void
6200 vadjustment_value_changed (GtkAdjustment *adjustment,
6201                            gpointer       data)
6202 {
6203   GtkCMCList *clist;
6204   gint dy, value;
6205
6206   g_return_if_fail (adjustment != NULL);
6207   g_return_if_fail (GTK_IS_CMCLIST (data));
6208
6209   clist = GTK_CMCLIST (data);
6210
6211   if (adjustment != clist->vadjustment)
6212     return;
6213
6214   value = -adjustment->value;
6215   dy = value - clist->voffset;
6216   clist->voffset = value;
6217
6218   if (GTK_WIDGET_DRAWABLE (clist))
6219     {
6220       gdk_window_scroll (clist->clist_window, 0, dy);
6221       gdk_window_process_updates (clist->clist_window, FALSE);
6222     }
6223
6224   return;
6225 }
6226
6227 typedef struct
6228 {
6229   GdkWindow *window;
6230   gint dx;
6231 } ScrollData;
6232
6233 /* The window to which widget->window is relative */
6234 #define ALLOCATION_WINDOW(widget)               \
6235    (GTK_WIDGET_NO_WINDOW (widget) ?             \
6236     (widget)->window :                          \
6237      gdk_window_get_parent ((widget)->window))
6238
6239 static void
6240 adjust_allocation_recurse (GtkWidget *widget,
6241                            gpointer   data)
6242 {
6243   ScrollData *scroll_data = data;
6244
6245   if (!GTK_WIDGET_REALIZED (widget))
6246     {
6247       if (GTK_WIDGET_VISIBLE (widget))
6248         {
6249           GdkRectangle tmp_rectangle = widget->allocation;
6250           tmp_rectangle.x += scroll_data->dx;
6251
6252           gtk_widget_size_allocate (widget, &tmp_rectangle);
6253         }
6254     }
6255   else
6256     {
6257       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
6258         {
6259           widget->allocation.x += scroll_data->dx;
6260
6261           if (GTK_IS_CONTAINER (widget))
6262             gtk_container_forall (GTK_CONTAINER (widget),
6263                                   adjust_allocation_recurse,
6264                                   data);
6265         }
6266     }
6267 }
6268
6269 static void
6270 adjust_allocation (GtkWidget *widget,
6271                    gint       dx)
6272 {
6273   ScrollData scroll_data;
6274
6275   if (GTK_WIDGET_REALIZED (widget))
6276     scroll_data.window = ALLOCATION_WINDOW (widget);
6277   else
6278     scroll_data.window = NULL;
6279
6280   scroll_data.dx = dx;
6281
6282   adjust_allocation_recurse (widget, &scroll_data);
6283 }
6284
6285 static void
6286 hadjustment_value_changed (GtkAdjustment *adjustment,
6287                            gpointer       data)
6288 {
6289   GtkCMCList *clist;
6290   GtkContainer *container;
6291   GdkRectangle area;
6292   gint i;
6293   gint y = 0;
6294   gint value;
6295   gint dx;
6296
6297   g_return_if_fail (adjustment != NULL);
6298   g_return_if_fail (GTK_IS_CMCLIST (data));
6299
6300   clist = GTK_CMCLIST (data);
6301   container = GTK_CONTAINER (data);
6302
6303   if (adjustment != clist->hadjustment)
6304     return;
6305
6306   value = adjustment->value;
6307
6308   dx = -value - clist->hoffset;
6309
6310   if (GTK_WIDGET_REALIZED (clist))
6311     gdk_window_scroll (clist->title_window, dx, 0);
6312
6313   /* adjust the column button's allocations */
6314   for (i = 0; i < clist->columns; i++)
6315     if (clist->column[i].button)
6316       adjust_allocation (clist->column[i].button, dx);
6317
6318   clist->hoffset = -value;
6319
6320   if (GTK_WIDGET_DRAWABLE (clist))
6321     {
6322       if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
6323           !container->focus_child && GTK_CMCLIST_ADD_MODE(clist))
6324         {
6325           y = ROW_TOP_YPIXEL (clist, clist->focus_row);
6326
6327           gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE, 0, y,
6328                               clist->clist_window_width - 1,
6329                               clist->row_height - 1);
6330         }
6331
6332       gdk_window_scroll (clist->clist_window, dx, 0);
6333       gdk_window_process_updates (clist->clist_window, FALSE);
6334
6335       if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
6336           !container->focus_child)
6337         {
6338           if (GTK_CMCLIST_ADD_MODE(clist))
6339             {
6340               gint focus_row;
6341
6342               focus_row = clist->focus_row;
6343               clist->focus_row = -1;
6344               draw_rows (clist, &area);
6345               clist->focus_row = focus_row;
6346
6347               gdk_draw_rectangle (clist->clist_window, clist->xor_gc,
6348                                   FALSE, 0, y, clist->clist_window_width - 1,
6349                                   clist->row_height - 1);
6350               return;
6351             }
6352           else if (ABS(dx) < clist->clist_window_width - 1)
6353             {
6354               gint x0;
6355               gint x1;
6356
6357               if (dx > 0)
6358                 {
6359                   x0 = clist->clist_window_width - 1;
6360                   x1 = dx;
6361                 }
6362               else
6363                 {
6364                   x0 = 0;
6365                   x1 = clist->clist_window_width - 1 + dx;
6366                 }
6367
6368               y = ROW_TOP_YPIXEL (clist, clist->focus_row);
6369               gdk_draw_line (clist->clist_window, clist->xor_gc,
6370                              x0, y + 1, x0, y + clist->row_height - 2);
6371               gdk_draw_line (clist->clist_window, clist->xor_gc,
6372                              x1, y + 1, x1, y + clist->row_height - 2);
6373             }
6374         }
6375     }
6376 }
6377
6378 /* PRIVATE
6379  * Memory Allocation/Distruction Routines for GtkCMCList stuctures
6380  *
6381  * functions:
6382  *   columns_new
6383  *   column_title_new
6384  *   columns_delete
6385  *   row_new
6386  *   row_delete
6387  */
6388 static GtkCMCListColumn *
6389 columns_new (GtkCMCList *clist)
6390 {
6391   GtkCMCListColumn *column;
6392   gint i;
6393
6394   column = g_new (GtkCMCListColumn, clist->columns);
6395
6396   for (i = 0; i < clist->columns; i++)
6397     {
6398       column[i].area.x = 0;
6399       column[i].area.y = 0;
6400       column[i].area.width = 0;
6401       column[i].area.height = 0;
6402       column[i].title = NULL;
6403       column[i].button = NULL;
6404       column[i].window = NULL;
6405       column[i].width = 0;
6406       column[i].min_width = -1;
6407       column[i].max_width = -1;
6408       column[i].visible = TRUE;
6409       column[i].width_set = FALSE;
6410       column[i].resizeable = TRUE;
6411       column[i].auto_resize = FALSE;
6412       column[i].button_passive = FALSE;
6413       column[i].justification = GTK_JUSTIFY_LEFT;
6414     }
6415
6416   return column;
6417 }
6418
6419 static void
6420 column_title_new (GtkCMCList    *clist,
6421                   gint         column,
6422                   const gchar *title)
6423 {
6424   g_free (clist->column[column].title);
6425
6426   clist->column[column].title = g_strdup (title);
6427 }
6428
6429 static void
6430 columns_delete (GtkCMCList *clist)
6431 {
6432   gint i;
6433
6434   for (i = 0; i < clist->columns; i++)
6435     g_free (clist->column[i].title);
6436
6437   g_free (clist->column);
6438 }
6439
6440 static GtkCMCListRow *
6441 row_new (GtkCMCList *clist)
6442 {
6443   int i;
6444   GtkCMCListRow *clist_row;
6445
6446 #if GLIB_CHECK_VERSION(2,10,0)
6447   clist_row = g_slice_new (GtkCMCListRow);
6448   clist_row->cell = g_slice_alloc (sizeof (GtkCMCell) * clist->columns);
6449 #else
6450   clist_row = g_chunk_new (GtkCMCListRow, (GMemChunk *)clist->row_mem_chunk);
6451   clist_row->cell = g_chunk_new (GtkCMCell, (GMemChunk *)clist->cell_mem_chunk);
6452 #endif
6453
6454   for (i = 0; i < clist->columns; i++)
6455     {
6456       clist_row->cell[i].type = GTK_CMCELL_EMPTY;
6457       clist_row->cell[i].vertical = 0;
6458       clist_row->cell[i].horizontal = 0;
6459       clist_row->cell[i].style = NULL;
6460     }
6461
6462   clist_row->fg_set = FALSE;
6463   clist_row->bg_set = FALSE;
6464   clist_row->style = NULL;
6465   clist_row->selectable = TRUE;
6466   clist_row->state = GTK_STATE_NORMAL;
6467   clist_row->data = NULL;
6468   clist_row->destroy = NULL;
6469
6470   return clist_row;
6471 }
6472
6473 static void
6474 row_delete (GtkCMCList    *clist,
6475             GtkCMCListRow *clist_row)
6476 {
6477   gint i;
6478
6479   for (i = 0; i < clist->columns; i++)
6480     {
6481       GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
6482         (clist, clist_row, i, GTK_CMCELL_EMPTY, NULL, 0, NULL, NULL);
6483       if (clist_row->cell[i].style)
6484         {
6485           if (GTK_WIDGET_REALIZED (clist))
6486             gtk_style_detach (clist_row->cell[i].style);
6487           g_object_unref (clist_row->cell[i].style);
6488         }
6489     }
6490
6491   if (clist_row->style)
6492     {
6493       if (GTK_WIDGET_REALIZED (clist))
6494         gtk_style_detach (clist_row->style);
6495       g_object_unref (clist_row->style);
6496     }
6497
6498   if (clist_row->destroy)
6499     clist_row->destroy (clist_row->data);
6500
6501 #if GLIB_CHECK_VERSION(2,10,0)
6502   g_slice_free1 (sizeof (GtkCMCell) * clist->columns, clist_row->cell);
6503   g_slice_free (GtkCMCListRow, clist_row);
6504 #else
6505   g_mem_chunk_free ((GMemChunk *)clist->cell_mem_chunk, clist_row->cell);
6506   g_mem_chunk_free ((GMemChunk *)clist->row_mem_chunk, clist_row);
6507 #endif
6508 }
6509
6510 /* FOCUS FUNCTIONS
6511  *   gtk_cmclist_focus_content_area
6512  *   gtk_cmclist_focus
6513  *   gtk_cmclist_draw_focus
6514  *   gtk_cmclist_focus_in
6515  *   gtk_cmclist_focus_out
6516  *   title_focus
6517  */
6518 static void
6519 gtk_cmclist_focus_content_area (GtkCMCList *clist)
6520 {
6521   if (clist->focus_row < 0)
6522     {
6523       clist->focus_row = 0;
6524
6525       if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
6526            clist->selection_mode == GTK_SELECTION_MULTIPLE) &&
6527           !clist->selection)
6528         g_signal_emit (G_OBJECT (clist),
6529                          clist_signals[SELECT_ROW], 0,
6530                          clist->focus_row, -1, NULL);
6531     }
6532   gtk_widget_grab_focus (GTK_WIDGET (clist));
6533 }
6534
6535 static gboolean
6536 gtk_cmclist_focus (GtkWidget        *widget,
6537                  GtkDirectionType  direction)
6538 {
6539   GtkCMCList *clist = GTK_CMCLIST (widget);
6540   GtkWidget *focus_child;
6541   gboolean is_current_focus;
6542
6543   if (!GTK_WIDGET_IS_SENSITIVE (widget))
6544     return FALSE;
6545
6546   focus_child = GTK_CONTAINER (widget)->focus_child;
6547
6548   is_current_focus = gtk_widget_is_focus (GTK_WIDGET (clist));
6549
6550   if (focus_child &&
6551       gtk_widget_child_focus (focus_child, direction))
6552     return TRUE;
6553
6554   switch (direction)
6555     {
6556     case GTK_DIR_LEFT:
6557     case GTK_DIR_RIGHT:
6558       if (focus_child)
6559         {
6560           if (title_focus_move (clist, direction))
6561             return TRUE;
6562         }
6563       else if (!is_current_focus)
6564         {
6565           gtk_cmclist_focus_content_area (clist);
6566           return TRUE;
6567         }
6568       break;
6569     case GTK_DIR_DOWN:
6570     case GTK_DIR_TAB_FORWARD:
6571       if (!focus_child && !is_current_focus)
6572         {
6573           if (title_focus_in (clist, direction))
6574             return TRUE;
6575         }
6576
6577       if (!is_current_focus && clist->rows)
6578         {
6579           gtk_cmclist_focus_content_area (clist);
6580           return TRUE;
6581         }
6582       break;
6583     case GTK_DIR_UP:
6584     case GTK_DIR_TAB_BACKWARD:
6585       if (!focus_child && is_current_focus)
6586         {
6587           if (title_focus_in (clist, direction))
6588             return TRUE;
6589         }
6590
6591       if (!is_current_focus && !focus_child && clist->rows)
6592         {
6593           gtk_cmclist_focus_content_area (clist);
6594           return TRUE;
6595         }
6596       break;
6597     default:
6598       break;
6599     }
6600
6601   return FALSE;
6602 }
6603
6604 static void
6605 gtk_cmclist_set_focus_child (GtkContainer *container,
6606                            GtkWidget    *child)
6607 {
6608   GtkCMCList *clist = GTK_CMCLIST (container);
6609   gint i;
6610
6611   for (i = 0; i < clist->columns; i++)
6612     if (clist->column[i].button == child)
6613       clist->focus_header_column = i;
6614
6615   parent_class->set_focus_child (container, child);
6616 }
6617
6618 static void
6619 gtk_cmclist_draw_focus (GtkWidget *widget)
6620 {
6621   GtkCMCList *clist;
6622
6623   g_return_if_fail (GTK_IS_CMCLIST (widget));
6624
6625   if (!GTK_WIDGET_DRAWABLE (widget) || !GTK_WIDGET_CAN_FOCUS (widget))
6626     return;
6627
6628   clist = GTK_CMCLIST (widget);
6629   if (clist->focus_row >= 0)
6630     gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
6631                         0, ROW_TOP_YPIXEL(clist, clist->focus_row),
6632                         clist->clist_window_width - 1,
6633                         clist->row_height - 1);
6634 }
6635
6636 static gint
6637 gtk_cmclist_focus_in (GtkWidget     *widget,
6638                     GdkEventFocus *event)
6639 {
6640   GtkCMCList *clist = GTK_CMCLIST (widget);
6641
6642   if (clist->selection_mode == GTK_SELECTION_BROWSE &&
6643       clist->selection == NULL && clist->focus_row > -1)
6644     {
6645       GList *list;
6646
6647       list = g_list_nth (clist->row_list, clist->focus_row);
6648       if (list && GTK_CMCLIST_ROW (list)->selectable)
6649         g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
6650                          clist->focus_row, -1, event);
6651       else
6652         gtk_cmclist_draw_focus (widget);
6653     }
6654   else
6655     gtk_cmclist_draw_focus (widget);
6656
6657   return FALSE;
6658 }
6659
6660 static gint
6661 gtk_cmclist_focus_out (GtkWidget     *widget,
6662                      GdkEventFocus *event)
6663 {
6664   GtkCMCList *clist = GTK_CMCLIST (widget);
6665
6666   gtk_cmclist_draw_focus (widget);
6667
6668   GTK_CMCLIST_GET_CLASS (widget)->resync_selection (clist, (GdkEvent *) event);
6669
6670   return FALSE;
6671 }
6672
6673 static gboolean
6674 focus_column (GtkCMCList *clist, gint column, gint dir)
6675 {
6676   GtkWidget *child = clist->column[column].button;
6677
6678   if (gtk_widget_child_focus (child, dir))
6679     {
6680       return TRUE;
6681     }
6682   else if (GTK_WIDGET_CAN_FOCUS (child))
6683     {
6684       gtk_widget_grab_focus (child);
6685       return TRUE;
6686     }
6687
6688   return FALSE;
6689 }
6690
6691 /* Focus moved onto the headers. Focus first focusable and visible child.
6692  * (FIXME: focus the last focused child if visible)
6693  */
6694 static gboolean
6695 title_focus_in (GtkCMCList *clist, gint dir)
6696 {
6697   gint i;
6698   gint left, right;
6699
6700   if (!GTK_CMCLIST_SHOW_TITLES (clist))
6701     return FALSE;
6702
6703   /* Check last focused column */
6704   if (clist->focus_header_column != -1)
6705     {
6706       i = clist->focus_header_column;
6707
6708       left = COLUMN_LEFT_XPIXEL (clist, i);
6709       right = left + clist->column[i].area.width;
6710
6711       if (left >= 0 && right <= clist->clist_window_width)
6712         {
6713           if (focus_column (clist, i, dir))
6714             return TRUE;
6715         }
6716     }
6717
6718   /* Check fully visible columns */
6719   for (i = 0 ; i < clist->columns ; i++)
6720     {
6721       left = COLUMN_LEFT_XPIXEL (clist, i);
6722       right = left + clist->column[i].area.width;
6723
6724       if (left >= 0 && right <= clist->clist_window_width)
6725         {
6726           if (focus_column (clist, i, dir))
6727             return TRUE;
6728         }
6729     }
6730
6731   /* Check partially visible columns */
6732   for (i = 0 ; i < clist->columns ; i++)
6733     {
6734       left = COLUMN_LEFT_XPIXEL (clist, i);
6735       right = left + clist->column[i].area.width;
6736
6737       if ((left < 0 && right > 0) ||
6738           (left < clist->clist_window_width && right > clist->clist_window_width))
6739         {
6740           if (focus_column (clist, i, dir))
6741             return TRUE;
6742         }
6743     }
6744
6745   return FALSE;
6746 }
6747
6748 /* Move the focus right or left within the title buttons, scrolling
6749  * as necessary to keep the focused child visible.
6750  */
6751 static gboolean
6752 title_focus_move (GtkCMCList *clist,
6753                   gint      dir)
6754 {
6755   GtkWidget *focus_child;
6756   gboolean return_val = FALSE;
6757   gint d = 0;
6758   gint i = -1;
6759   gint j;
6760
6761   if (!GTK_CMCLIST_SHOW_TITLES(clist))
6762     return FALSE;
6763
6764   focus_child = GTK_CONTAINER (clist)->focus_child;
6765   g_assert (focus_child);
6766
6767   /* Movement direction within headers
6768    */
6769   switch (dir)
6770     {
6771     case GTK_DIR_RIGHT:
6772       d = 1;
6773       break;
6774     case GTK_DIR_LEFT:
6775       d = -1;
6776       break;
6777     }
6778
6779   for (i = 0; i < clist->columns; i++)
6780     if (clist->column[i].button == focus_child)
6781       break;
6782
6783   g_assert (i != -1);           /* Have a starting column */
6784
6785   j = i + d;
6786   while (!return_val && j >= 0 && j < clist->columns)
6787     {
6788       if (clist->column[j].button &&
6789           GTK_WIDGET_VISIBLE (clist->column[j].button))
6790         {
6791           if (focus_column (clist, j, dir))
6792             {
6793               return_val = TRUE;
6794               break;
6795             }
6796         }
6797       j += d;
6798     }
6799
6800   /* If we didn't find it, wrap around and keep looking
6801    */
6802   if (!return_val)
6803     {
6804       j = d > 0 ? 0 : clist->columns - 1;
6805
6806       while (!return_val && j != i)
6807         {
6808           if (clist->column[j].button &&
6809               GTK_WIDGET_VISIBLE (clist->column[j].button))
6810             {
6811               if (focus_column (clist, j, dir))
6812                 {
6813                   return_val = TRUE;
6814                   break;
6815                 }
6816             }
6817           j += d;
6818         }
6819     }
6820
6821   /* Scroll horizontally so focused column is visible
6822    */
6823   if (return_val)
6824     {
6825       if (COLUMN_LEFT_XPIXEL (clist, j) < CELL_SPACING + COLUMN_INSET)
6826         gtk_cmclist_moveto (clist, -1, j, 0, 0);
6827       else if (COLUMN_LEFT_XPIXEL(clist, j) + clist->column[j].area.width >
6828                clist->clist_window_width)
6829         {
6830           gint last_column;
6831
6832           for (last_column = clist->columns - 1;
6833                last_column >= 0 && !clist->column[last_column].visible; last_column--);
6834
6835           if (j == last_column)
6836             gtk_cmclist_moveto (clist, -1, j, 0, 0);
6837           else
6838             gtk_cmclist_moveto (clist, -1, j, 0, 1);
6839         }
6840     }
6841   return TRUE;                  /* Even if we didn't find a new one, we can keep the
6842                                  * focus in the same place.
6843                                  */
6844 }
6845
6846 /* PRIVATE SCROLLING FUNCTIONS
6847  *   move_focus_row
6848  *   scroll_horizontal
6849  *   scroll_vertical
6850  *   move_horizontal
6851  *   move_vertical
6852  *   horizontal_timeout
6853  *   vertical_timeout
6854  *   remove_grab
6855  */
6856 static void
6857 move_focus_row (GtkCMCList      *clist,
6858                 GtkScrollType  scroll_type,
6859                 gfloat         position)
6860 {
6861   GtkWidget *widget;
6862
6863   g_return_if_fail (clist != 0);
6864   g_return_if_fail (GTK_IS_CMCLIST (clist));
6865
6866   widget = GTK_WIDGET (clist);
6867
6868   switch (scroll_type)
6869     {
6870     case GTK_SCROLL_STEP_UP:
6871     case GTK_SCROLL_STEP_BACKWARD:
6872       if (clist->focus_row <= 0)
6873         return;
6874       gtk_cmclist_draw_focus (widget);
6875       clist->focus_row--;
6876       gtk_cmclist_draw_focus (widget);
6877       break;
6878
6879     case GTK_SCROLL_STEP_DOWN:
6880     case GTK_SCROLL_STEP_FORWARD:
6881       if (clist->focus_row >= clist->rows - 1)
6882         return;
6883       gtk_cmclist_draw_focus (widget);
6884       clist->focus_row++;
6885       gtk_cmclist_draw_focus (widget);
6886       break;
6887     case GTK_SCROLL_PAGE_UP:
6888     case GTK_SCROLL_PAGE_BACKWARD:
6889       if (clist->focus_row <= 0)
6890         return;
6891       gtk_cmclist_draw_focus (widget);
6892       clist->focus_row = MAX (0, clist->focus_row -
6893                               (2 * clist->clist_window_height -
6894                                clist->row_height - CELL_SPACING) /
6895                               (2 * (clist->row_height + CELL_SPACING)));
6896       gtk_cmclist_draw_focus (widget);
6897       break;
6898     case GTK_SCROLL_PAGE_DOWN:
6899     case GTK_SCROLL_PAGE_FORWARD:
6900       if (clist->focus_row >= clist->rows - 1)
6901         return;
6902       gtk_cmclist_draw_focus (widget);
6903       clist->focus_row = MIN (clist->rows - 1, clist->focus_row +
6904                               (2 * clist->clist_window_height -
6905                                clist->row_height - CELL_SPACING) /
6906                               (2 * (clist->row_height + CELL_SPACING)));
6907       gtk_cmclist_draw_focus (widget);
6908       break;
6909     case GTK_SCROLL_JUMP:
6910       if (position >= 0 && position <= 1)
6911         {
6912           gtk_cmclist_draw_focus (widget);
6913           clist->focus_row = position * (clist->rows - 1);
6914           gtk_cmclist_draw_focus (widget);
6915         }
6916       break;
6917     default:
6918       break;
6919     }
6920 }
6921
6922 static void
6923 scroll_horizontal (GtkCMCList      *clist,
6924                    GtkScrollType  scroll_type,
6925                    gfloat         position)
6926 {
6927   gint column = 0;
6928   gint last_column;
6929
6930   g_return_if_fail (clist != 0);
6931   g_return_if_fail (GTK_IS_CMCLIST (clist));
6932
6933   if (clist_has_grab (clist))
6934     return;
6935
6936   for (last_column = clist->columns - 1;
6937        last_column >= 0 && !clist->column[last_column].visible; last_column--)
6938     ;
6939
6940   switch (scroll_type)
6941     {
6942     case GTK_SCROLL_STEP_BACKWARD:
6943       column = COLUMN_FROM_XPIXEL (clist, 0);
6944       if (COLUMN_LEFT_XPIXEL (clist, column) - CELL_SPACING - COLUMN_INSET >= 0
6945           && column > 0)
6946         column--;
6947       break;
6948     case GTK_SCROLL_STEP_FORWARD:
6949       column = COLUMN_FROM_XPIXEL (clist, clist->clist_window_width);
6950       if (column < 0)
6951         return;
6952       if (COLUMN_LEFT_XPIXEL (clist, column) +
6953           clist->column[column].area.width +
6954           CELL_SPACING + COLUMN_INSET - 1 <= clist->clist_window_width &&
6955           column < last_column)
6956         column++;
6957       break;
6958     case GTK_SCROLL_PAGE_BACKWARD:
6959     case GTK_SCROLL_PAGE_FORWARD:
6960       return;
6961     case GTK_SCROLL_JUMP:
6962       if (position >= 0 && position <= 1)
6963         {
6964           gint vis_columns = 0;
6965           gint i;
6966
6967           for (i = 0; i <= last_column; i++)
6968             if (clist->column[i].visible)
6969               vis_columns++;
6970
6971           column = position * vis_columns;
6972
6973           for (i = 0; i <= last_column && column > 0; i++)
6974             if (clist->column[i].visible)
6975               column--;
6976
6977           column = i;
6978         }
6979       else
6980         return;
6981       break;
6982     default:
6983       break;
6984     }
6985
6986   if (COLUMN_LEFT_XPIXEL (clist, column) < CELL_SPACING + COLUMN_INSET)
6987     gtk_cmclist_moveto (clist, -1, column, 0, 0);
6988   else if (COLUMN_LEFT_XPIXEL (clist, column) + CELL_SPACING + COLUMN_INSET - 1
6989            + clist->column[column].area.width > clist->clist_window_width)
6990     {
6991       if (column == last_column)
6992         gtk_cmclist_moveto (clist, -1, column, 0, 0);
6993       else
6994         gtk_cmclist_moveto (clist, -1, column, 0, 1);
6995     }
6996 }
6997
6998 static void
6999 scroll_vertical (GtkCMCList      *clist,
7000                  GtkScrollType  scroll_type,
7001                  gfloat         position)
7002 {
7003   gint old_focus_row;
7004
7005   g_return_if_fail (GTK_IS_CMCLIST (clist));
7006
7007   if (clist_has_grab (clist))
7008     return;
7009
7010   switch (clist->selection_mode)
7011     {
7012     case GTK_SELECTION_MULTIPLE:
7013       if (clist->anchor >= 0)
7014         return;
7015     case GTK_SELECTION_BROWSE:
7016
7017       old_focus_row = clist->focus_row;
7018       move_focus_row (clist, scroll_type, position);
7019
7020       if (old_focus_row != clist->focus_row)
7021         {
7022           if (clist->selection_mode == GTK_SELECTION_BROWSE)
7023             g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
7024                              old_focus_row, -1, NULL);
7025           else if (!GTK_CMCLIST_ADD_MODE(clist))
7026             {
7027               gtk_cmclist_unselect_all (clist);
7028               clist->undo_anchor = old_focus_row;
7029             }
7030         }
7031
7032       switch (gtk_cmclist_row_is_visible (clist, clist->focus_row))
7033         {
7034         case GTK_VISIBILITY_NONE:
7035           if (old_focus_row != clist->focus_row &&
7036               !(clist->selection_mode == GTK_SELECTION_MULTIPLE &&
7037                 GTK_CMCLIST_ADD_MODE(clist)))
7038             g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
7039                              clist->focus_row, -1, NULL);
7040           switch (scroll_type)
7041             {
7042             case GTK_SCROLL_PAGE_UP:
7043             case GTK_SCROLL_STEP_UP:
7044             case GTK_SCROLL_STEP_BACKWARD:
7045             case GTK_SCROLL_PAGE_BACKWARD:
7046               gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
7047               break;
7048             case GTK_SCROLL_PAGE_DOWN:
7049             case GTK_SCROLL_STEP_DOWN:
7050             case GTK_SCROLL_STEP_FORWARD:
7051             case GTK_SCROLL_PAGE_FORWARD:
7052               gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
7053               break;
7054             case GTK_SCROLL_JUMP:
7055               gtk_cmclist_moveto (clist, clist->focus_row, -1, 0.5, 0);
7056               break;
7057             default:
7058               break;
7059             }
7060           break;
7061         case GTK_VISIBILITY_PARTIAL:
7062           switch (scroll_type)
7063             {
7064             case GTK_SCROLL_STEP_BACKWARD:
7065             case GTK_SCROLL_PAGE_BACKWARD:
7066               gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
7067               break;
7068             case GTK_SCROLL_STEP_FORWARD:
7069             case GTK_SCROLL_PAGE_FORWARD:
7070               gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
7071               break;
7072             case GTK_SCROLL_JUMP:
7073               gtk_cmclist_moveto (clist, clist->focus_row, -1, 0.5, 0);
7074               break;
7075             default:
7076               break;
7077             }
7078         default:
7079           if (old_focus_row != clist->focus_row &&
7080               !(clist->selection_mode == GTK_SELECTION_MULTIPLE &&
7081                 GTK_CMCLIST_ADD_MODE(clist)))
7082             g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
7083                              clist->focus_row, -1, NULL);
7084           break;
7085         }
7086       break;
7087     default:
7088       move_focus_row (clist, scroll_type, position);
7089
7090       if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
7091           clist->clist_window_height)
7092         gtk_cmclist_moveto (clist, clist->focus_row, -1, 1, 0);
7093       else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
7094         gtk_cmclist_moveto (clist, clist->focus_row, -1, 0, 0);
7095       break;
7096     }
7097 }
7098
7099 static void
7100 move_horizontal (GtkCMCList *clist,
7101                  gint      diff)
7102 {
7103   gdouble value;
7104
7105   if (!clist->hadjustment)
7106     return;
7107
7108   value = CLAMP (clist->hadjustment->value + diff, 0.0,
7109                  clist->hadjustment->upper - clist->hadjustment->page_size);
7110   gtk_adjustment_set_value (clist->hadjustment, value);
7111 }
7112
7113 static void
7114 move_vertical (GtkCMCList *clist,
7115                gint      row,
7116                gfloat    align)
7117 {
7118   gdouble value;
7119
7120   if (!clist->vadjustment)
7121     return;
7122
7123   value = (ROW_TOP_YPIXEL (clist, row) - clist->voffset -
7124            align * (clist->clist_window_height - clist->row_height) +
7125            (2 * align - 1) * CELL_SPACING);
7126
7127   if (value + clist->vadjustment->page_size > clist->vadjustment->upper)
7128     value = clist->vadjustment->upper - clist->vadjustment->page_size;
7129
7130   gtk_adjustment_set_value (clist->vadjustment, value);
7131 }
7132
7133 static void
7134 do_fake_motion (GtkWidget *widget)
7135 {
7136   GdkEvent *event = gdk_event_new (GDK_MOTION_NOTIFY);
7137
7138   event->motion.send_event = TRUE;
7139
7140   gtk_cmclist_motion (widget, (GdkEventMotion *)event);
7141   gdk_event_free (event);
7142 }
7143
7144 static gint
7145 horizontal_timeout (GtkCMCList *clist)
7146 {
7147   clist->htimer = 0;
7148   do_fake_motion (GTK_WIDGET (clist));
7149
7150   return FALSE;
7151 }
7152
7153 static gint
7154 vertical_timeout (GtkCMCList *clist)
7155 {
7156   clist->vtimer = 0;
7157   do_fake_motion (GTK_WIDGET (clist));
7158
7159   return FALSE;
7160 }
7161
7162 static void
7163 remove_grab (GtkCMCList *clist)
7164 {
7165   GtkWidget *widget = GTK_WIDGET (clist);
7166
7167   if (GTK_WIDGET_HAS_GRAB (clist))
7168     {
7169       GdkDisplay *display = gtk_widget_get_display (widget);
7170
7171       gtk_grab_remove (widget);
7172       if (gdk_display_pointer_is_grabbed (display))
7173         gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
7174     }
7175
7176   if (clist->htimer)
7177     {
7178       g_source_remove (clist->htimer);
7179       clist->htimer = 0;
7180     }
7181
7182   if (clist->vtimer)
7183     {
7184       g_source_remove (clist->vtimer);
7185       clist->vtimer = 0;
7186     }
7187 }
7188
7189 /* PUBLIC SORTING FUNCTIONS
7190  * gtk_cmclist_sort
7191  * gtk_cmclist_set_compare_func
7192  * gtk_cmclist_set_auto_sort
7193  * gtk_cmclist_set_sort_type
7194  * gtk_cmclist_set_sort_column
7195  */
7196 void
7197 gtk_cmclist_sort (GtkCMCList *clist)
7198 {
7199   g_return_if_fail (GTK_IS_CMCLIST (clist));
7200
7201   GTK_CMCLIST_GET_CLASS (clist)->sort_list (clist);
7202 }
7203
7204 void
7205 gtk_cmclist_set_compare_func (GtkCMCList            *clist,
7206                             GtkCMCListCompareFunc  cmp_func)
7207 {
7208   g_return_if_fail (GTK_IS_CMCLIST (clist));
7209
7210   clist->compare = (cmp_func) ? cmp_func : default_compare;
7211 }
7212
7213 void
7214 gtk_cmclist_set_auto_sort (GtkCMCList *clist,
7215                          gboolean  auto_sort)
7216 {
7217   g_return_if_fail (GTK_IS_CMCLIST (clist));
7218
7219   if (GTK_CMCLIST_AUTO_SORT(clist) && !auto_sort)
7220     GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_AUTO_SORT);
7221   else if (!GTK_CMCLIST_AUTO_SORT(clist) && auto_sort)
7222     {
7223       GTK_CMCLIST_SET_FLAG (clist, CMCLIST_AUTO_SORT);
7224       gtk_cmclist_sort (clist);
7225     }
7226 }
7227
7228 void
7229 gtk_cmclist_set_sort_type (GtkCMCList    *clist,
7230                          GtkSortType  sort_type)
7231 {
7232   g_return_if_fail (GTK_IS_CMCLIST (clist));
7233
7234   clist->sort_type = sort_type;
7235 }
7236
7237 void
7238 gtk_cmclist_set_sort_column (GtkCMCList *clist,
7239                            gint      column)
7240 {
7241   g_return_if_fail (GTK_IS_CMCLIST (clist));
7242
7243   if (column < 0 || column >= clist->columns)
7244     return;
7245
7246   clist->sort_column = column;
7247 }
7248
7249 /* PRIVATE SORTING FUNCTIONS
7250  *   default_compare
7251  *   real_sort_list
7252  *   gtk_cmclist_merge
7253  *   gtk_cmclist_mergesort
7254  */
7255 static gint
7256 default_compare (GtkCMCList      *clist,
7257                  gconstpointer  ptr1,
7258                  gconstpointer  ptr2)
7259 {
7260   char *text1 = NULL;
7261   char *text2 = NULL;
7262
7263   GtkCMCListRow *row1 = (GtkCMCListRow *) ptr1;
7264   GtkCMCListRow *row2 = (GtkCMCListRow *) ptr2;
7265
7266   switch (row1->cell[clist->sort_column].type)
7267     {
7268     case GTK_CMCELL_TEXT:
7269       text1 = GTK_CMCELL_TEXT (row1->cell[clist->sort_column])->text;
7270       break;
7271     case GTK_CMCELL_PIXTEXT:
7272       text1 = GTK_CMCELL_PIXTEXT (row1->cell[clist->sort_column])->text;
7273       break;
7274     default:
7275       break;
7276     }
7277
7278   switch (row2->cell[clist->sort_column].type)
7279     {
7280     case GTK_CMCELL_TEXT:
7281       text2 = GTK_CMCELL_TEXT (row2->cell[clist->sort_column])->text;
7282       break;
7283     case GTK_CMCELL_PIXTEXT:
7284       text2 = GTK_CMCELL_PIXTEXT (row2->cell[clist->sort_column])->text;
7285       break;
7286     default:
7287       break;
7288     }
7289
7290   if (!text2)
7291     return (text1 != NULL);
7292
7293   if (!text1)
7294     return -1;
7295
7296   return strcmp (text1, text2);
7297 }
7298
7299 static void
7300 real_sort_list (GtkCMCList *clist)
7301 {
7302   GList *list;
7303   GList *work;
7304   gint i;
7305
7306   g_return_if_fail (GTK_IS_CMCLIST (clist));
7307
7308   if (clist->rows <= 1)
7309     return;
7310
7311   if (clist_has_grab (clist))
7312     return;
7313
7314   gtk_cmclist_freeze (clist);
7315
7316   if (clist->anchor != -1 && clist->selection_mode == GTK_SELECTION_MULTIPLE)
7317     {
7318       GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
7319       g_list_free (clist->undo_selection);
7320       g_list_free (clist->undo_unselection);
7321       clist->undo_selection = NULL;
7322       clist->undo_unselection = NULL;
7323     }
7324
7325   clist->row_list = gtk_cmclist_mergesort (clist, clist->row_list, clist->rows);
7326
7327   work = clist->selection;
7328
7329   for (i = 0, list = clist->row_list; i < clist->rows; i++, list = list->next)
7330     {
7331       if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_SELECTED)
7332         {
7333           work->data = GINT_TO_POINTER (i);
7334           work = work->next;
7335         }
7336
7337       if (i == clist->rows - 1)
7338         clist->row_list_end = list;
7339     }
7340
7341   gtk_cmclist_thaw (clist);
7342 }
7343
7344 static GList *
7345 gtk_cmclist_merge (GtkCMCList *clist,
7346                  GList    *a,         /* first list to merge */
7347                  GList    *b)         /* second list to merge */
7348 {
7349   GList z = { 0 };                    /* auxiliary node */
7350   GList *c;
7351   gint cmp;
7352
7353   c = &z;
7354
7355   while (a || b)
7356     {
7357       if (a && !b)
7358         {
7359           c->next = a;
7360           a->prev = c;
7361           c = a;
7362           a = a->next;
7363           break;
7364         }
7365       else if (!a && b)
7366         {
7367           c->next = b;
7368           b->prev = c;
7369           c = b;
7370           b = b->next;
7371           break;
7372         }
7373       else /* a && b */
7374         {
7375           cmp = clist->compare (clist, GTK_CMCLIST_ROW (a), GTK_CMCLIST_ROW (b));
7376           if ((cmp >= 0 && clist->sort_type == GTK_SORT_DESCENDING) ||
7377               (cmp <= 0 && clist->sort_type == GTK_SORT_ASCENDING) ||
7378               (a && !b))
7379             {
7380               c->next = a;
7381               a->prev = c;
7382               c = a;
7383               a = a->next;
7384             }
7385           else
7386             {
7387               c->next = b;
7388               b->prev = c;
7389               c = b;
7390               b = b->next;
7391             }
7392         }
7393     }
7394
7395   z.next->prev = NULL;
7396   return z.next;
7397 }
7398
7399 static GList *
7400 gtk_cmclist_mergesort (GtkCMCList *clist,
7401                      GList    *list,         /* the list to sort */
7402                      gint      num)          /* the list's length */
7403 {
7404   GList *half;
7405   gint i;
7406
7407   if (num <= 1)
7408     {
7409       return list;
7410     }
7411   else
7412     {
7413       /* move "half" to the middle */
7414       half = list;
7415       for (i = 0; i < num / 2; i++)
7416         half = half->next;
7417
7418       /* cut the list in two */
7419       half->prev->next = NULL;
7420       half->prev = NULL;
7421
7422       /* recursively sort both lists */
7423       return gtk_cmclist_merge (clist,
7424                        gtk_cmclist_mergesort (clist, list, num / 2),
7425                        gtk_cmclist_mergesort (clist, half, num - num / 2));
7426     }
7427 }
7428
7429 /************************/
7430
7431 static void
7432 drag_source_info_destroy (gpointer data)
7433 {
7434   GtkCMCListCellInfo *info = data;
7435
7436   g_free (info);
7437 }
7438
7439 static void
7440 drag_dest_info_destroy (gpointer data)
7441 {
7442   GtkCMCListDestInfo *info = data;
7443
7444   g_free (info);
7445 }
7446
7447 static void
7448 drag_dest_cell (GtkCMCList         *clist,
7449                 gint              x,
7450                 gint              y,
7451                 GtkCMCListDestInfo *dest_info)
7452 {
7453   GtkWidget *widget;
7454
7455   widget = GTK_WIDGET (clist);
7456
7457   dest_info->insert_pos = GTK_CMCLIST_DRAG_NONE;
7458
7459   y -= (GTK_CONTAINER (clist)->border_width +
7460         widget->style->ythickness +
7461         clist->column_title_area.height);
7462
7463   dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
7464   if (dest_info->cell.row >= clist->rows)
7465     {
7466       dest_info->cell.row = clist->rows - 1;
7467       y = ROW_TOP_YPIXEL (clist, dest_info->cell.row) + clist->row_height;
7468     }
7469   if (dest_info->cell.row < -1)
7470     dest_info->cell.row = -1;
7471
7472   x -= GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
7473
7474   dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
7475
7476   if (dest_info->cell.row >= 0)
7477     {
7478       gint y_delta;
7479       gint h = 0;
7480
7481       y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);
7482
7483       if (GTK_CMCLIST_DRAW_DRAG_RECT(clist))
7484         {
7485           dest_info->insert_pos = GTK_CMCLIST_DRAG_INTO;
7486           h = clist->row_height / 4;
7487         }
7488       else if (GTK_CMCLIST_DRAW_DRAG_LINE(clist))
7489         {
7490           dest_info->insert_pos = GTK_CMCLIST_DRAG_BEFORE;
7491           h = clist->row_height / 2;
7492         }
7493
7494       if (GTK_CMCLIST_DRAW_DRAG_LINE(clist))
7495         {
7496           if (y_delta < h)
7497             dest_info->insert_pos = GTK_CMCLIST_DRAG_BEFORE;
7498           else if (clist->row_height - y_delta < h)
7499             dest_info->insert_pos = GTK_CMCLIST_DRAG_AFTER;
7500         }
7501     }
7502 }
7503
7504 static void
7505 gtk_cmclist_drag_begin (GtkWidget            *widget,
7506                       GdkDragContext *context)
7507 {
7508   GtkCMCList *clist;
7509   GtkCMCListCellInfo *info;
7510
7511   g_return_if_fail (GTK_IS_CMCLIST (widget));
7512   g_return_if_fail (context != NULL);
7513
7514   clist = GTK_CMCLIST (widget);
7515
7516   clist->drag_button = 0;
7517   remove_grab (clist);
7518
7519   switch (clist->selection_mode)
7520     {
7521     case GTK_SELECTION_MULTIPLE:
7522       update_extended_selection (clist, clist->focus_row);
7523       GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
7524       break;
7525     case GTK_SELECTION_SINGLE:
7526       clist->anchor = -1;
7527     case GTK_SELECTION_BROWSE:
7528       break;
7529     default:
7530       g_assert_not_reached ();
7531     }
7532
7533   info = g_dataset_get_data (context, "gtk-clist-drag-source");
7534
7535   if (!info)
7536     {
7537       info = g_new (GtkCMCListCellInfo, 1);
7538
7539       if (clist->click_cell.row < 0)
7540         clist->click_cell.row = 0;
7541       else if (clist->click_cell.row >= clist->rows)
7542         clist->click_cell.row = clist->rows - 1;
7543       info->row = clist->click_cell.row;
7544       info->column = clist->click_cell.column;
7545
7546       g_dataset_set_data_full (context, "gtk-clist-drag-source", info,
7547                                drag_source_info_destroy);
7548     }
7549
7550   if (GTK_CMCLIST_USE_DRAG_ICONS (clist))
7551     gtk_drag_set_icon_default (context);
7552 }
7553
7554 static void
7555 gtk_cmclist_drag_end (GtkWidget    *widget,
7556                     GdkDragContext *context)
7557 {
7558   GtkCMCList *clist;
7559
7560   g_return_if_fail (GTK_IS_CMCLIST (widget));
7561   g_return_if_fail (context != NULL);
7562
7563   clist = GTK_CMCLIST (widget);
7564
7565   clist->click_cell.row = -1;
7566   clist->click_cell.column = -1;
7567 }
7568
7569 static void
7570 gtk_cmclist_drag_leave (GtkWidget      *widget,
7571                       GdkDragContext *context,
7572                       guint           time)
7573 {
7574   GtkCMCList *clist;
7575   GtkCMCListDestInfo *dest_info;
7576
7577   g_return_if_fail (GTK_IS_CMCLIST (widget));
7578   g_return_if_fail (context != NULL);
7579
7580   clist = GTK_CMCLIST (widget);
7581
7582   dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
7583
7584   if (dest_info)
7585     {
7586       if (dest_info->cell.row >= 0 &&
7587           GTK_CMCLIST_REORDERABLE(clist) &&
7588           gtk_drag_get_source_widget (context) == widget)
7589         {
7590           GList *list;
7591           GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
7592
7593           list = context->targets;
7594           while (list)
7595             {
7596               if (atom == GDK_POINTER_TO_ATOM (list->data))
7597                 {
7598                   GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
7599                     (clist,
7600                      g_list_nth (clist->row_list, dest_info->cell.row)->data,
7601                      dest_info->cell.row, dest_info->insert_pos);
7602                   clist->drag_highlight_row = -1;
7603                   break;
7604                 }
7605               list = list->next;
7606             }
7607         }
7608       g_dataset_remove_data (context, "gtk-clist-drag-dest");
7609     }
7610 }
7611
7612 static gint
7613 gtk_cmclist_drag_motion (GtkWidget      *widget,
7614                        GdkDragContext *context,
7615                        gint            x,
7616                        gint            y,
7617                        guint           time)
7618 {
7619   GtkCMCList *clist;
7620   GtkCMCListDestInfo new_info;
7621   GtkCMCListDestInfo *dest_info;
7622
7623   g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
7624
7625   clist = GTK_CMCLIST (widget);
7626
7627   dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
7628
7629   if (!dest_info)
7630     {
7631       dest_info = g_new (GtkCMCListDestInfo, 1);
7632
7633       dest_info->insert_pos  = GTK_CMCLIST_DRAG_NONE;
7634       dest_info->cell.row    = -1;
7635       dest_info->cell.column = -1;
7636
7637       g_dataset_set_data_full (context, "gtk-clist-drag-dest", dest_info,
7638                                drag_dest_info_destroy);
7639     }
7640
7641   drag_dest_cell (clist, x, y, &new_info);
7642
7643   if (GTK_CMCLIST_REORDERABLE (clist))
7644     {
7645       GList *list;
7646       GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
7647
7648       list = context->targets;
7649       while (list)
7650         {
7651           if (atom == GDK_POINTER_TO_ATOM (list->data))
7652             break;
7653           list = list->next;
7654         }
7655
7656       if (list)
7657         {
7658           if (gtk_drag_get_source_widget (context) != widget ||
7659               new_info.insert_pos == GTK_CMCLIST_DRAG_NONE ||
7660               new_info.cell.row == clist->click_cell.row ||
7661               (new_info.cell.row == clist->click_cell.row - 1 &&
7662                new_info.insert_pos == GTK_CMCLIST_DRAG_AFTER) ||
7663               (new_info.cell.row == clist->click_cell.row + 1 &&
7664                new_info.insert_pos == GTK_CMCLIST_DRAG_BEFORE))
7665             {
7666               if (dest_info->cell.row < 0)
7667                 {
7668                   gdk_drag_status (context, GDK_ACTION_DEFAULT, time);
7669                   return FALSE;
7670                 }
7671               return TRUE;
7672             }
7673
7674           if (new_info.cell.row != dest_info->cell.row ||
7675               (new_info.cell.row == dest_info->cell.row &&
7676                dest_info->insert_pos != new_info.insert_pos))
7677             {
7678               if (dest_info->cell.row >= 0)
7679                 GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
7680                   (clist, g_list_nth (clist->row_list,
7681                                       dest_info->cell.row)->data,
7682                    dest_info->cell.row, dest_info->insert_pos);
7683
7684               dest_info->insert_pos  = new_info.insert_pos;
7685               dest_info->cell.row    = new_info.cell.row;
7686               dest_info->cell.column = new_info.cell.column;
7687
7688               GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
7689                 (clist, g_list_nth (clist->row_list,
7690                                     dest_info->cell.row)->data,
7691                  dest_info->cell.row, dest_info->insert_pos);
7692
7693               clist->drag_highlight_row = dest_info->cell.row;
7694               clist->drag_highlight_pos = dest_info->insert_pos;
7695
7696               gdk_drag_status (context, context->suggested_action, time);
7697             }
7698           return TRUE;
7699         }
7700     }
7701
7702   dest_info->insert_pos  = new_info.insert_pos;
7703   dest_info->cell.row    = new_info.cell.row;
7704   dest_info->cell.column = new_info.cell.column;
7705   return TRUE;
7706 }
7707
7708 static gboolean
7709 gtk_cmclist_drag_drop (GtkWidget      *widget,
7710                      GdkDragContext *context,
7711                      gint            x,
7712                      gint            y,
7713                      guint           time)
7714 {
7715   g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
7716   g_return_val_if_fail (context != NULL, FALSE);
7717
7718   if (GTK_CMCLIST_REORDERABLE (widget) &&
7719       gtk_drag_get_source_widget (context) == widget)
7720     {
7721       GList *list;
7722       GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
7723
7724       list = context->targets;
7725       while (list)
7726         {
7727           if (atom == GDK_POINTER_TO_ATOM (list->data))
7728             return TRUE;
7729           list = list->next;
7730         }
7731     }
7732   return FALSE;
7733 }
7734
7735 static void
7736 gtk_cmclist_drag_data_received (GtkWidget        *widget,
7737                               GdkDragContext   *context,
7738                               gint              x,
7739                               gint              y,
7740                               GtkSelectionData *selection_data,
7741                               guint             info,
7742                               guint             time)
7743 {
7744   GtkCMCList *clist;
7745
7746   g_return_if_fail (GTK_IS_CMCLIST (widget));
7747   g_return_if_fail (context != NULL);
7748   g_return_if_fail (selection_data != NULL);
7749
7750   clist = GTK_CMCLIST (widget);
7751
7752   if (GTK_CMCLIST_REORDERABLE (clist) &&
7753       gtk_drag_get_source_widget (context) == widget &&
7754       selection_data->target ==
7755       gdk_atom_intern_static_string ("gtk-clist-drag-reorder") &&
7756       selection_data->format == 8 &&
7757       selection_data->length == sizeof (GtkCMCListCellInfo))
7758     {
7759       GtkCMCListCellInfo *source_info;
7760
7761       source_info = (GtkCMCListCellInfo *)(selection_data->data);
7762       if (source_info)
7763         {
7764           GtkCMCListDestInfo dest_info;
7765
7766           drag_dest_cell (clist, x, y, &dest_info);
7767
7768           if (dest_info.insert_pos == GTK_CMCLIST_DRAG_AFTER)
7769             dest_info.cell.row++;
7770           if (source_info->row < dest_info.cell.row)
7771             dest_info.cell.row--;
7772           if (dest_info.cell.row != source_info->row)
7773             gtk_cmclist_row_move (clist, source_info->row, dest_info.cell.row);
7774
7775           g_dataset_remove_data (context, "gtk-clist-drag-dest");
7776         }
7777     }
7778 }
7779
7780 static void
7781 gtk_cmclist_drag_data_get (GtkWidget        *widget,
7782                          GdkDragContext   *context,
7783                          GtkSelectionData *selection_data,
7784                          guint             info,
7785                          guint             time)
7786 {
7787   g_return_if_fail (GTK_IS_CMCLIST (widget));
7788   g_return_if_fail (context != NULL);
7789   g_return_if_fail (selection_data != NULL);
7790
7791   if (selection_data->target == gdk_atom_intern_static_string ("gtk-clist-drag-reorder"))
7792     {
7793       GtkCMCListCellInfo *info;
7794
7795       info = g_dataset_get_data (context, "gtk-clist-drag-source");
7796
7797       if (info)
7798         {
7799           GtkCMCListCellInfo ret_info;
7800
7801           ret_info.row = info->row;
7802           ret_info.column = info->column;
7803
7804           gtk_selection_data_set (selection_data, selection_data->target,
7805                                   8, (guchar *) &ret_info,
7806                                   sizeof (GtkCMCListCellInfo));
7807         }
7808     }
7809 }
7810
7811 static void
7812 draw_drag_highlight (GtkCMCList        *clist,
7813                      GtkCMCListRow     *dest_row,
7814                      gint             dest_row_number,
7815                      GtkCMCListDragPos  drag_pos)
7816 {
7817   gint y;
7818
7819   y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
7820
7821   switch (drag_pos)
7822     {
7823     case GTK_CMCLIST_DRAG_NONE:
7824       break;
7825     case GTK_CMCLIST_DRAG_AFTER:
7826       y += clist->row_height + 1;
7827     case GTK_CMCLIST_DRAG_BEFORE:
7828       gdk_draw_line (clist->clist_window, clist->xor_gc,
7829                      0, y, clist->clist_window_width, y);
7830       break;
7831     case GTK_CMCLIST_DRAG_INTO:
7832       gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE, 0, y,
7833                           clist->clist_window_width - 1, clist->row_height);
7834       break;
7835     }
7836 }
7837
7838 void
7839 gtk_cmclist_set_reorderable (GtkCMCList *clist,
7840                            gboolean  reorderable)
7841 {
7842   GtkWidget *widget;
7843
7844   g_return_if_fail (GTK_IS_CMCLIST (clist));
7845
7846   if ((GTK_CMCLIST_REORDERABLE(clist) != 0) == reorderable)
7847     return;
7848
7849   widget = GTK_WIDGET (clist);
7850
7851   if (reorderable)
7852     {
7853       GTK_CMCLIST_SET_FLAG (clist, CMCLIST_REORDERABLE);
7854       gtk_drag_dest_set (widget,
7855                          GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
7856                          &clist_target_table, 1, GDK_ACTION_MOVE);
7857     }
7858   else
7859     {
7860       GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_REORDERABLE);
7861       gtk_drag_dest_unset (GTK_WIDGET (clist));
7862     }
7863 }
7864
7865 void
7866 gtk_cmclist_set_use_drag_icons (GtkCMCList *clist,
7867                               gboolean  use_icons)
7868 {
7869   g_return_if_fail (GTK_IS_CMCLIST (clist));
7870
7871   if (use_icons != 0)
7872     GTK_CMCLIST_SET_FLAG (clist, CMCLIST_USE_DRAG_ICONS);
7873   else
7874     GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_USE_DRAG_ICONS);
7875 }
7876
7877 void
7878 gtk_cmclist_set_button_actions (GtkCMCList *clist,
7879                               guint     button,
7880                               guint8    button_actions)
7881 {
7882   g_return_if_fail (GTK_IS_CMCLIST (clist));
7883
7884   if (button < MAX_BUTTON)
7885     {
7886       if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) ||
7887           GTK_WIDGET_HAS_GRAB (clist))
7888         {
7889           remove_grab (clist);
7890           clist->drag_button = 0;
7891         }
7892
7893       GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
7894
7895       clist->button_actions[button] = button_actions;
7896     }
7897 }