X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktogglebutton.c;h=999710c1671d93592c7f7a0f86e114a90356dc5d;hb=HEAD;hp=ddc6678ffd206bb1c5170abec02f9d08e62c5866;hpb=e6f6ee193d81fdb7009cb324cf9d90e3d69b6616;p=~andy%2Fgtk

diff --git a/gtk/gtktogglebutton.c b/gtk/gtktogglebutton.c
index ddc6678ff..999710c16 100644
--- a/gtk/gtktogglebutton.c
+++ b/gtk/gtktogglebutton.c
@@ -12,9 +12,7 @@
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
@@ -25,20 +23,83 @@
  */
 
 #include "config.h"
+
+#include "gtktogglebutton.h"
+
+#include "gtkbuttonprivate.h"
 #include "gtklabel.h"
 #include "gtkmain.h"
 #include "gtkmarshalers.h"
-#include "gtktogglebutton.h"
 #include "gtktoggleaction.h"
 #include "gtkactivatable.h"
 #include "gtkprivate.h"
 #include "gtkintl.h"
-#include "gtkalias.h"
+#include "a11y/gtktogglebuttonaccessible.h"
+
+
+/**
+ * SECTION:gtktogglebutton
+ * @Short_description: Create buttons which retain their state
+ * @Title: GtkToggleButton
+ * @See_also: #GtkButton, #GtkCheckButton, #GtkCheckMenuItem
+ *
+ * A #GtkToggleButton is a #GtkButton which will remain 'pressed-in' when
+ * clicked. Clicking again will cause the toggle button to return to its
+ * normal state.
+ *
+ * A toggle button is created by calling either gtk_toggle_button_new() or
+ * gtk_toggle_button_new_with_label(). If using the former, it is advisable to
+ * pack a widget, (such as a #GtkLabel and/or a #GtkImage), into the toggle
+ * button's container. (See #GtkButton for more information).
+ *
+ * The state of a #GtkToggleButton can be set specifically using
+ * gtk_toggle_button_set_active(), and retrieved using
+ * gtk_toggle_button_get_active().
+ *
+ * To simply switch the state of a toggle button, use gtk_toggle_button_toggled().
+ *
+ * <example>
+ * <title>Creating two #GtkToggleButton widgets.</title>
+ * <programlisting>
+ * void make_toggles (void) {
+ *    GtkWidget *dialog, *toggle1, *toggle2;
+ *
+ *    dialog = gtk_dialog_new (<!-- -->);
+ *    toggle1 = gtk_toggle_button_new_with_label ("Hi, i'm a toggle button.");
+ *
+ *    // Makes this toggle button invisible
+ *    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle1), TRUE);
+ *
+ *    g_signal_connect (toggle1, "toggled",
+ *                      G_CALLBACK (output_state), NULL);
+ *    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
+ *                        toggle1, FALSE, FALSE, 2);
+ *
+ *    toggle2 = gtk_toggle_button_new_with_label ("Hi, i'm another toggle button.");
+ *    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle2), FALSE);
+ *    g_signal_connect (toggle2, "toggled",
+ *                      G_CALLBACK (output_state), NULL);
+ *    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
+ *                        toggle2, FALSE, FALSE, 2);
+ *
+ *    gtk_widget_show_all (dialog);
+ * }
+ * </programlisting>
+ * </example>
+ */
+
 
 #define DEFAULT_LEFT_POS  4
 #define DEFAULT_TOP_POS   4
 #define DEFAULT_SPACING   7
 
+struct _GtkToggleButtonPrivate
+{
+  guint active         : 1;
+  guint draw_indicator : 1;
+  guint inconsistent   : 1;
+};
+
 enum {
   TOGGLED,
   LAST_SIGNAL
@@ -52,8 +113,6 @@ enum {
 };
 
 
-static gint gtk_toggle_button_expose        (GtkWidget            *widget,
-					     GdkEventExpose       *event);
 static gboolean gtk_toggle_button_mnemonic_activate  (GtkWidget            *widget,
                                                       gboolean              group_cycling);
 static void gtk_toggle_button_pressed       (GtkButton            *button);
@@ -98,7 +157,6 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
   gobject_class->set_property = gtk_toggle_button_set_property;
   gobject_class->get_property = gtk_toggle_button_get_property;
 
-  widget_class->expose_event = gtk_toggle_button_expose;
   widget_class->mnemonic_activate = gtk_toggle_button_mnemonic_activate;
 
   button_class->pressed = gtk_toggle_button_pressed;
@@ -113,7 +171,7 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
                                    PROP_ACTIVE,
                                    g_param_spec_boolean ("active",
 							 P_("Active"),
-							 P_("If the toggle button should be pressed in or not"),
+							 P_("If the toggle button should be pressed in"),
 							 FALSE,
 							 GTK_PARAM_READWRITE));
 
