Pileus Git - ~andy/gtk/blob - gtk/gtkradiomenuitem.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #include "gtklabel.h"
  20 #include "gtkradiomenuitem.h"
  21
  22
  23 static void gtk_radio_menu_item_class_init     (GtkRadioMenuItemClass *klass);
  24 static void gtk_radio_menu_item_init           (GtkRadioMenuItem      *radio_menu_item);
  25 static void gtk_radio_menu_item_activate       (GtkMenuItem           *menu_item);
  26 static void gtk_radio_menu_item_draw_indicator (GtkCheckMenuItem      *check_menu_item,
  27                                                 GdkRectangle          *area);
  28
  29
  30 guint
  31 gtk_radio_menu_item_get_type ()
  32 {
  33   static guint radio_menu_item_type = 0;
  34
  35   if (!radio_menu_item_type)
  36     {
  37       GtkTypeInfo radio_menu_item_info =
  38       {
  39         "GtkRadioMenuItem",
  40         sizeof (GtkRadioMenuItem),
  41         sizeof (GtkRadioMenuItemClass),
  42         (GtkClassInitFunc) gtk_radio_menu_item_class_init,
  43         (GtkObjectInitFunc) gtk_radio_menu_item_init,
  44         (GtkArgSetFunc) NULL,
  45         (GtkArgGetFunc) NULL,
  46       };
  47
  48       radio_menu_item_type = gtk_type_unique (gtk_check_menu_item_get_type (), &radio_menu_item_info);
  49     }
  50
  51   return radio_menu_item_type;
  52 }
  53
  54 GtkWidget*
  55 gtk_radio_menu_item_new (GSList *group)
  56 {
  57   GtkRadioMenuItem *radio_menu_item;
  58
  59   radio_menu_item = gtk_type_new (gtk_radio_menu_item_get_type ());
  60
  61   gtk_radio_menu_item_set_group (radio_menu_item, group);
  62
  63   return GTK_WIDGET (radio_menu_item);
  64 }
  65
  66 void
  67 gtk_radio_menu_item_set_group (GtkRadioMenuItem *radio_menu_item,
  68                                GSList           *group)
  69 {
  70   g_return_if_fail (radio_menu_item != NULL);
  71   g_return_if_fail (GTK_IS_RADIO_MENU_ITEM (radio_menu_item));
  72   g_return_if_fail (!g_slist_find (group, radio_menu_item));
  73
  74   if (radio_menu_item->group)
  75     {
  76       GSList *slist;
  77
  78       radio_menu_item->group = g_slist_remove (radio_menu_item->group, radio_menu_item);
  79
  80       for (slist = radio_menu_item->group; slist; slist = slist->next)
  81         {
  82           GtkRadioMenuItem *tmp_item;
  83
  84           tmp_item = slist->data;
  85
  86           tmp_item->group = radio_menu_item->group;
  87         }
  88     }
  89
  90   radio_menu_item->group = g_slist_prepend (group, radio_menu_item);
  91
  92   if (group)
  93     {
  94       GSList *slist;
  95
  96       for (slist = group; slist; slist = slist->next)
  97         {
  98           GtkRadioMenuItem *tmp_item;
  99
 100           tmp_item = slist->data;
 101
 102           tmp_item->group = radio_menu_item->group;
 103         }
 104     }
 105   else
 106     {
 107       GTK_CHECK_MENU_ITEM (radio_menu_item)->active = TRUE;
 108       /* gtk_widget_set_state (GTK_WIDGET (radio_menu_item), GTK_STATE_ACTIVE);
 109        */
 110     }
 111 }
 112
 113 GtkWidget*
 114 gtk_radio_menu_item_new_with_label (GSList *group,
 115                                     const gchar *label)
 116 {
 117   GtkWidget *radio_menu_item;
 118   GtkWidget *label_widget;
 119
 120   radio_menu_item = gtk_radio_menu_item_new (group);
 121   label_widget = gtk_label_new (label);
 122   gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
 123
 124   gtk_container_add (GTK_CONTAINER (radio_menu_item), label_widget);
 125   gtk_widget_show (label_widget);
 126
 127   return radio_menu_item;
 128 }
 129
 130 GSList*
 131 gtk_radio_menu_item_group (GtkRadioMenuItem *radio_menu_item)
 132 {
 133   g_return_val_if_fail (radio_menu_item != NULL, NULL);
 134   g_return_val_if_fail (GTK_IS_RADIO_MENU_ITEM (radio_menu_item), NULL);
 135
 136   return radio_menu_item->group;
 137 }
 138
 139
 140 static void
 141 gtk_radio_menu_item_class_init (GtkRadioMenuItemClass *klass)
 142 {
 143   GtkMenuItemClass *menu_item_class;
 144   GtkCheckMenuItemClass *check_menu_item_class;
 145
 146   menu_item_class = (GtkMenuItemClass*) klass;
 147   check_menu_item_class = (GtkCheckMenuItemClass*) klass;
 148
 149   menu_item_class->activate = gtk_radio_menu_item_activate;
 150
 151   check_menu_item_class->draw_indicator = gtk_radio_menu_item_draw_indicator;
 152 }
 153
 154 static void
 155 gtk_radio_menu_item_init (GtkRadioMenuItem *radio_menu_item)
 156 {
 157   radio_menu_item->group = g_slist_prepend (NULL, radio_menu_item);
 158 }
 159
 160 static void
 161 gtk_radio_menu_item_activate (GtkMenuItem *menu_item)
 162 {
 163   GtkRadioMenuItem *radio_menu_item;
 164   GtkCheckMenuItem *check_menu_item;
 165   GtkCheckMenuItem *tmp_menu_item;
 166   GSList *tmp_list;
 167   gint toggled;
 168
 169   g_return_if_fail (menu_item != NULL);
 170   g_return_if_fail (GTK_IS_RADIO_MENU_ITEM (menu_item));
 171
 172   radio_menu_item = GTK_RADIO_MENU_ITEM (menu_item);
 173   check_menu_item = GTK_CHECK_MENU_ITEM (menu_item);
 174   toggled = FALSE;
 175
 176   if (check_menu_item->active)
 177     {
 178       tmp_menu_item = NULL;
 179       tmp_list = radio_menu_item->group;
 180
 181       while (tmp_list)
 182         {
 183           tmp_menu_item = tmp_list->data;
 184           tmp_list = tmp_list->next;
 185
 186           if (tmp_menu_item->active && (tmp_menu_item != check_menu_item))
 187             break;
 188
 189           tmp_menu_item = NULL;
 190         }
 191
 192       if (tmp_menu_item)
 193         {
 194           toggled = TRUE;
 195           check_menu_item->active = !check_menu_item->active;
 196         }
 197     }
 198   else
 199     {
 200       toggled = TRUE;
 201       check_menu_item->active = !check_menu_item->active;
 202
 203       tmp_list = radio_menu_item->group;
 204       while (tmp_list)
 205         {
 206           tmp_menu_item = tmp_list->data;
 207           tmp_list = tmp_list->next;
 208
 209           if (tmp_menu_item->active && (tmp_menu_item != check_menu_item))
 210             {
 211               gtk_menu_item_activate (GTK_MENU_ITEM (tmp_menu_item));
 212               break;
 213             }
 214         }
 215     }
 216
 217   if (toggled)
 218     gtk_check_menu_item_toggled (check_menu_item);
 219   gtk_widget_queue_draw (GTK_WIDGET (radio_menu_item));
 220 }
 221
 222 static void
 223 gtk_radio_menu_item_draw_indicator (GtkCheckMenuItem *check_menu_item,
 224                                     GdkRectangle     *area)
 225 {
 226   GtkWidget *widget;
 227   GtkStateType state_type;
 228   GtkShadowType shadow_type;
 229   GdkPoint pts[4];
 230   gint width, height;
 231   gint x, y;
 232
 233   g_return_if_fail (check_menu_item != NULL);
 234   g_return_if_fail (GTK_IS_RADIO_MENU_ITEM (check_menu_item));
 235
 236   if (GTK_WIDGET_DRAWABLE (check_menu_item))
 237     {
 238       widget = GTK_WIDGET (check_menu_item);
 239
 240       width = 8;
 241       height = 8;
 242       x = (GTK_CONTAINER (check_menu_item)->border_width +
 243            widget->style->klass->xthickness + 2);
 244       y = (widget->allocation.height - height) / 2;
 245
 246       gdk_window_clear_area (widget->window, x, y, width, height);
 247
 248       if (check_menu_item->active ||
 249           check_menu_item->always_show_toggle ||
 250           (GTK_WIDGET_STATE (check_menu_item) == GTK_STATE_PRELIGHT))
 251         {
 252           state_type = GTK_WIDGET_STATE (widget);
 253           if (check_menu_item->active ||
 254               !check_menu_item->always_show_toggle)
 255             shadow_type = GTK_SHADOW_IN;
 256           else
 257             shadow_type = GTK_SHADOW_OUT;
 258
 259           pts[0].x = x + width / 2;
 260           pts[0].y = y;
 261           pts[1].x = x + width;
 262           pts[1].y = y + height / 2;
 263           pts[2].x = pts[0].x;
 264           pts[2].y = y + height;
 265           pts[3].x = x;
 266           pts[3].y = pts[1].y;
 267
 268           gdk_draw_polygon (widget->window,
 269                             widget->style->bg_gc[state_type],
 270                             TRUE, pts, 4);
 271           gtk_draw_diamond (widget->style, widget->window,
 272                             state_type, shadow_type,
 273                             x, y, width, height);
 274         }
 275     }
 276 }
 277