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