@@ -133,6 +191,13 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
 							 FALSE,
 							 GTK_PARAM_READWRITE));
 
+  /**
+   * GtkToggleButton::toggled:
+   * @togglebutton: the object which received the signal.
+   *
+   * Should be connected if you wish to perform an action whenever the
+   * #GtkToggleButton's state is changed.
+   */
   toggle_button_signals[TOGGLED] =
     g_signal_new (I_("toggled"),
 		  G_OBJECT_CLASS_TYPE (gobject_class),
@@ -141,14 +206,25 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
 		  NULL, NULL,
 		  _gtk_marshal_VOID__VOID,
 		  G_TYPE_NONE, 0);
+
+  g_type_class_add_private (class, sizeof (GtkToggleButtonPrivate));
+
+  gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE);
 }
 
 static void
 gtk_toggle_button_init (GtkToggleButton *toggle_button)
 {
-  toggle_button->active = FALSE;
-  toggle_button->draw_indicator = FALSE;
-  GTK_BUTTON (toggle_button)->depress_on_activate = TRUE;
+  GtkToggleButtonPrivate *priv;
+
+  toggle_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (toggle_button,
+                                                     GTK_TYPE_TOGGLE_BUTTON,
+                                                     GtkToggleButtonPrivate);
+  priv = toggle_button->priv;
+
+  priv->active = FALSE;
+  priv->draw_indicator = FALSE;
+  GTK_BUTTON (toggle_button)->priv->depress_on_activate = TRUE;
 }
 
 static void
@@ -197,13 +273,27 @@ gtk_toggle_button_sync_action_properties (GtkActivatable *activatable,
   gtk_action_unblock_activate (action);
 }
 
-
+/**
+ * gtk_toggle_button_new:
+ *
+ * Creates a new toggle button. A widget should be packed into the button, as in gtk_button_new().
+ *
+ * Returns: a new toggle button.
+ */
 GtkWidget*
 gtk_toggle_button_new (void)
 {
   return g_object_new (GTK_TYPE_TOGGLE_BUTTON, NULL);
 }
 
+/**
+ * gtk_toggle_button_new_with_label:
+ * @label: a string containing the message to be placed in the toggle button.
+ *
+ * Creates a new toggle button with a text label.
+ *
+ * Returns: a new toggle button.
+ */
 GtkWidget*
 gtk_toggle_button_new_with_label (const gchar *label)
 {
@@ -214,12 +304,13 @@ gtk_toggle_button_new_with_label (const gchar *label)
  * gtk_toggle_button_new_with_mnemonic:
  * @label: the text of the button, with an underscore in front of the
  *         mnemonic character
- * @returns: a new #GtkToggleButton
  *
  * Creates a new #GtkToggleButton containing a label. The label
  * will be created using gtk_label_new_with_mnemonic(), so underscores
  * in @label indicate the mnemonic for the button.
- **/
+ *
+ * Returns: a new #GtkToggleButton
+ */
 GtkWidget*
 gtk_toggle_button_new_with_mnemonic (const gchar *label)
 {
@@ -262,20 +353,19 @@ gtk_toggle_button_get_property (GObject      *object,
 				GValue       *value,
 				GParamSpec   *pspec)
 {
-  GtkToggleButton *tb;
-
-  tb = GTK_TOGGLE_BUTTON (object);
+  GtkToggleButton *tb = GTK_TOGGLE_BUTTON (object);
+  GtkToggleButtonPrivate *priv = tb->priv;
 
   switch (prop_id)
     {
     case PROP_ACTIVE:
-      g_value_set_boolean (value, tb->active);
+      g_value_set_boolean (value, priv->active);
       break;
     case PROP_INCONSISTENT:
-      g_value_set_boolean (value, tb->inconsistent);
+      g_value_set_boolean (value, priv->inconsistent);
       break;
     case PROP_DRAW_INDICATOR:
-      g_value_set_boolean (value, tb->draw_indicator);
+      g_value_set_boolean (value, priv->draw_indicator);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -301,19 +391,35 @@ void
 gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
 			    gboolean         draw_indicator)
 {
+  GtkToggleButtonPrivate *priv;
+
   g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));
 
+  priv = toggle_button->priv;
+
   draw_indicator = draw_indicator ? TRUE : FALSE;
 
-  if (toggle_button->draw_indicator != draw_indicator)
+  if (priv->draw_indicator != draw_indicator)
     {
-      toggle_button->draw_indicator = draw_indicator;
-      GTK_BUTTON (toggle_button)->depress_on_activate = !draw_indicator;
-      
-      if (GTK_WIDGET_VISIBLE (toggle_button))
+      GtkStyleContext *context;
+
+      priv->draw_indicator = draw_indicator;
+      GTK_BUTTON (toggle_button)->priv->depress_on_activate = !draw_indicator;
+
+      if (gtk_widget_get_visible (GTK_WIDGET (toggle_button)))
 	gtk_widget_queue_resize (GTK_WIDGET (toggle_button));
 
       g_object_notify (G_OBJECT (toggle_button), "draw-indicator");
+
+      /* Make toggle buttons conditionally have the "button"
+       * class depending on draw_indicator.
+       */
+      context = gtk_widget_get_style_context (GTK_WIDGET (toggle_button));
+
+      if (draw_indicator)
+        gtk_style_context_remove_class (context, GTK_STYLE_CLASS_BUTTON);
+      else
+        gtk_style_context_add_class (context, GTK_STYLE_CLASS_BUTTON);
     }
 }
 
@@ -332,31 +438,67 @@ gtk_toggle_button_get_mode (GtkToggleButton *toggle_button)
 {
   g_return_val_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button), FALSE);
 
