src/ui/gui/customentry.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2005, 2007  Free Software Foundation
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 /*
  18    This widget is a subclass of GtkEntry.  It's an entry widget with a
  19    button on the right hand side.
  20
  21    This code is heavily based upon the GtkSpinButton widget.  Therefore
  22    the copyright notice of that code is pasted below.
  23
  24    Please note however,  this code is covered by the GPL, not the LGPL.
  25 */
  26
  27 /* GTK - The GIMP Toolkit
  28  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  29  *
  30  * GtkSpinButton widget for GTK+
  31  * Copyright (C) 1998 Lars Hamann and Stefan Jeske
  32  *
  33  * This library is free software; you can redistribute it and/or
  34  * modify it under the terms of the GNU Lesser General Public
  35  * License as published by the Free Software Foundation; either
  36  * version 2 of the License, or (at your option) any later version.
  37  *
  38  * This library is distributed in the hope that it will be useful,
  39  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  40  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  41  * Lesser General Public License for more details.
  42  *
  43  * You should have received a copy of the GNU Lesser General Public
  44  * License along with this library.  If not, see
  45  * <http://www.gnu.org/licenses/>.
  46  */
  47
  48
  49 /*
  50  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  51  * file for a list of people on the GTK+ Team.  See the ChangeLog
  52  * files for a list of changes.  These files are distributed with
  53  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  54  */
  55
  56 #include <config.h>
  57
  58 #include <gtk/gtksignal.h>
  59 #include <gtk/gtkentry.h>
  60 #include "customentry.h"
  61
  62
  63 static void psppire_custom_entry_class_init          (PsppireCustomEntryClass *klass);
  64 static void psppire_custom_entry_init                (PsppireCustomEntry      *ce);
  65
  66 static GtkEntryClass *parent_class = NULL;
  67
  68 /* Signals */
  69 enum
  70 {
  71   CLICKED,
  72   n_SIGNALS
  73 };
  74
  75
  76 static guint custom_entry_signals[n_SIGNALS] = {0};
  77
  78
  79 GType
  80 psppire_custom_entry_get_type (void)
  81 {
  82   static GType ce_type = 0;
  83
  84   if (!ce_type)
  85     {
  86       static const GTypeInfo ce_info =
  87         {
  88           sizeof (PsppireCustomEntryClass),
  89           NULL, /* base_init */
  90           NULL, /* base_finalize */
  91           (GClassInitFunc) psppire_custom_entry_class_init,
  92           NULL, /* class_finalize */
  93           NULL, /* class_data */
  94           sizeof (PsppireCustomEntry),
  95           0,
  96           (GInstanceInitFunc) psppire_custom_entry_init,
  97         };
  98
  99       ce_type = g_type_register_static (GTK_TYPE_ENTRY, "PsppireCustomEntry",
 100                                         &ce_info, 0);
 101     }
 102
 103   return ce_type;
 104 }
 105
 106
 107 static void
 108 psppire_custom_entry_map (GtkWidget *widget)
 109 {
 110   if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
 111     {
 112       GTK_WIDGET_CLASS (parent_class)->map (widget);
 113       gdk_window_show (PSPPIRE_CUSTOM_ENTRY (widget)->panel);
 114     }
 115 }
 116
 117 static void
 118 psppire_custom_entry_unmap (GtkWidget *widget)
 119 {
 120   if (GTK_WIDGET_MAPPED (widget))
 121     {
 122       gdk_window_hide (PSPPIRE_CUSTOM_ENTRY (widget)->panel);
 123       GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 124     }
 125 }
 126
 127 static gint psppire_custom_entry_get_button_width (PsppireCustomEntry *custom_entry);
 128
 129 static void
 130 psppire_custom_entry_realize (GtkWidget *widget)
 131 {
 132   PsppireCustomEntry *custom_entry;
 133   GdkWindowAttr attributes;
 134   gint attributes_mask;
 135   guint real_width;
 136   gint button_size ;
 137
 138   custom_entry = PSPPIRE_CUSTOM_ENTRY (widget);
 139
 140   button_size = psppire_custom_entry_get_button_width (custom_entry);
 141
 142   real_width = widget->allocation.width;
 143   widget->allocation.width -= button_size + 2 * widget->style->xthickness;
 144   gtk_widget_set_events (widget, gtk_widget_get_events (widget) |
 145                          GDK_KEY_RELEASE_MASK);
 146   GTK_WIDGET_CLASS (parent_class)->realize (widget);
 147
 148   widget->allocation.width = real_width;
 149
 150   attributes.window_type = GDK_WINDOW_CHILD;
 151   attributes.wclass = GDK_INPUT_OUTPUT;
 152   attributes.visual = gtk_widget_get_visual (widget);
 153   attributes.colormap = gtk_widget_get_colormap (widget);
 154   attributes.event_mask = gtk_widget_get_events (widget);
 155   attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
 156     | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
 157     | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
 158
 159   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 160
 161   attributes.x = (widget->allocation.x +
 162                   widget->allocation.width - button_size -
 163                   2 * widget->style->xthickness);
 164   attributes.y = widget->allocation.y + (widget->allocation.height -
 165                                          widget->requisition.height) / 2;
 166   attributes.width = button_size + 2 * widget->style->xthickness;
 167   attributes.height = widget->requisition.height;
 168
 169   custom_entry->panel = gdk_window_new (gtk_widget_get_parent_window (widget),
 170                                         &attributes, attributes_mask);
 171   gdk_window_set_user_data (custom_entry->panel, widget);
 172
 173   gtk_style_set_background (widget->style, custom_entry->panel, GTK_STATE_NORMAL);
 174
 175
 176   gtk_widget_queue_resize (GTK_WIDGET (custom_entry));
 177 }
 178
 179
 180 #define MIN_BUTTON_WIDTH  6
 181
 182 static gint
 183 psppire_custom_entry_get_button_width (PsppireCustomEntry *custom_entry)
 184 {
 185   const gint size = pango_font_description_get_size
 186     (GTK_WIDGET (custom_entry)->style->font_desc);
 187
 188   gint button_width = MAX (PANGO_PIXELS (size), MIN_BUTTON_WIDTH);
 189
 190   return button_width - button_width % 2; /* force even */
 191 }
 192
 193 /**
 194  * custom_entry_get_shadow_type:
 195  * @custom_entry: a #PsppireCustomEntry
 196  *
 197  * Convenience function to Get the shadow type from the underlying widget's
 198  * style.
 199  *
 200  * Return value: the #GtkShadowType
 201  **/
 202 static gint
 203 psppire_custom_entry_get_shadow_type (PsppireCustomEntry *custom_entry)
 204 {
 205   GtkShadowType rc_shadow_type;
 206
 207   gtk_widget_style_get (GTK_WIDGET (custom_entry), "shadow_type", &rc_shadow_type, NULL);
 208
 209   return rc_shadow_type;
 210 }
 211
 212
 213 static void
 214 psppire_custom_entry_unrealize (GtkWidget *widget)
 215 {
 216   PsppireCustomEntry *ce = PSPPIRE_CUSTOM_ENTRY (widget);
 217
 218   GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 219
 220   if (ce->panel)
 221     {
 222       gdk_window_set_user_data (ce->panel, NULL);
 223       gdk_window_destroy (ce->panel);
 224       ce->panel = NULL;
 225     }
 226 }
 227
 228
 229 static void
 230 psppire_custom_entry_redraw (PsppireCustomEntry *custom_entry)
 231 {
 232   GtkWidget *widget;
 233
 234   widget = GTK_WIDGET (custom_entry);
 235
 236   if (GTK_WIDGET_DRAWABLE (widget))
 237     {
 238       gtk_widget_queue_draw (widget);
 239
 240       /* We must invalidate the panel window ourselves, because it
 241        * is not a child of widget->window
 242        */
 243       gdk_window_invalidate_rect (custom_entry->panel, NULL, TRUE);
 244     }
 245 }
 246
 247
 248 static gint
 249 psppire_custom_entry_expose (GtkWidget      *widget,
 250                      GdkEventExpose *event)
 251 {
 252   PsppireCustomEntry *ce = PSPPIRE_CUSTOM_ENTRY (widget);
 253
 254   g_return_val_if_fail (PSPPIRE_IS_CUSTOM_ENTRY (widget), FALSE);
 255   g_return_val_if_fail (event != NULL, FALSE);
 256
 257   if (GTK_WIDGET_DRAWABLE (widget))
 258     {
 259       gboolean is_editable;
 260       GtkShadowType shadow_type;
 261       GdkRectangle rect;
 262
 263       rect.x = 0;
 264       rect.y = 0;
 265
 266       if (event->window != ce->panel)
 267         GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
 268
 269       gdk_drawable_get_size (ce->panel, &rect.width, &rect.height);
 270
 271       gdk_window_begin_paint_rect (ce->panel, &rect);
 272
 273
 274       shadow_type = psppire_custom_entry_get_shadow_type (ce);
 275
 276       g_object_get (widget, "editable", &is_editable, NULL);
 277
 278       gtk_paint_box (widget->style, ce->panel,
 279                      is_editable ? GTK_STATE_NORMAL: GTK_STATE_INSENSITIVE,
 280                      shadow_type,
 281                      NULL, widget, "customentry",
 282                      rect.x, rect.y, rect.width, rect.height);
 283
 284
 285       gdk_window_end_paint (ce->panel);
 286     }
 287
 288   return FALSE;
 289 }
 290
 291
 292 static gint
 293 psppire_custom_entry_button_press (GtkWidget      *widget,
 294                            GdkEventButton *event);
 295
 296 static void
 297 psppire_custom_entry_size_allocate (GtkWidget     *widget,
 298                             GtkAllocation *allocation);
 299
 300
 301
 302 static void
 303 psppire_custom_entry_class_init (PsppireCustomEntryClass *klass)
 304 {
 305   GObjectClass     *gobject_class = G_OBJECT_CLASS (klass);
 306
 307   GtkWidgetClass   *widget_class;
 308   GtkEntryClass   *entry_class;
 309
 310   parent_class = g_type_class_peek_parent (klass);
 311
 312   widget_class   = (GtkWidgetClass*)   klass;
 313   entry_class   = (GtkEntryClass*)   klass;
 314
 315   widget_class->map = psppire_custom_entry_map;
 316   widget_class->unmap = psppire_custom_entry_unmap;
 317
 318   widget_class->realize = psppire_custom_entry_realize;
 319   widget_class->unrealize = psppire_custom_entry_unrealize;
 320
 321   widget_class->expose_event = psppire_custom_entry_expose;
 322   widget_class->button_press_event = psppire_custom_entry_button_press;
 323
 324   widget_class->size_allocate = psppire_custom_entry_size_allocate;
 325
 326
 327   gtk_widget_class_install_style_property_parser
 328     (widget_class,
 329      g_param_spec_enum ("shadow_type",
 330                         "Shadow Type",
 331                         "Style of bevel around the custom entry button",
 332                         GTK_TYPE_SHADOW_TYPE,
 333                         GTK_SHADOW_ETCHED_IN,
 334                         G_PARAM_READABLE),
 335      gtk_rc_property_parse_enum);
 336
 337   custom_entry_signals[CLICKED] =
 338     g_signal_new ("clicked",
 339                   G_TYPE_FROM_CLASS (gobject_class),
 340                   G_SIGNAL_RUN_LAST,
 341                   0,
 342                   NULL, NULL,
 343                   g_cclosure_marshal_VOID__VOID,
 344                   G_TYPE_NONE,
 345                   0);
 346
 347
 348 }
 349
 350 static void
 351 psppire_custom_entry_init (PsppireCustomEntry *ce)
 352 {
 353 }
 354
 355 GtkWidget*
 356 psppire_custom_entry_new ()
 357 {
 358   return GTK_WIDGET (g_object_new (psppire_custom_entry_get_type (), NULL));
 359 }
 360
 361
 362
 363 static gint
 364 psppire_custom_entry_button_press (GtkWidget *widget,
 365                                    GdkEventButton *event)
 366 {
 367   PsppireCustomEntry *ce = PSPPIRE_CUSTOM_ENTRY (widget);
 368
 369   if (event->window == ce->panel)
 370     {
 371       gboolean is_editable ;
 372       if (!GTK_WIDGET_HAS_FOCUS (widget))
 373         gtk_widget_grab_focus (widget);
 374
 375       g_object_get (ce, "editable", &is_editable, NULL);
 376
 377       if ( event->button == 1 && is_editable )
 378         g_signal_emit (widget, custom_entry_signals[CLICKED], 0);
 379
 380     }
 381   else
 382     return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
 383
 384   return FALSE;
 385 }
 386
 387
 388
 389 static void
 390 psppire_custom_entry_size_allocate (GtkWidget     *widget,
 391                             GtkAllocation *allocation)
 392 {
 393   PsppireCustomEntry *ce;
 394   GtkAllocation entry_allocation;
 395   GtkAllocation panel_allocation;
 396   gint button_width;
 397   gint panel_width;
 398
 399   g_return_if_fail (PSPPIRE_IS_CUSTOM_ENTRY (widget));
 400   g_return_if_fail (allocation != NULL);
 401
 402   ce = PSPPIRE_CUSTOM_ENTRY (widget);
 403   button_width = psppire_custom_entry_get_button_width (ce);
 404   panel_width = button_width + 2 * widget->style->xthickness;
 405
 406   widget->allocation = *allocation;
 407
 408   entry_allocation = *allocation;
 409   entry_allocation.width -= panel_width;
 410
 411   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
 412     {
 413       entry_allocation.x += panel_width;
 414       panel_allocation.x = allocation->x;
 415     }
 416   else
 417     {
 418       panel_allocation.x = allocation->x + allocation->width - panel_width;
 419     }
 420
 421   panel_allocation.width = panel_width;
 422   panel_allocation.height = MIN (widget->requisition.height, allocation->height);
 423
 424   panel_allocation.y = allocation->y + (allocation->height -
 425                                         panel_allocation.height) / 2;
 426
 427   GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, &entry_allocation);
 428
 429   if (GTK_WIDGET_REALIZED (widget))
 430     {
 431       gdk_window_move_resize (PSPPIRE_CUSTOM_ENTRY (widget)->panel,
 432                               panel_allocation.x,
 433                               panel_allocation.y,
 434                               panel_allocation.width,
 435                               panel_allocation.height);
 436     }
 437
 438   psppire_custom_entry_redraw (ce);
 439 }
 440
 441
 442
 443
 444