plugins/class-gen/combo-flags.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*  combo-flags.c
   3  *  Copyright (C) 2006 Armin Burgmeier
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program 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
  13  *  GNU Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include "combo-flags.h"
  21
  22 #include <gtk/gtktreeview.h>
  23 #include <gtk/gtktreeselection.h>
  24 #include <gtk/gtkcelllayout.h>
  25 #include <gtk/gtkcellrenderer.h>
  26 #include <gtk/gtkscrolledwindow.h>
  27 #include <gtk/gtkframe.h>
  28 #include <gtk/gtkwindow.h>
  29 #include <gtk/gtkmain.h>
  30
  31 #include <gdk/gdkkeysyms.h>
  32
  33 #include <libanjuta/anjuta-marshal.h>
  34
  35 typedef struct _CgComboFlagsCellInfo CgComboFlagsCellInfo;
  36 struct _CgComboFlagsCellInfo
  37 {
  38   GtkCellRenderer *cell;
  39   GSList *attributes;
  40
  41   GtkCellLayoutDataFunc func;
  42   gpointer func_data;
  43   GDestroyNotify destroy;
  44
  45   guint expand : 1;
  46   guint pack : 1;
  47 };
  48
  49 typedef struct _CgComboFlagsPrivate CgComboFlagsPrivate;
  50 struct _CgComboFlagsPrivate
  51 {
  52         GtkTreeModel* model;
  53
  54         GtkWidget* window;
  55         GtkWidget* treeview;
  56         GtkTreeViewColumn* column;
  57
  58         GSList* cells;
  59
  60         gboolean editing_started;
  61         gboolean editing_canceled;
  62 };
  63
  64 #define CG_COMBO_FLAGS_PRIVATE(o) \
  65         (G_TYPE_INSTANCE_GET_PRIVATE( \
  66                 (o), \
  67                 CG_TYPE_COMBO_FLAGS, \
  68                 CgComboFlagsPrivate \
  69         ))
  70
  71 enum {
  72         PROP_0,
  73         PROP_MODEL
  74 };
  75
  76 enum {
  77         SELECTED,
  78         LAST_SIGNAL
  79 };
  80
  81 static GtkHBoxClass* parent_class = NULL;
  82 static guint combo_flags_signals[LAST_SIGNAL];
  83
  84 static CgComboFlagsCellInfo *
  85 cg_combo_flags_get_cell_info (CgComboFlags *combo,
  86                               GtkCellRenderer *cell)
  87 {
  88         CgComboFlagsPrivate *priv;
  89         GSList *i;
  90
  91         priv = CG_COMBO_FLAGS_PRIVATE (combo);
  92         for (i = priv->cells; i != NULL; i = i->next)
  93         {
  94             CgComboFlagsCellInfo *info = (CgComboFlagsCellInfo *) i->data;
  95
  96             if (info != NULL && info->cell == cell)
  97                         return info;
  98         }
  99
 100         return NULL;
 101 }
 102
 103 static void
 104 cg_combo_flags_cell_layout_pack_start (GtkCellLayout *layout,
 105                                        GtkCellRenderer *cell,
 106                                        gboolean expand)
 107 {
 108         CgComboFlags *combo;
 109         CgComboFlagsPrivate *priv;
 110         CgComboFlagsCellInfo *info;
 111
 112         combo = CG_COMBO_FLAGS (layout);
 113         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 114
 115         g_object_ref (cell);
 116         gtk_object_sink (GTK_OBJECT (cell));
 117
 118         info = g_new0 (CgComboFlagsCellInfo, 1);
 119         info->cell = cell;
 120         info->expand = expand;
 121         info->pack = GTK_PACK_START;
 122
 123         priv->cells = g_slist_append (priv->cells, info);
 124
 125         if (priv->column != NULL)
 126                 gtk_tree_view_column_pack_start (priv->column, cell, expand);
 127 }
 128
 129 static void
 130 cg_combo_flags_cell_layout_pack_end (GtkCellLayout *layout,
 131                                      GtkCellRenderer *cell,
 132                                      gboolean expand)
 133 {
 134         CgComboFlags *combo;
 135         CgComboFlagsPrivate *priv;
 136         CgComboFlagsCellInfo *info;
 137
 138         combo = CG_COMBO_FLAGS (layout);
 139         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 140
 141         g_object_ref (cell);
 142         gtk_object_sink (GTK_OBJECT (cell));
 143
 144         info = g_new0 (CgComboFlagsCellInfo, 1);
 145         info->cell = cell;
 146         info->expand = expand;
 147         info->pack = GTK_PACK_END;
 148
 149         priv->cells = g_slist_append (priv->cells, info);
 150
 151         if (priv->column != NULL)
 152                 gtk_tree_view_column_pack_end (priv->column, cell, expand);
 153 }
 154
 155 static void
 156 cg_combo_flags_cell_layout_clear_attributes (GtkCellLayout *layout,
 157                                              GtkCellRenderer *cell)
 158 {
 159         CgComboFlags *combo;
 160         CgComboFlagsPrivate *priv;
 161         CgComboFlagsCellInfo *info;
 162         GSList *list;
 163
 164         combo = CG_COMBO_FLAGS (layout);
 165         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 166
 167         info = cg_combo_flags_get_cell_info (combo, cell);
 168         g_return_if_fail (info != NULL);
 169
 170         list = info->attributes;
 171         while (list && list->next)
 172         {
 173                 g_free (list->data);
 174                 list = list->next->next;
 175         }
 176
 177         g_slist_free (info->attributes);
 178         info->attributes = NULL;
 179
 180         if (priv->column != NULL)
 181         {
 182             gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (priv->column),
 183                                               cell);
 184         }
 185
 186         gtk_widget_queue_resize (GTK_WIDGET (combo));
 187 }
 188
 189 static void
 190 cg_combo_flags_cell_layout_clear (GtkCellLayout *layout)
 191 {
 192         CgComboFlags *combo;
 193         CgComboFlagsPrivate *priv;
 194         GSList *i;
 195
 196         combo = CG_COMBO_FLAGS (layout);
 197         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 198
 199         if (priv->column != NULL)
 200                 gtk_tree_view_column_clear (priv->column);
 201
 202         for (i = priv->cells; i; i = i->next)
 203         {
 204                 CgComboFlagsCellInfo* info = (CgComboFlagsCellInfo*)i->data;
 205
 206                 cg_combo_flags_cell_layout_clear_attributes (layout, info->cell);
 207                 g_object_unref (info->cell);
 208                 g_free (info);
 209                 i->data = NULL;
 210         }
 211
 212         g_slist_free (priv->cells);
 213         priv->cells = NULL;
 214 }
 215
 216 static void
 217 cg_combo_flags_cell_layout_add_attribute (GtkCellLayout *layout,
 218                                           GtkCellRenderer *cell,
 219                                           const gchar *attribute,
 220                                           gint column)
 221 {
 222         CgComboFlags *combo;
 223         CgComboFlagsPrivate *priv;
 224         CgComboFlagsCellInfo *info;
 225
 226         combo = CG_COMBO_FLAGS (layout);
 227         priv = CG_COMBO_FLAGS_PRIVATE(combo);
 228         info = cg_combo_flags_get_cell_info (combo, cell);
 229
 230         info->attributes = g_slist_prepend (info->attributes,
 231                                             GINT_TO_POINTER (column));
 232         info->attributes = g_slist_prepend (info->attributes,
 233                                             g_strdup (attribute));
 234
 235         if (priv->column != NULL)
 236         {
 237                 gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->column),
 238                                        cell, attribute, column);
 239         }
 240
 241         gtk_widget_queue_resize (GTK_WIDGET (combo));
 242 }
 243
 244 static void
 245 cg_combo_flags_cell_data_func (GtkCellLayout *cell_layout,
 246                                GtkCellRenderer *cell,
 247                                GtkTreeModel *tree_model,
 248                                GtkTreeIter *iter,
 249                                gpointer data)
 250 {
 251   CgComboFlagsCellInfo *info;
 252   info = (CgComboFlagsCellInfo *) data;
 253
 254   if (info->func == NULL)
 255     return;
 256
 257   (*info->func) (cell_layout, cell, tree_model, iter, info->func_data);
 258 }
 259
 260 static void
 261 cg_combo_flags_cell_layout_set_cell_data_func (GtkCellLayout *layout,
 262                                                GtkCellRenderer *cell,
 263                                                GtkCellLayoutDataFunc func,
 264                                                gpointer func_data,
 265                                                GDestroyNotify destroy)
 266 {
 267         CgComboFlags *combo;
 268         CgComboFlagsPrivate *priv;
 269         CgComboFlagsCellInfo *info;
 270         GDestroyNotify old_destroy;
 271
 272         combo = CG_COMBO_FLAGS (layout);
 273         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 274         info = cg_combo_flags_get_cell_info (combo, cell);
 275         g_return_if_fail (info != NULL);
 276
 277         if (info->destroy)
 278         {
 279                 old_destroy = info->destroy;
 280
 281                 info->destroy = NULL;
 282                 old_destroy (info->func_data);
 283         }
 284
 285         info->func = func;
 286         info->func_data = func_data;
 287         info->destroy = destroy;
 288
 289         if (priv->column != NULL)
 290         {
 291         gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (priv->column),
 292                                             cell, func, func_data, NULL);
 293         }
 294
 295         gtk_widget_queue_resize (GTK_WIDGET (combo));
 296 }
 297
 298 static void
 299 cg_combo_flags_cell_layout_reorder (GtkCellLayout *layout,
 300                                     GtkCellRenderer *cell,
 301                                     gint position)
 302 {
 303         CgComboFlags *combo;
 304         CgComboFlagsPrivate *priv;
 305         CgComboFlagsCellInfo *info;
 306         GSList *link;
 307
 308         combo = CG_COMBO_FLAGS (layout);
 309         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 310
 311         info = cg_combo_flags_get_cell_info (combo, cell);
 312         g_return_if_fail (info != NULL);
 313
 314         link = g_slist_find (priv->cells, info);
 315         g_return_if_fail (link != NULL);
 316
 317         priv->cells = g_slist_remove_link (priv->cells, link);
 318         priv->cells = g_slist_insert (priv->cells, info, position);
 319
 320         if (priv->column != NULL)
 321                 gtk_cell_layout_reorder (GTK_CELL_LAYOUT (priv->column), cell, position);
 322
 323         gtk_widget_queue_draw (GTK_WIDGET (combo));
 324 }
 325
 326 static void
 327 cg_combo_flags_cell_editable_start_editing (GtkCellEditable *cell_editable,
 328                                             G_GNUC_UNUSED GdkEvent *event)
 329 {
 330         CgComboFlags *combo;
 331         CgComboFlagsPrivate *priv;
 332
 333         combo = CG_COMBO_FLAGS (cell_editable);
 334         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 335
 336         priv->editing_started = TRUE;
 337         gtk_widget_grab_focus (GTK_WIDGET (combo));
 338         cg_combo_flags_popup (combo);
 339 }
 340
 341 static void
 342 cg_combo_flags_sync_cells (CgComboFlags *combo,
 343                            GtkCellLayout *cell_layout)
 344 {
 345         CgComboFlagsPrivate *priv;
 346         CgComboFlagsCellInfo *info;
 347         GSList *j;
 348         GSList *k;
 349
 350         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 351         for (k = priv->cells; k != NULL; k = k->next)
 352         {
 353                 info = (CgComboFlagsCellInfo *) k->data;
 354
 355                 if (info->pack == GTK_PACK_START)
 356                         gtk_cell_layout_pack_start (cell_layout, info->cell, info->expand);
 357                 else if (info->pack == GTK_PACK_END)
 358                         gtk_cell_layout_pack_end (cell_layout, info->cell, info->expand);
 359
 360                 gtk_cell_layout_set_cell_data_func (cell_layout, info->cell,
 361                                                     cg_combo_flags_cell_data_func,
 362                                                     info, NULL);
 363
 364                 for (j = info->attributes; j != NULL; j = j->next->next)
 365                 {
 366                         gtk_cell_layout_add_attribute (cell_layout, info->cell, j->data,
 367                                                        GPOINTER_TO_INT (j->next->data));
 368                 }
 369         }
 370 }
 371
 372 static void
 373 cg_combo_flags_get_position (CgComboFlags *combo,
 374                              gint *x,
 375                              gint *y,
 376                              gint *width,
 377                              gint *height)
 378 {
 379         CgComboFlagsPrivate *priv;
 380         GdkScreen *screen;
 381         gint monitor_num;
 382         GdkRectangle monitor;
 383         GtkRequisition popup_req;
 384
 385         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 386
 387         g_assert (priv->window != NULL);
 388
 389         gdk_window_get_origin (GTK_WIDGET (combo)->window, x, y);
 390
 391         if (GTK_WIDGET_NO_WINDOW (GTK_WIDGET (combo)))
 392         {
 393                 *x += GTK_WIDGET (combo)->allocation.x;
 394                 *y += GTK_WIDGET (combo)->allocation.y;
 395         }
 396
 397         gtk_widget_size_request (priv->window, &popup_req);
 398
 399         *width = GTK_WIDGET (combo)->allocation.width;
 400         if (popup_req.width > *width) *width = popup_req.width;
 401         *height = popup_req.height;
 402
 403         screen = gtk_widget_get_screen (GTK_WIDGET(combo));
 404         monitor_num =
 405                 gdk_screen_get_monitor_at_window (screen, GTK_WIDGET (combo)->window);
 406
 407         gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
 408
 409         if (*x < monitor.x)
 410         {
 411                 *x = monitor.x;
 412         }
 413         else if (*x + *width > monitor.x + monitor.width)
 414         {
 415                 *x = monitor.x + monitor.width - *width;
 416         }
 417
 418         if (*y + GTK_WIDGET (combo)->allocation.height + *height <=
 419             monitor.y + monitor.height)
 420         {
 421                 *y += GTK_WIDGET (combo)->allocation.height;
 422         }
 423         else if (*y - *height >= monitor.y)
 424         {
 425                 *y -= *height;
 426         }
 427         else if (monitor.y + monitor.height -
 428                  (*y + GTK_WIDGET (combo)->allocation.height) > *y - monitor.y)
 429         {
 430                 *y += GTK_WIDGET (combo)->allocation.height;
 431                 *height = monitor.y + monitor.height - *y;
 432         }
 433         else
 434     {
 435                 *height = *y - monitor.y;
 436                 *y = monitor.y;
 437     }
 438 }
 439
 440 static gboolean
 441 cg_combo_flags_treeview_button_press_cb (G_GNUC_UNUSED GtkWidget *widget,
 442                                          GdkEventButton *event,
 443                                          gpointer data)
 444 {
 445         CgComboFlags *combo;
 446         CgComboFlagsPrivate *priv;
 447         GtkTreeSelection *selection;
 448         GtkTreeIter iter;
 449
 450         combo = CG_COMBO_FLAGS(data);
 451         priv = CG_COMBO_FLAGS_PRIVATE(combo);
 452
 453         switch (event->button)
 454         {
 455         case 1:
 456                 selection =
 457                         gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 458
 459                 if(gtk_tree_selection_get_selected (selection, NULL, &iter) == TRUE)
 460                 {
 461                         g_signal_emit (G_OBJECT (combo), combo_flags_signals[SELECTED],
 462                                        0, &iter, CG_COMBO_FLAGS_SELECTION_TOGGLE);
 463
 464                         return TRUE;
 465                 }
 466
 467                 return FALSE;
 468                 break;
 469         case 3:
 470                 priv->editing_canceled = FALSE;
 471                 cg_combo_flags_popdown (combo);
 472                 return TRUE;
 473                 break;
 474         default:
 475                 return FALSE;
 476                 break;
 477         }
 478 }
 479
 480 static gboolean
 481 cg_combo_flags_treeview_key_press_cb (G_GNUC_UNUSED GtkWidget *widget,
 482                                       GdkEventKey *event,
 483                                       gpointer data)
 484 {
 485         CgComboFlags *combo;
 486         CgComboFlagsPrivate *priv;
 487         GtkTreeSelection *selection;
 488         GtkTreeIter iter;
 489
 490         combo = CG_COMBO_FLAGS (data);
 491         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 492
 493         switch (event->keyval)
 494         {
 495         case GDK_space:
 496         case GDK_KP_Space:
 497                 selection =
 498                         gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 499
 500                 if(gtk_tree_selection_get_selected (selection, NULL, &iter) == TRUE)
 501                 {
 502                         g_signal_emit (G_OBJECT (combo), combo_flags_signals[SELECTED],
 503                                        0, &iter, CG_COMBO_FLAGS_SELECTION_TOGGLE);
 504
 505                         return TRUE;
 506                 }
 507
 508                 return FALSE;
 509                 break;
 510         case GDK_Return:
 511         case GDK_KP_Enter:
 512                 selection =
 513                         gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 514
 515                 if(gtk_tree_selection_get_selected (selection, NULL, &iter) == TRUE)
 516                 {
 517                         g_signal_emit (G_OBJECT (combo), combo_flags_signals[SELECTED],
 518                                        0, &iter, CG_COMBO_FLAGS_SELECTION_SELECT);
 519                 }
 520
 521                 priv->editing_canceled = FALSE;
 522                 cg_combo_flags_popdown (combo);
 523                 return TRUE;
 524                 break;
 525         default:
 526                 return FALSE;
 527                 break;
 528         }
 529 }
 530
 531 static gboolean
 532 cg_combo_flags_window_button_press_cb (G_GNUC_UNUSED GtkWidget *widget,
 533                                        G_GNUC_UNUSED GdkEventButton *event,
 534                                        gpointer data)
 535 {
 536         /* Probably the mouse clicked somewhere else but not into the window,
 537          * otherwise the treeview would have received the event. */
 538         CgComboFlags *combo;
 539         CgComboFlagsPrivate *priv;
 540
 541         combo = CG_COMBO_FLAGS (data);
 542         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 543
 544         priv->editing_canceled = FALSE;
 545         cg_combo_flags_popdown (combo);
 546
 547         return TRUE;
 548 }
 549
 550 static gboolean
 551 cg_combo_flags_window_key_press_cb (G_GNUC_UNUSED GtkWidget *widget,
 552                                     GdkEventKey *event,
 553                                     gpointer data)
 554 {
 555         CgComboFlags *combo;
 556         CgComboFlagsPrivate *priv;
 557
 558         combo = CG_COMBO_FLAGS (data);
 559         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 560
 561         switch (event->keyval)
 562         {
 563         case GDK_Escape:
 564                 priv->editing_canceled = TRUE;
 565                 cg_combo_flags_popdown (combo);
 566                 return TRUE;
 567                 break;
 568         default:
 569                 return FALSE;
 570                 break;
 571         }
 572 }
 573
 574 static void
 575 cg_combo_flags_init (CgComboFlags *combo_flags)
 576 {
 577         CgComboFlagsPrivate *priv;
 578         priv = CG_COMBO_FLAGS_PRIVATE (combo_flags);
 579
 580         priv->model = NULL;
 581         priv->window = NULL;
 582         priv->treeview = NULL;
 583         priv->column = NULL;
 584         priv->cells = NULL;
 585
 586         priv->editing_started = FALSE;
 587         priv->editing_canceled = FALSE;
 588 }
 589
 590 static void
 591 cg_combo_flags_finalize (GObject *object)
 592 {
 593         CgComboFlags *combo_flags;
 594         CgComboFlagsPrivate *priv;
 595
 596         combo_flags = CG_COMBO_FLAGS (object);
 597         priv = CG_COMBO_FLAGS_PRIVATE (combo_flags);
 598
 599         if (priv->window != NULL)
 600                 cg_combo_flags_popdown (combo_flags);
 601
 602         G_OBJECT_CLASS (parent_class)->finalize (object);
 603 }
 604
 605 static void
 606 cg_combo_flags_set_property (GObject *object,
 607                              guint prop_id,
 608                              const GValue *value,
 609                              GParamSpec *pspec)
 610 {
 611         CgComboFlags *combo_flags;
 612         CgComboFlagsPrivate *priv;
 613
 614         g_return_if_fail(CG_IS_COMBO_FLAGS (object));
 615
 616         combo_flags = CG_COMBO_FLAGS (object);
 617         priv = CG_COMBO_FLAGS_PRIVATE (combo_flags);
 618
 619         switch (prop_id)
 620         {
 621         case PROP_MODEL:
 622                 if (priv->model != NULL) g_object_unref (G_OBJECT (priv->model));
 623                 priv->model = GTK_TREE_MODEL (g_value_dup_object (value));
 624
 625                 if (priv->treeview != NULL)
 626                 {
 627                         gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
 628                                                  priv->model);
 629                 }
 630
 631                 break;
 632         default:
 633                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 634                 break;
 635         }
 636 }
 637
 638 static void
 639 cg_combo_flags_get_property (GObject *object,
 640                              guint prop_id,
 641                              GValue *value,
 642                              GParamSpec *pspec)
 643 {
 644         CgComboFlags *combo_flags;
 645         CgComboFlagsPrivate *priv;
 646
 647         g_return_if_fail (CG_IS_COMBO_FLAGS (object));
 648
 649         combo_flags = CG_COMBO_FLAGS (object);
 650         priv = CG_COMBO_FLAGS_PRIVATE (combo_flags);
 651
 652         switch (prop_id)
 653         {
 654         case PROP_MODEL:
 655                 g_value_set_object (value, G_OBJECT (priv->model));
 656                 break;
 657         default:
 658                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 659                 break;
 660         }
 661 }
 662
 663 static void
 664 cg_combo_flags_class_init (CgComboFlagsClass *klass)
 665 {
 666         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 667         parent_class = g_type_class_peek_parent (klass);
 668
 669         g_type_class_add_private (klass, sizeof (CgComboFlagsPrivate));
 670
 671         object_class->finalize = cg_combo_flags_finalize;
 672         object_class->set_property = cg_combo_flags_set_property;
 673         object_class->get_property = cg_combo_flags_get_property;
 674
 675         g_object_class_install_property(object_class,
 676                                         PROP_MODEL,
 677                                         g_param_spec_object("model",
 678                                                             "Model",
 679                                                             "The model used by the CgComboFlags widget",
 680                                                             GTK_TYPE_TREE_MODEL,
 681                                                             G_PARAM_READWRITE));
 682
 683         combo_flags_signals[SELECTED] =
 684                 g_signal_new("selected",
 685                              G_OBJECT_CLASS_TYPE(object_class),
 686                              G_SIGNAL_RUN_LAST,
 687                              0, /* no default handler */
 688                              NULL, NULL,
 689                              anjuta_cclosure_marshal_VOID__BOXED_ENUM,
 690                              G_TYPE_NONE,
 691                              2,
 692                              GTK_TYPE_TREE_ITER,
 693                              CG_TYPE_COMBO_FLAGS_SELECTION_TYPE);
 694 }
 695
 696 static void
 697 cg_combo_flags_cell_layout_init (GtkCellLayoutIface *iface)
 698 {
 699         iface->pack_start = cg_combo_flags_cell_layout_pack_start;
 700         iface->pack_end = cg_combo_flags_cell_layout_pack_end;
 701         iface->reorder = cg_combo_flags_cell_layout_reorder;
 702         iface->clear = cg_combo_flags_cell_layout_clear;
 703         iface->add_attribute = cg_combo_flags_cell_layout_add_attribute;
 704         iface->set_cell_data_func = cg_combo_flags_cell_layout_set_cell_data_func;
 705         iface->clear_attributes = cg_combo_flags_cell_layout_clear_attributes;
 706 }
 707
 708 static void
 709 cg_combo_flags_cell_editable_init (GtkCellEditableIface *iface)
 710 {
 711         iface->start_editing = cg_combo_flags_cell_editable_start_editing;
 712 }
 713
 714 static gboolean
 715 cg_combo_flags_popup_idle (gpointer data)
 716 {
 717         CgComboFlags *combo;
 718         CgComboFlagsPrivate *priv;
 719         GtkTreeSelection* selection;
 720         GtkWidget *toplevel;
 721         GtkWidget *scrolled;
 722         gint height, width, x, y;
 723
 724         combo = CG_COMBO_FLAGS (data);
 725         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 726
 727         g_assert (priv->window == NULL);
 728         priv->window = gtk_window_new (GTK_WINDOW_POPUP);
 729
 730         g_object_ref (G_OBJECT (priv->window));
 731         gtk_window_set_resizable (GTK_WINDOW (priv->window), FALSE);
 732
 733         g_signal_connect (G_OBJECT (priv->window), "key_press_event",
 734                           G_CALLBACK (cg_combo_flags_window_key_press_cb),
 735                           combo);
 736
 737         g_signal_connect (G_OBJECT (priv->window), "button_press_event",
 738                           G_CALLBACK (cg_combo_flags_window_button_press_cb),
 739                           combo);
 740
 741         scrolled = gtk_scrolled_window_new (NULL, NULL);
 742         gtk_container_add (GTK_CONTAINER (priv->window), scrolled);
 743
 744         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
 745                                                                              GTK_SHADOW_ETCHED_IN);
 746
 747         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
 748                                                                     GTK_POLICY_NEVER, GTK_POLICY_NEVER);
 749
 750         gtk_widget_show (scrolled);
 751
 752         priv->treeview = gtk_tree_view_new_with_model (priv->model);
 753         gtk_widget_show (priv->treeview);
 754         gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview);
 755
 756         g_signal_connect (G_OBJECT (priv->treeview), "key_press_event",
 757                           G_CALLBACK (cg_combo_flags_treeview_key_press_cb),
 758                           combo);
 759
 760         g_signal_connect (G_OBJECT (priv->treeview), "button_press_event",
 761                           G_CALLBACK (cg_combo_flags_treeview_button_press_cb),
 762                           combo);
 763
 764         priv->column = gtk_tree_view_column_new ();
 765         g_object_ref (G_OBJECT (priv->column));
 766         cg_combo_flags_sync_cells (combo, GTK_CELL_LAYOUT (priv->column));
 767         gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), priv->column);
 768
 769         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 770         gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
 771
 772         gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE);
 773         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
 774         gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->treeview), TRUE);
 775
 776         toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo));
 777         if (GTK_IS_WINDOW (toplevel))
 778         {
 779                 gtk_window_group_add_window (gtk_window_get_group (
 780                                              GTK_WINDOW (toplevel)),
 781                                              GTK_WINDOW (priv->window));
 782
 783                 gtk_window_set_transient_for (GTK_WINDOW (priv->window),
 784                                               GTK_WINDOW (toplevel));
 785
 786         }
 787
 788         gtk_window_set_screen (GTK_WINDOW (priv->window),
 789                            gtk_widget_get_screen (GTK_WIDGET (combo)));
 790
 791         cg_combo_flags_get_position (combo, &x, &y, &width, &height);
 792         gtk_widget_set_size_request (priv->window, width, height);
 793         gtk_window_move (GTK_WINDOW(priv->window), x, y);
 794         gtk_widget_show (priv->window);
 795
 796         gtk_widget_grab_focus (priv->window);
 797         if (!GTK_WIDGET_HAS_FOCUS (priv->treeview))
 798                 gtk_widget_grab_focus (priv->treeview);
 799
 800         gdk_pointer_grab (priv->window->window, TRUE,
 801                           GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
 802                           GDK_POINTER_MOTION_MASK,
 803                           NULL, NULL, GDK_CURRENT_TIME);
 804
 805         gtk_grab_add (priv->window);
 806
 807         gdk_keyboard_grab (priv->window->window, TRUE, GDK_CURRENT_TIME);
 808         return FALSE;
 809 }
 810
 811 static gboolean
 812 cg_combo_flags_popdown_idle (gpointer data)
 813 {
 814         gtk_widget_destroy (GTK_WIDGET (data));
 815         return FALSE;
 816 }
 817
 818 GType
 819 cg_combo_flags_selection_type_get_type (void)
 820 {
 821         static GType our_type = 0;
 822
 823         if(our_type == 0)
 824         {
 825                 static const GEnumValue values[] =
 826                 {
 827                         { CG_COMBO_FLAGS_SELECTION_NONE, "CG_COMBO_FLAGS_SELECTION_NONE", "none" },
 828                         { CG_COMBO_FLAGS_SELECTION_UNSELECT, "CG_COMBO_FLAGS_SELECTION_UNSELECT", "unselect" },
 829                         { CG_COMBO_FLAGS_SELECTION_SELECT, "CG_COMBO_FLAGS_SELECTION_SELECT", "select" },
 830                         { CG_COMBO_FLAGS_SELECTION_TOGGLE, "CG_COMBO_FLAGS_SELECTION_TOGGLE", "toggle" },
 831                         { 0, NULL, NULL }
 832                 };
 833
 834                 our_type = g_enum_register_static("CgComboFlagsSelectionType", values);
 835         }
 836
 837         return our_type;
 838 }
 839
 840 GType
 841 cg_combo_flags_get_type (void)
 842 {
 843         static GType our_type = 0;
 844
 845         if(our_type == 0)
 846         {
 847                 static const GTypeInfo our_info =
 848                 {
 849                         sizeof (CgComboFlagsClass),
 850                         (GBaseInitFunc) NULL,
 851                         (GBaseFinalizeFunc) NULL,
 852                         (GClassInitFunc) cg_combo_flags_class_init,
 853                         NULL,
 854                         NULL,
 855                         sizeof (CgComboFlags),
 856                         0,
 857                         (GInstanceInitFunc) cg_combo_flags_init,
 858                         NULL
 859                 };
 860
 861                 static const GInterfaceInfo cell_layout_info =
 862                 {
 863                         (GInterfaceInitFunc) cg_combo_flags_cell_layout_init,
 864                         NULL,
 865                         NULL
 866                 };
 867
 868                 static const GInterfaceInfo cell_editable_info =
 869                 {
 870                         (GInterfaceInitFunc) cg_combo_flags_cell_editable_init,
 871                         NULL,
 872                         NULL
 873                 };
 874
 875                 our_type = g_type_register_static(GTK_TYPE_HBOX, "CgComboFlags",
 876                                                   &our_info, 0);
 877
 878                 g_type_add_interface_static (our_type, GTK_TYPE_CELL_LAYOUT,
 879                                              &cell_layout_info);
 880
 881                 g_type_add_interface_static (our_type, GTK_TYPE_CELL_EDITABLE,
 882                                              &cell_editable_info);
 883         }
 884
 885         return our_type;
 886 }
 887
 888 GtkWidget *
 889 cg_combo_flags_new (void)
 890 {
 891         GObject *object;
 892         object = g_object_new (CG_TYPE_COMBO_FLAGS, NULL);
 893         return GTK_WIDGET (object);
 894 }
 895
 896 GtkWidget *
 897 cg_combo_flags_new_with_model (GtkTreeModel *model)
 898 {
 899         GObject *object;
 900         object = g_object_new (CG_TYPE_COMBO_FLAGS, "model", model, NULL);
 901         return GTK_WIDGET (object);
 902 }
 903
 904 void
 905 cg_combo_flags_popup(CgComboFlags *combo)
 906 {
 907         g_idle_add(cg_combo_flags_popup_idle, combo);
 908 }
 909
 910 void
 911 cg_combo_flags_popdown(CgComboFlags *combo)
 912 {
 913         CgComboFlagsPrivate *priv;
 914         priv = CG_COMBO_FLAGS_PRIVATE (combo);
 915
 916         if (priv->window != NULL)
 917         {
 918                 gtk_grab_remove (priv->window);
 919                 gdk_pointer_ungrab (GDK_CURRENT_TIME);
 920                 gdk_keyboard_ungrab (GDK_CURRENT_TIME);
 921                 gtk_widget_hide (priv->window);
 922
 923                 g_object_unref (priv->column);
 924                 g_idle_add (cg_combo_flags_popdown_idle, priv->window);
 925
 926                 priv->window = NULL;
 927                 priv->treeview = NULL;
 928                 priv->column = NULL;
 929
 930                 if (priv->editing_started)
 931                 {
 932                         priv->editing_started = FALSE;
 933                         gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo));
 934
 935                         /* Seems like someone already calls _remove_widget when the
 936                          * cell renderer emits its edited signal (which we rely on if
 937                          * the editing was not canceled). */
 938                         if (priv->editing_canceled)
 939                                 gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo));
 940                 }
 941         }
 942 }
 943
 944 gboolean
 945 cg_combo_flags_editing_canceled (CgComboFlags *combo)
 946 {
 947         return CG_COMBO_FLAGS_PRIVATE (combo)->editing_canceled;
 948 }