-  return toggle_button->draw_indicator;
+  return toggle_button->priv->draw_indicator;
 }
 
+/**
+ * gtk_toggle_button_set_active:
+ * @toggle_button: a #GtkToggleButton.
+ * @is_active: %TRUE or %FALSE.
+ *
+ * Sets the status of the toggle button. Set to %TRUE if you want the
+ * GtkToggleButton to be 'pressed in', and %FALSE to raise it.
+ * This action causes the #GtkToggleButton::toggled signal and the
+ * #GtkButton::clicked signal to be emitted.
+ */
 void
 gtk_toggle_button_set_active (GtkToggleButton *toggle_button,
 			      gboolean         is_active)
 {
+  GtkToggleButtonPrivate *priv;
+
   g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));
 
+  priv = toggle_button->priv;
+
   is_active = is_active != FALSE;
 
-  if (toggle_button->active != is_active)
+  if (priv->active != is_active)
     gtk_button_clicked (GTK_BUTTON (toggle_button));
 }
 
+void
+_gtk_toggle_button_set_active (GtkToggleButton *toggle_button,
+                               gboolean         is_active)
+{
+  toggle_button->priv->active = is_active;
+}
 
+/**
+ * gtk_toggle_button_get_active:
+ * @toggle_button: a #GtkToggleButton.
+ *
+ * Queries a #GtkToggleButton and returns its current state. Returns %TRUE if
+ * the toggle button is pressed in and %FALSE if it is raised.
+ *
+ * Returns: a #gboolean value.
+ */
 gboolean
 gtk_toggle_button_get_active (GtkToggleButton *toggle_button)
 {
   g_return_val_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button), FALSE);
 
-  return (toggle_button->active) ? TRUE : FALSE;
+  return toggle_button->priv->active;
 }
 
-
+/**
+ * gtk_toggle_button_toggled:
+ * @toggle_button: a #GtkToggleButton.
+ *
+ * Emits the #GtkToggleButton::toggled signal on the
+ * #GtkToggleButton. There is no good reason for an
+ * application ever to call this function.
+ */
 void
 gtk_toggle_button_toggled (GtkToggleButton *toggle_button)
 {
@@ -384,14 +526,18 @@ void
 gtk_toggle_button_set_inconsistent (GtkToggleButton *toggle_button,
                                     gboolean         setting)
 {
+  GtkToggleButtonPrivate *priv;
+
   g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));
-  
+
+  priv = toggle_button->priv;
+
   setting = setting != FALSE;
 
-  if (setting != toggle_button->inconsistent)
+  if (setting != priv->inconsistent)
     {
-      toggle_button->inconsistent = setting;
-      
+      priv->inconsistent = setting;
+
       gtk_toggle_button_update_state (GTK_BUTTON (toggle_button));
       gtk_widget_queue_draw (GTK_WIDGET (toggle_button));
 
@@ -412,39 +558,7 @@ gtk_toggle_button_get_inconsistent (GtkToggleButton *toggle_button)
 {
   g_return_val_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button), FALSE);
 
