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