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