-  return toggle_button->inconsistent;
-}
-
-static gint
-gtk_toggle_button_expose (GtkWidget      *widget,
-			  GdkEventExpose *event)
-{
-  if (GTK_WIDGET_DRAWABLE (widget))
-    {
-      GtkWidget *child = GTK_BIN (widget)->child;
-      GtkButton *button = GTK_BUTTON (widget);
-      GtkStateType state_type;
-      GtkShadowType shadow_type;
-
-      state_type = GTK_WIDGET_STATE (widget);
-      
-      if (GTK_TOGGLE_BUTTON (widget)->inconsistent)
-        {
-          if (state_type == GTK_STATE_ACTIVE)
-            state_type = GTK_STATE_NORMAL;
-          shadow_type = GTK_SHADOW_ETCHED_IN;
-        }
-      else
-	shadow_type = button->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-
-      _gtk_button_paint (button, &event->area, state_type, shadow_type,
-			 "togglebutton", "togglebuttondefault");
-
-      if (child)
-	gtk_container_propagate_expose (GTK_CONTAINER (widget), child, event);
-    }
-  
-  return FALSE;
+  return toggle_button->priv->inconsistent;
 }
 
 static gboolean
@@ -456,7 +570,7 @@ gtk_toggle_button_mnemonic_activate (GtkWidget *widget,
    * gtk_widget_real_mnemonic_activate() in order to focus the widget even
    * if there is no mnemonic conflict.
    */
-  if (GTK_WIDGET_CAN_FOCUS (widget))
+  if (gtk_widget_get_can_focus (widget))
     gtk_widget_grab_focus (widget);
 
   if (!group_cycling)
@@ -468,7 +582,7 @@ gtk_toggle_button_mnemonic_activate (GtkWidget *widget,
 static void
 gtk_toggle_button_pressed (GtkButton *button)
 {
-  button->button_down = TRUE;
+  button->priv->button_down = TRUE;
 
   gtk_toggle_button_update_state (button);
   gtk_widget_queue_draw (GTK_WIDGET (button));
@@ -477,11 +591,11 @@ gtk_toggle_button_pressed (GtkButton *button)
 static void
 gtk_toggle_button_released (GtkButton *button)
 {
-  if (button->button_down)
+  if (button->priv->button_down)
     {
-      button->button_down = FALSE;
+      button->priv->button_down = FALSE;
 
-      if (button->in_button)
+      if (button->priv->in_button)
 	gtk_button_clicked (button);
 
       gtk_toggle_button_update_state (button);
@@ -493,7 +607,9 @@ static void
 gtk_toggle_button_clicked (GtkButton *button)
 {
   GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (button);
-  toggle_button->active = !toggle_button->active;
+  GtkToggleButtonPrivate *priv = toggle_button->priv;
+
+  priv->active = !priv->active;
 
   gtk_toggle_button_toggled (toggle_button);
 
@@ -509,28 +625,31 @@ static void
 gtk_toggle_button_update_state (GtkButton *button)
 {
   GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (button);
-  gboolean depressed, touchscreen;
-  GtkStateType new_state;
+  GtkToggleButtonPrivate *priv = toggle_button->priv;
+  gboolean depressed;
+  GtkStateFlags new_state = 0;
 
-  g_object_get (gtk_widget_get_settings (GTK_WIDGET (button)),
-                "gtk-touchscreen-mode", &touchscreen,
-                NULL);
+  new_state = gtk_widget_get_state_flags (GTK_WIDGET (button)) &
+    ~(GTK_STATE_FLAG_INCONSISTENT |
+      GTK_STATE_FLAG_PRELIGHT |
+      GTK_STATE_FLAG_ACTIVE);
 
-  if (toggle_button->inconsistent)
+  if (priv->inconsistent)
+    new_state |= GTK_STATE_FLAG_INCONSISTENT;
+
+  if (priv->inconsistent)
     depressed = FALSE;
-  else if (button->in_button && button->button_down)
+  else if (button->priv->in_button && button->priv->button_down)
     depressed = TRUE;
   else
-    depressed = toggle_button->active;
-      
-  if (!touchscreen && button->in_button && (!button->button_down || toggle_button->draw_indicator))
-    new_state = GTK_STATE_PRELIGHT;
-  else
-    new_state = depressed ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL;
+    depressed = priv->active;
 
-  _gtk_button_set_depressed (button, depressed); 
-  gtk_widget_set_state (GTK_WIDGET (toggle_button), new_state);
-}
+  if (button->priv->in_button)
+    new_state |= GTK_STATE_FLAG_PRELIGHT;
 
-#define __GTK_TOGGLE_BUTTON_C__
-#include "gtkaliasdef.c"
+  if (depressed)
+    new_state |= GTK_STATE_FLAG_ACTIVE;
+
+  _gtk_button_set_depressed (button, depressed);
+  gtk_widget_set_state_flags (GTK_WIDGET (toggle_button), new_state, TRUE);
+}