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