src/geanymenubuttonaction.c

   1 /*
   2  *      geanymenubuttonaction.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2009-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2009-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License along
  18  *      with this program; if not, write to the Free Software Foundation, Inc.,
  19  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 /* GtkAction subclass to provide a GtkMenuToolButton in a toolbar.
  23  * This class is missing the action_create_menu_item() function and so can't be
  24  * used for creating menu items. */
  25
  26
  27 #include "geany.h"
  28 #include "support.h"
  29 #include "utils.h"
  30 #include "geanymenubuttonaction.h"
  31
  32
  33 typedef struct _GeanyMenubuttonActionPrivate            GeanyMenubuttonActionPrivate;
  34
  35 #define GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(obj)       (GEANY_MENU_BUTTON_ACTION(obj)->priv)
  36
  37
  38 struct _GeanyMenubuttonActionPrivate
  39 {
  40         GtkWidget       *menu;
  41
  42         gchar *tooltip_arrow;
  43 };
  44
  45 enum
  46 {
  47         PROP_0,
  48         PROP_TOOLTIP_ARROW
  49 };
  50
  51 enum
  52 {
  53         BUTTON_CLICKED,
  54         LAST_SIGNAL
  55 };
  56 static guint signals[LAST_SIGNAL];
  57
  58
  59 G_DEFINE_TYPE(GeanyMenubuttonAction, geany_menu_button_action, GTK_TYPE_ACTION)
  60
  61
  62 static void geany_menu_button_action_finalize(GObject *object)
  63 {
  64         GeanyMenubuttonActionPrivate *priv = GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(object);
  65
  66         g_object_unref(priv->menu);
  67         g_free(priv->tooltip_arrow);
  68
  69         (* G_OBJECT_CLASS(geany_menu_button_action_parent_class)->finalize)(object);
  70 }
  71
  72
  73 static void delegate_button_activated(GtkAction *action)
  74 {
  75         g_signal_emit(action, signals[BUTTON_CLICKED], 0);
  76 }
  77
  78
  79 static void geany_menu_button_action_set_property(GObject *object, guint prop_id,
  80                                                                                                   const GValue *value, GParamSpec *pspec)
  81 {
  82         switch (prop_id)
  83         {
  84         case PROP_TOOLTIP_ARROW:
  85         {
  86                 GeanyMenubuttonActionPrivate *priv = GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(object);
  87                 g_free(priv->tooltip_arrow);
  88                 priv->tooltip_arrow = g_value_dup_string(value);
  89                 break;
  90         }
  91         default:
  92                 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
  93                 break;
  94         }
  95 }
  96
  97
  98 static GtkWidget *geany_menu_button_action_create_tool_item(GtkAction *action)
  99 {
 100         GtkWidget *toolitem;
 101         GeanyMenubuttonActionPrivate *priv = GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(action);
 102
 103         toolitem = g_object_new(GTK_TYPE_MENU_TOOL_BUTTON, NULL);
 104         gtk_menu_tool_button_set_arrow_tooltip_text(GTK_MENU_TOOL_BUTTON(toolitem), priv->tooltip_arrow);
 105
 106         return toolitem;
 107 }
 108
 109
 110 static void geany_menu_button_action_class_init(GeanyMenubuttonActionClass *klass)
 111 {
 112         GtkActionClass *action_class = GTK_ACTION_CLASS(klass);
 113         GObjectClass *g_object_class = G_OBJECT_CLASS(klass);
 114
 115         g_object_class->finalize = geany_menu_button_action_finalize;
 116         g_object_class->set_property = geany_menu_button_action_set_property;
 117
 118         action_class->activate = delegate_button_activated;
 119         action_class->create_tool_item = geany_menu_button_action_create_tool_item;
 120         action_class->toolbar_item_type = GTK_TYPE_MENU_TOOL_BUTTON;
 121
 122         g_type_class_add_private(klass, sizeof(GeanyMenubuttonActionPrivate));
 123
 124         g_object_class_install_property(g_object_class,
 125                                                                         PROP_TOOLTIP_ARROW,
 126                                                                         g_param_spec_string(
 127                                                                         "tooltip-arrow",
 128                                                                         "Arrow tooltip",
 129                                                                         "A special tooltip for the arrow button",
 130                                                                         "",
 131                                                                         G_PARAM_WRITABLE));
 132
 133         signals[BUTTON_CLICKED] = g_signal_new("button-clicked",
 134                                                                                 G_TYPE_FROM_CLASS(klass),
 135                                                                                 (GSignalFlags) 0,
 136                                                                                 0,
 137                                                                                 0,
 138                                                                                 NULL,
 139                                                                                 g_cclosure_marshal_VOID__VOID,
 140                                                                                 G_TYPE_NONE, 0);
 141 }
 142
 143
 144 static void geany_menu_button_action_init(GeanyMenubuttonAction *action)
 145 {
 146         GeanyMenubuttonActionPrivate *priv;
 147
 148         action->priv = G_TYPE_INSTANCE_GET_PRIVATE(action,
 149                 GEANY_MENU_BUTTON_ACTION_TYPE, GeanyMenubuttonActionPrivate);
 150
 151         priv = action->priv;
 152         priv->tooltip_arrow = NULL;
 153         priv->menu = NULL;
 154 }
 155
 156
 157 GtkAction *geany_menu_button_action_new(const gchar *name,
 158                                                                                 const gchar *label,
 159                                                                             const gchar *tooltip,
 160                                                                             const gchar *tooltip_arrow,
 161                                                                                 const gchar *stock_id)
 162 {
 163         GtkAction *action = g_object_new(GEANY_MENU_BUTTON_ACTION_TYPE,
 164                 "name", name,
 165                 "label", label,
 166                 "tooltip", tooltip,
 167                 "tooltip-arrow", tooltip_arrow,
 168                 "stock-id", stock_id,
 169                 NULL);
 170
 171         return action;
 172 }
 173
 174
 175 GtkWidget *geany_menu_button_action_get_menu(GeanyMenubuttonAction *action)
 176 {
 177         GeanyMenubuttonActionPrivate *priv;
 178
 179         g_return_val_if_fail(action != NULL, NULL);
 180
 181         priv = GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(action);
 182
 183         return priv->menu;
 184 }
 185
 186
 187 static void menu_items_changed_cb(GtkContainer *container, GtkWidget *widget, GeanyMenubuttonAction *action)
 188 {
 189         GeanyMenubuttonActionPrivate *priv;
 190         gboolean enable;
 191         GSList *l;
 192
 193         g_return_if_fail(action != NULL);
 194
 195         priv = GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(action);
 196         if (priv->menu != NULL)
 197         {
 198                 GList *children = gtk_container_get_children(GTK_CONTAINER(priv->menu));
 199
 200                 enable = (g_list_length(children) > 0);
 201                 g_list_free(children);
 202         }
 203         else
 204                 enable = FALSE;
 205
 206         foreach_slist(l, gtk_action_get_proxies(GTK_ACTION(action)))
 207         {
 208                 /* On Windows a GtkImageMenuItem proxy is created for whatever reason. So we filter
 209                  * by type and act only on GtkMenuToolButton proxies. */
 210                 /* TODO find why the GtkImageMenuItem proxy is created */
 211                 if (! GTK_IS_MENU_TOOL_BUTTON(l->data))
 212                         continue;
 213
 214                 if (enable)
 215                 {
 216                         if (gtk_menu_tool_button_get_menu(GTK_MENU_TOOL_BUTTON(l->data)) == NULL)
 217                                 gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(l->data), priv->menu);
 218                 }
 219                 else
 220                         gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(l->data), NULL);
 221         }
 222 }
 223
 224
 225 void geany_menu_button_action_set_menu(GeanyMenubuttonAction *action, GtkWidget *menu)
 226 {
 227         GeanyMenubuttonActionPrivate *priv;
 228
 229         g_return_if_fail(action != NULL);
 230
 231         priv = GEANY_MENU_BUTTON_ACTION_GET_PRIVATE(action);
 232
 233         if (priv->menu != NULL && GTK_IS_WIDGET(priv->menu))
 234                 g_signal_handlers_disconnect_by_func(priv->menu, menu_items_changed_cb, action);
 235         if (menu != NULL)
 236         {
 237                 g_signal_connect(menu, "add", G_CALLBACK(menu_items_changed_cb), action);
 238                 g_signal_connect(menu, "remove", G_CALLBACK(menu_items_changed_cb), action);
 239         }
 240
 241         priv->menu = menu;
 242
 243         menu_items_changed_cb(GTK_CONTAINER(menu), NULL, action);
 244 }