callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gtkradiotoolbutton.c gtkradiotoolbutton.h gtktoggletoolbutton.c

Browse Source 
Mon Jun 30 01:20:19 2003  Soeren Sandmann  <sandmann@daimi.au.dk>

	* gtkradiotoolbutton.c
	* gtkradiotoolbutton.h
	* gtktoggletoolbutton.c
	* gtktoggletoolbutton.h
	* gtktoolbutton.c
	* gtktoolbutton.h
	* gtktoolitem.c
	* gtktoolitem.h
	* gtktoolbar.c
	* gtktoolbar.h
	* gtkseparatortoolitem.c
	* gtkseparatortoolitem.h

	New toolbar.
This commit is contained in:
Soeren Sandmann
2003-06-29 23:34:20 +00:00
committed by Søren Sandmann Pedersen
parent 8de1773384
commit fa336d283a
19 changed files with 4775 additions and 1380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
ChangeLog
View File

@ -1,3 +1,20 @@
Mon Jun 30 01:20:19 2003 Soeren Sandmann <sandmann@daimi.au.dk>
* gtkradiotoolbutton.c
* gtkradiotoolbutton.h
* gtktoggletoolbutton.c
* gtktoggletoolbutton.h
* gtktoolbutton.c
* gtktoolbutton.h
* gtktoolitem.c
* gtktoolitem.h
* gtktoolbar.c
* gtktoolbar.h
* gtkseparatortoolitem.c
* gtkseparatortoolitem.h
New toolbar.
2003-06-29 Matthias Clasen <maclas@gmx.de>
* gtk/gtkwidget.c (gtk_widget_class_init): Remove a duplicate parameter from docs, some more formatting

17
ChangeLog.pre-2-10
View File

@ -1,3 +1,20 @@
Mon Jun 30 01:20:19 2003 Soeren Sandmann <sandmann@daimi.au.dk>
* gtkradiotoolbutton.c
* gtkradiotoolbutton.h
* gtktoggletoolbutton.c
* gtktoggletoolbutton.h
* gtktoolbutton.c
* gtktoolbutton.h
* gtktoolitem.c
* gtktoolitem.h
* gtktoolbar.c
* gtktoolbar.h
* gtkseparatortoolitem.c
* gtkseparatortoolitem.h
New toolbar.
2003-06-29 Matthias Clasen <maclas@gmx.de>
* gtk/gtkwidget.c (gtk_widget_class_init): Remove a duplicate parameter from docs, some more formatting

17
ChangeLog.pre-2-4
View File

@ -1,3 +1,20 @@
Mon Jun 30 01:20:19 2003 Soeren Sandmann <sandmann@daimi.au.dk>
* gtkradiotoolbutton.c
* gtkradiotoolbutton.h
* gtktoggletoolbutton.c
* gtktoggletoolbutton.h
* gtktoolbutton.c
* gtktoolbutton.h
* gtktoolitem.c
* gtktoolitem.h
* gtktoolbar.c
* gtktoolbar.h
* gtkseparatortoolitem.c
* gtkseparatortoolitem.h
New toolbar.
2003-06-29 Matthias Clasen <maclas@gmx.de>
* gtk/gtkwidget.c (gtk_widget_class_init): Remove a duplicate parameter from docs, some more formatting

17
ChangeLog.pre-2-6
View File

@ -1,3 +1,20 @@
Mon Jun 30 01:20:19 2003 Soeren Sandmann <sandmann@daimi.au.dk>
* gtkradiotoolbutton.c
* gtkradiotoolbutton.h
* gtktoggletoolbutton.c
* gtktoggletoolbutton.h
* gtktoolbutton.c
* gtktoolbutton.h
* gtktoolitem.c
* gtktoolitem.h
* gtktoolbar.c
* gtktoolbar.h
* gtkseparatortoolitem.c
* gtkseparatortoolitem.h
New toolbar.
2003-06-29 Matthias Clasen <maclas@gmx.de>
* gtk/gtkwidget.c (gtk_widget_class_init): Remove a duplicate parameter from docs, some more formatting

17
ChangeLog.pre-2-8
View File

@ -1,3 +1,20 @@
Mon Jun 30 01:20:19 2003 Soeren Sandmann <sandmann@daimi.au.dk>
* gtkradiotoolbutton.c
* gtkradiotoolbutton.h
* gtktoggletoolbutton.c
* gtktoggletoolbutton.h
* gtktoolbutton.c
* gtktoolbutton.h
* gtktoolitem.c
* gtktoolitem.h
* gtktoolbar.c
* gtktoolbar.h
* gtkseparatortoolitem.c
* gtkseparatortoolitem.h
New toolbar.
2003-06-29 Matthias Clasen <maclas@gmx.de>
* gtk/gtkwidget.c (gtk_widget_class_init): Remove a duplicate parameter from docs, some more formatting

34
gtk/Makefile.am
View File

@ -94,28 +94,27 @@ gtk_public_h_sources = \
gtkalignment.h \
gtkarrow.h \
gtkaspectframe.h \
gtkbbox.h \
gtkbin.h \
gtkbindings.h \
gtkbbox.h \
gtkbox.h \
gtkbutton.h \
gtkcalendar.h \
gtkcelleditable.h \
gtkcellrenderer.h \
gtkcellrendererpixbuf.h \
gtkcellrenderertext.h \
gtkcellrenderertoggle.h \
gtkcheckbutton.h \
gtkcheckmenuitem.h \
gtkseparatormenuitem.h \
gtkclist.h \
gtkclipboard.h \
gtkclist.h \
gtkcolorsel.h \
gtkcolorseldialog.h \
gtkcombo.h \
gtkcontainer.h \
gtkctree.h \
gtkcurve.h \
gtkcellrenderer.h \
gtkcelleditable.h \
gtkcellrenderertext.h \
gtkcellrenderertoggle.h \
gtkcellrendererpixbuf.h \
gtkdebug.h \
gtkdialog.h \
gtkdnd.h \
@ -162,8 +161,8 @@ gtk_public_h_sources = \
gtkmessagedialog.h \
gtkmisc.h \
gtknotebook.h \
gtkoldeditable.h \
gtkobject.h \
gtkoldeditable.h \
gtkoptionmenu.h \
gtkpaned.h \
gtkpixmap.h \
@ -174,6 +173,7 @@ gtk_public_h_sources = \
gtkprogressbar.h \
gtkradiobutton.h \
gtkradiomenuitem.h \
gtkradiotoolbutton.h \
gtkrange.h \
gtkrc.h \
gtkruler.h \
@ -182,16 +182,19 @@ gtk_public_h_sources = \
gtkscrolledwindow.h \
gtkselection.h \
gtkseparator.h \
gtkseparatormenuitem.h \
gtkseparatortoolitem.h \
gtksettings.h \
gtksignal.h \
gtksizegroup.h \
gtksocket.h \
gtkspinbutton.h \
gtkstyle.h \
gtkstatusbar.h \
gtkstock.h \
gtkstyle.h \
gtktable.h \
gtktearoffmenuitem.h \
gtktext.h \
gtktextbuffer.h \
gtktextchild.h \
gtktextdisplay.h \
@ -201,10 +204,12 @@ gtk_public_h_sources = \
gtktexttag.h \
gtktexttagtable.h \
gtktextview.h \
gtktext.h \
gtktipsquery.h \
gtktogglebutton.h \
gtktoggletoolbutton.h \
gtktoolbar.h \
gtktoolbutton.h \
gtktoolitem.h \
gtktooltips.h \
gtktree.h \
gtktreednd.h \
@ -249,6 +254,12 @@ gtk_c_sources = \
gtkaccelgroup.c \
gtkaccelmap.c \
gtkaccellabel.c \
gtkradiotoolbutton.c \
gtktoggletoolbutton.c \
gtktoolbar.c \
gtktoolbutton.c \
gtkseparatortoolitem.c \
gtktoolitem.c \
gtkaccessible.c \
gtkadjustment.c \
gtkalignment.c \
@ -374,7 +385,6 @@ gtk_c_sources = \
gtkthemes.c \
gtktipsquery.c \
gtktogglebutton.c \
gtktoolbar.c \
gtktooltips.c \
gtktree.c \
gtktreeitem.c \

1
gtk/gtkmarshalers.list
View File

@ -29,6 +29,7 @@ BOOLEAN:OBJECT,UINT,FLAGS
BOOLEAN:OBJECT,INT,INT,UINT
BOOLEAN:OBJECT,STRING,STRING,BOXED
BOOLEAN:OBJECT,BOXED,BOXED
BOOLEAN:OBJECT,STRING,STRING
BOOLEAN:INT,INT
BOOLEAN:VOID
BOOLEAN:BOOLEAN

147
gtk/gtkradiotoolbutton.c Normal file
View File

@ -0,0 +1,147 @@
/* gtkradiotoolbutton.c
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#include "gtkradiotoolbutton.h"
#include "gtkradiobutton.h"
#include "gtkintl.h"
static void gtk_radio_tool_button_init (GtkRadioToolButton *button);
static void gtk_radio_tool_button_class_init (GtkRadioToolButtonClass *klass);
GType
gtk_radio_tool_button_get_type (void)
{
static GType type = 0;
if (!type)
{
static const GTypeInfo type_info =
{
sizeof (GtkRadioToolButtonClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gtk_radio_tool_button_class_init,
(GClassFinalizeFunc) NULL,
NULL,
sizeof (GtkRadioToolButton),
0, /* n_preallocs */
(GInstanceInitFunc) gtk_radio_tool_button_init
};
type = g_type_register_static (GTK_TYPE_TOGGLE_TOOL_BUTTON,
"GtkRadioToolButton", &type_info, 0);
}
return type;
}
static void
gtk_radio_tool_button_class_init (GtkRadioToolButtonClass *klass)
{
GtkToolButtonClass *toolbutton_class;
toolbutton_class = (GtkToolButtonClass *)klass;
toolbutton_class->button_type = GTK_TYPE_RADIO_BUTTON;
}
static void
gtk_radio_tool_button_init (GtkRadioToolButton *button)
{
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (GTK_TOOL_BUTTON (button)->button), FALSE);
}
GtkToolItem *
gtk_radio_tool_button_new (GSList *group)
{
GtkRadioToolButton *button;
button = g_object_new (GTK_TYPE_RADIO_TOOL_BUTTON,
NULL);
gtk_radio_tool_button_set_group (button, group);
return GTK_TOOL_ITEM (button);
}
GtkToolItem *
gtk_radio_tool_button_new_from_stock (GSList *group,
const gchar *stock_id)
{
GtkRadioToolButton *button;
g_return_val_if_fail (stock_id != NULL, NULL);
button = g_object_new (GTK_TYPE_RADIO_TOOL_BUTTON,
"stock_id", stock_id,
NULL);
gtk_radio_tool_button_set_group (button, group);
return GTK_TOOL_ITEM (button);
}
GtkToolItem *
gtk_radio_tool_button_new_from_widget (GtkWidget *group,
const gchar *stock_id)
{
GSList *list = NULL;
g_return_val_if_fail (GTK_IS_RADIO_TOOL_BUTTON (group), NULL);
if (group)
list = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (group));
return gtk_radio_tool_button_new_from_stock (list, stock_id);
}
GtkToolItem *
gtk_radio_tool_button_new_with_stock_from_widget (GtkWidget *group)
{
GSList *list = NULL;
g_return_val_if_fail (GTK_IS_RADIO_TOOL_BUTTON (group), NULL);
if (group)
list = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (group));
return gtk_radio_tool_button_new (list);
}
GSList *
gtk_radio_tool_button_get_group (GtkRadioToolButton *button)
{
g_return_val_if_fail (GTK_IS_RADIO_TOOL_BUTTON (button), NULL);
return gtk_radio_button_get_group (GTK_RADIO_BUTTON (GTK_TOOL_BUTTON (button)->button));
}
void
gtk_radio_tool_button_set_group (GtkRadioToolButton *button,
GSList *group)
{
g_return_if_fail (GTK_IS_RADIO_TOOL_BUTTON (button));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (GTK_TOOL_BUTTON (button)->button), group);
}

62
gtk/gtkradiotoolbutton.h Normal file
View File

@ -0,0 +1,62 @@
/* gtkradiotoolbutton.h
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#ifndef __GTK_RADIO_TOOL_BUTTON_H__
#define __GTK_RADIO_TOOL_BUTTON_H__
#include "gtktoggletoolbutton.h"
#define GTK_TYPE_RADIO_TOOL_BUTTON (gtk_radio_tool_button_get_type ())
#define GTK_RADIO_TOOL_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_TOOL_BUTTON, GtkRadioToolButton))
#define GTK_RADIO_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_TOOL_BUTTON, GtkRadioToolButtonClass))
#define GTK_IS_RADIO_TOOL_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_TOOL_BUTTON))
#define GTK_IS_RADIO_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GTK_TYPE_RADIO_TOOL_BUTTON))
#define GTK_RADIO_TOOL_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_RADIO_TOOL_BUTTON, GtkRadioToolButtonClass))
typedef struct _GtkRadioToolButton GtkRadioToolButton;
typedef struct _GtkRadioToolButtonClass GtkRadioToolButtonClass;
struct _GtkRadioToolButton
{
GtkToggleToolButton parent;
};
struct _GtkRadioToolButtonClass
{
GtkToggleToolButtonClass parent_class;
};
GType gtk_radio_tool_button_get_type (void) G_GNUC_CONST;
GtkToolItem *gtk_radio_tool_button_new (GSList *group);
GtkToolItem *gtk_radio_tool_button_new_from_stock (GSList *group,
const gchar *stock_id);
GtkToolItem *gtk_radio_tool_button_new_from_widget (GtkWidget *group,
const gchar *stock_id);
GtkToolItem *gtk_radio_tool_button_new_with_stock_from_widget (GtkWidget *group);
GSList * gtk_radio_tool_button_get_group (GtkRadioToolButton *button);
void gtk_radio_tool_button_set_group (GtkRadioToolButton *button,
GSList *group);
#endif /* __GTK_RADIO_TOOL_BUTTON_H__ */

90
gtk/gtkseparatortoolitem.c Normal file
View File

@ -0,0 +1,90 @@
/* gtkseparatortoolitem.c
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#include "gtkseparatormenuitem.h"
#include "gtkseparatortoolitem.h"
#include "gtkintl.h"
static void gtk_separator_tool_item_class_init (GtkSeparatorToolItemClass*class);
static void gtk_separator_tool_item_add (GtkContainer *container,
GtkWidget *child);
static GObjectClass *parent_class = NULL;
GType
gtk_separator_tool_item_get_type (void)
{
static GType type = 0;
if (!type)
{
static const GTypeInfo type_info =
{
sizeof (GtkSeparatorToolItemClass),
(GBaseInitFunc) 0,
(GBaseFinalizeFunc) 0,
(GClassInitFunc) gtk_separator_tool_item_class_init,
(GClassFinalizeFunc) 0,
NULL,
sizeof (GtkSeparatorToolItem),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
type = g_type_register_static (GTK_TYPE_TOOL_ITEM,
"GtkSeparatorToolItem", &type_info, 0);
}
return type;
}
static void
gtk_separator_tool_item_class_init (GtkSeparatorToolItemClass *class)
{
GtkContainerClass *container_class;
GtkToolItemClass *toolitem_class;
parent_class = g_type_class_peek_parent (class);
container_class = (GtkContainerClass *)class;
toolitem_class = (GtkToolItemClass *)class;
container_class->add = gtk_separator_tool_item_add;
}
static void
gtk_separator_tool_item_add (GtkContainer *container,
GtkWidget *child)
{
g_warning("attempt to add a child to an GtkSeparatorToolItem");
}
GtkToolItem *
gtk_separator_tool_item_new (void)
{
GtkToolItem *self;
self = g_object_new (GTK_TYPE_SEPARATOR_TOOL_ITEM,
NULL);
return self;
}

50
gtk/gtkseparatortoolitem.h Normal file
View File

@ -0,0 +1,50 @@
/* gtktoggletoolbutton.h
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#ifndef __GTK_SEPARATOR_TOOL_ITEM_H__
#define __GTK_SEPARATOR_TOOL_ITEM_H__
#include "gtktoolitem.h"
#define GTK_TYPE_SEPARATOR_TOOL_ITEM (gtk_separator_tool_item_get_type ())
#define GTK_SEPARATOR_TOOL_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM, GtkSeparatorToolItem))
#define GTK_SEPARATOR_TOOL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR_TOOL_ITEM, GtkSeparatorToolItemClass))
#define GTK_IS_SEPARATOR_TOOL_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM))
#define GTK_IS_SEPARATOR_TOOL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM))
#define GTK_SEPARATOR_TOOL_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM, GtkSeparatorToolItemClass))
typedef struct _GtkSeparatorToolItem GtkSeparatorToolItem;
typedef struct _GtkSeparatorToolItemClass GtkSeparatorToolItemClass;
struct _GtkSeparatorToolItem
{
GtkToolItem parent;
};
struct _GtkSeparatorToolItemClass
{
GtkToolItemClass parent_class;
};
GType gtk_separator_tool_item_get_type (void) G_GNUC_CONST;
GtkToolItem *gtk_separator_tool_item_new (void);
#endif /* __GTK_SEPARATOR_TOOL_ITEM_H__ */

244
gtk/gtktoggletoolbutton.c Normal file
View File

@ -0,0 +1,244 @@
/* gtktoggletoolbutton.c
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#include "gtktoggletoolbutton.h"
#include "gtkcheckmenuitem.h"
#include "gtklabel.h"
#include "gtktogglebutton.h"
#include "gtkstock.h"
#include "gtkintl.h"
#define MENU_ID "gtk-toggle-tool-button-menu-id"
enum {
TOGGLED,
LAST_SIGNAL
};
static void gtk_toggle_tool_button_init (GtkToggleToolButton *button);
static void gtk_toggle_tool_button_class_init (GtkToggleToolButtonClass *klass);
static gboolean gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *button);
static void button_toggled (GtkWidget *widget,
GtkToggleToolButton *button);
static void menu_item_activated (GtkWidget *widget,
GtkToggleToolButton *button);
static GObjectClass *parent_class = NULL;
static guint toggle_signals[LAST_SIGNAL] = { 0 };
GType
gtk_toggle_tool_button_get_type (void)
{
static GType type = 0;
if (!type)
{
static const GTypeInfo type_info =
{
sizeof (GtkToggleToolButtonClass),
(GBaseInitFunc) 0,
(GBaseFinalizeFunc) 0,
(GClassInitFunc) gtk_toggle_tool_button_class_init,
(GClassFinalizeFunc) 0,
NULL,
sizeof (GtkToggleToolButton),
0, /* n_preallocs */
(GInstanceInitFunc) gtk_toggle_tool_button_init
};
type = g_type_register_static (GTK_TYPE_TOOL_BUTTON,
"GtkToggleToolButton", &type_info, 0);
}
return type;
}
static void
gtk_toggle_tool_button_class_init (GtkToggleToolButtonClass *klass)
{
GObjectClass *object_class;
GtkToolItemClass *toolitem_class;
GtkToolButtonClass *toolbutton_class;
parent_class = g_type_class_peek_parent (klass);
object_class = (GObjectClass *)klass;
toolitem_class = (GtkToolItemClass *)klass;
toolbutton_class = (GtkToolButtonClass *)klass;
toolitem_class->create_menu_proxy = gtk_toggle_tool_button_create_menu_proxy;
toolbutton_class->button_type = GTK_TYPE_TOGGLE_BUTTON;
toggle_signals[TOGGLED] =
g_signal_new ("toggled",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToggleToolButtonClass, toggled),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
gtk_toggle_tool_button_init (GtkToggleToolButton *button)
{
g_signal_connect_object (GTK_TOOL_BUTTON (button)->button, "toggled",
G_CALLBACK (button_toggled), button, 0);
}
static gboolean
gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (item);
GtkToggleToolButton *toggle_tool_button = GTK_TOGGLE_TOOL_BUTTON (item);
GtkWidget *menu_item = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label = "";
if (tool_button->label_widget && GTK_IS_LABEL (tool_button->label_widget))
label = gtk_label_get_label (GTK_LABEL (tool_button->label_widget));
else if (tool_button->label_text)
{
label = tool_button->label_text;
use_mnemonic = tool_button->use_underline;
}
else if (tool_button->stock_id && gtk_stock_lookup (tool_button->stock_id, &stock_item))
label = stock_item.label;
if (use_mnemonic)
menu_item = gtk_check_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
toggle_tool_button->active);
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object (G_CALLBACK (menu_item_activated),
G_OBJECT (toggle_tool_button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item);
return TRUE;
}
/* There are two activatable widgets, a toggle button and a menu item.
*
* If a widget is activated and the state of the tool button is the same as
* the new state of the activated widget, then the other widget was the one
* that was activated by the user and updated the tool button's state.
*
* If the state of the tool button is not the same as the new state of the
* activated widget, then the activation was activated by the user, and the
* widget needs to make sure the tool button is updated before the other
* widget is activated. This will make sure the other widget a tool button
* in a state that matches its own new state.
*/
static void
menu_item_activated (GtkWidget *menu_item,
GtkToggleToolButton *toggle_tool_button)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (toggle_tool_button);
gboolean menu_active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu_item));
if (toggle_tool_button->active != menu_active)
{
toggle_tool_button->active = menu_active;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tool_button->button),
toggle_tool_button->active);
g_signal_emit (G_OBJECT (toggle_tool_button), toggle_signals[TOGGLED], 0);
}
}
static void
button_toggled (GtkWidget *widget,
GtkToggleToolButton *toggle_tool_button)
{
gboolean toggle_active = GTK_TOGGLE_BUTTON (widget)->active;
if (toggle_tool_button->active != toggle_active)
{
GtkWidget *menu_item;
toggle_tool_button->active = toggle_active;
if ((menu_item =
gtk_tool_item_get_proxy_menu_item (GTK_TOOL_ITEM (toggle_tool_button), MENU_ID)))
{
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
toggle_tool_button->active);
}
g_signal_emit (G_OBJECT (toggle_tool_button), toggle_signals[TOGGLED], 0);
}
}
GtkToolItem *
gtk_toggle_tool_button_new (void)
{
GtkToolButton *button;
button = g_object_new (GTK_TYPE_TOGGLE_TOOL_BUTTON,
NULL);
return GTK_TOOL_ITEM (button);
}
GtkToolItem *
gtk_toggle_tool_button_new_from_stock (const gchar *stock_id)
{
GtkToolButton *button;
g_return_val_if_fail (stock_id != NULL, NULL);
button = g_object_new (GTK_TYPE_TOGGLE_TOOL_BUTTON,
"stock_id", stock_id,
NULL);
return GTK_TOOL_ITEM (button);
}
void
gtk_toggle_tool_button_set_active (GtkToggleToolButton *button,
gboolean is_active)
{
g_return_if_fail (GTK_IS_TOGGLE_TOOL_BUTTON (button));
is_active = is_active != FALSE;
if (button->active != is_active)
gtk_button_clicked (GTK_BUTTON (GTK_TOOL_BUTTON (button)->button));
}
gboolean
gtk_toggle_tool_button_get_active (GtkToggleToolButton *button)
{
g_return_val_if_fail (GTK_IS_TOGGLE_TOOL_BUTTON (button), FALSE);
return button->active;
}

68
gtk/gtktoggletoolbutton.h Normal file
View File

@ -0,0 +1,68 @@
/* gtktoggletoolbutton.h
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#ifndef __GTK_TOGGLE_TOOL_BUTTON_H__
#define __GTK_TOGGLE_TOOL_BUTTON_H__
#include "gtktoolbutton.h"
G_BEGIN_DECLS
#define GTK_TYPE_TOGGLE_TOOL_BUTTON (gtk_toggle_tool_button_get_type ())
#define GTK_TOGGLE_TOOL_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON, GtkToggleToolButton))
#define GTK_TOGGLE_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_TOOL_BUTTON, GtkToggleToolButtonClass))
#define GTK_IS_TOGGLE_TOOL_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON))
#define GTK_IS_TOGGLE_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON))
#define GTK_TOGGLE_TOOL_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON, GtkToggleToolButtonClass))
typedef struct _GtkToggleToolButton GtkToggleToolButton;
typedef struct _GtkToggleToolButtonClass GtkToggleToolButtonClass;
struct _GtkToggleToolButton
{
GtkToolButton parent;
/*< private >*/
GtkWidget *menu_item;
guint active : 1;
};
struct _GtkToggleToolButtonClass
{
GtkToolButtonClass parent_class;
/* signal */
void (* toggled) (GtkToggleToolButton *button);
};
GType gtk_toggle_tool_button_get_type (void) G_GNUC_CONST;
GtkToolItem *gtk_toggle_tool_button_new (void);
GtkToolItem *gtk_toggle_tool_button_new_from_stock (const gchar *stock_id);
void gtk_toggle_tool_button_set_active (GtkToggleToolButton *button,
gboolean is_active);
gboolean gtk_toggle_tool_button_get_active (GtkToggleToolButton *button);
G_END_DECLS
#endif /* __GTK_TOGGLE_TOOL_BUTTON_H__ */

3490
gtk/gtktoolbar.c
View File

File diff suppressed because it is too large Load Diff

173
gtk/gtktoolbar.h
View File

@ -2,6 +2,10 @@
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* GtkToolbar copyright (C) Federico Mena
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
@ -28,30 +32,33 @@
#ifndef __GTK_TOOLBAR_H__
#define __GTK_TOOLBAR_H__
#include <gdk/gdk.h>
#include <gtk/gtkcontainer.h>
#include <gtk/gtkenums.h>
#include <gtk/gtktooltips.h>
#include "gtktoolitem.h"
#ifndef GTK_DISABLE_DEPRECATED
/* Not needed, retained for compatibility -Yosh */
#include <gtk/gtkpixmap.h>
#include <gtk/gtksignal.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define GTK_TYPE_TOOLBAR (gtk_toolbar_get_type ())
#define GTK_TOOLBAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLBAR, GtkToolbar))
#define GTK_TOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLBAR, GtkToolbarClass))
#define GTK_IS_TOOLBAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLBAR))
#define GTK_IS_TOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLBAR))
#define GTK_TOOLBAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLBAR, GtkToolbarClass))
G_BEGIN_DECLS
#define GTK_TYPE_TOOLBAR (gtk_toolbar_get_type ())
#define GTK_TOOLBAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLBAR, GtkToolbar))
#define GTK_TOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLBAR, GtkToolbarClass))
#define GTK_IS_TOOLBAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLBAR))
#define GTK_IS_TOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLBAR))
#define GTK_TOOLBAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLBAR, GtkToolbarClass))
#define GTK_TOOLBAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_TOOLBAR, GtkToolbarPrivate))
#ifndef GTK_DISABLE_DEPRECATED
typedef enum
{
GTK_TOOLBAR_CHILD_SPACE,
@ -61,15 +68,7 @@ typedef enum
GTK_TOOLBAR_CHILD_WIDGET
} GtkToolbarChildType;
typedef enum
{
GTK_TOOLBAR_SPACE_EMPTY,
GTK_TOOLBAR_SPACE_LINE
} GtkToolbarSpaceStyle;
typedef struct _GtkToolbarChild GtkToolbarChild;
typedef struct _GtkToolbar GtkToolbar;
typedef struct _GtkToolbarClass GtkToolbarClass;
typedef struct _GtkToolbarChild GtkToolbarChild;
struct _GtkToolbarChild
{
@ -79,6 +78,18 @@ struct _GtkToolbarChild
GtkWidget *label;
};
typedef enum
{
GTK_TOOLBAR_SPACE_EMPTY,
GTK_TOOLBAR_SPACE_LINE
} GtkToolbarSpaceStyle;
#endif /* GTK_DISABLE_DEPRECATED */
typedef struct _GtkToolbar GtkToolbar;
typedef struct _GtkToolbarClass GtkToolbarClass;
typedef struct _GtkToolbarPrivate GtkToolbarPrivate;
struct _GtkToolbar
{
GtkContainer container;
@ -90,13 +101,13 @@ struct _GtkToolbar
GtkIconSize icon_size;
GtkTooltips *tooltips;
gint button_maxw;
gint button_maxh;
gint button_maxw; /* maximum width of homogeneous children */
gint button_maxh; /* maximum height of homogeneous children */
guint style_set_connection;
guint icon_size_connection;
guint style_set : 1;
guint icon_size_set : 1;
};
@ -105,45 +116,76 @@ struct _GtkToolbarClass
{
GtkContainerClass parent_class;
void (* orientation_changed) (GtkToolbar *toolbar,
GtkOrientation orientation);
void (* style_changed) (GtkToolbar *toolbar,
GtkToolbarStyle style);
/* signals */
void (* orientation_changed) (GtkToolbar *toolbar,
GtkOrientation orientation);
void (* style_changed) (GtkToolbar *toolbar,
GtkToolbarStyle style);
void (* popup_context_menu) (GtkToolbar *toolbar);
/* Padding for future expansion */
void (*_gtk_reserved1) (void);
void (*_gtk_reserved2) (void);
void (*_gtk_reserved3) (void);
void (*_gtk_reserved4) (void);
};
GType gtk_toolbar_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_toolbar_new (void);
GType gtk_toolbar_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_toolbar_new (void);
void gtk_toolbar_insert (GtkToolbar *toolbar,
GtkToolItem *item,
gint pos);
gint gtk_toolbar_get_item_index (GtkToolbar *toolbar,
GtkToolItem *item);
gint gtk_toolbar_get_n_items (GtkToolbar *toolbar);
GtkToolItem * gtk_toolbar_get_nth_item (GtkToolbar *toolbar,
gint n);
gint gtk_toolbar_get_drop_index (GtkToolbar *toolbar,
gint x,
gint y);
void gtk_toolbar_set_show_arrow (GtkToolbar *toolbar,
gboolean show_arrow);
void gtk_toolbar_set_orientation (GtkToolbar *toolbar,
GtkOrientation orientation);
void gtk_toolbar_set_tooltips (GtkToolbar *toolbar,
gboolean enable);
void gtk_toolbar_unset_icon_size (GtkToolbar *toolbar);
gboolean gtk_toolbar_get_show_arrow (GtkToolbar *toolbar);
GtkOrientation gtk_toolbar_get_orientation (GtkToolbar *toolbar);
GtkToolbarStyle gtk_toolbar_get_style (GtkToolbar *toolbar);
GtkIconSize gtk_toolbar_get_icon_size (GtkToolbar *toolbar);
gboolean gtk_toolbar_get_tooltips (GtkToolbar *toolbar);
GtkReliefStyle gtk_toolbar_get_relief_style (GtkToolbar *toolbar);
#ifndef GTK_DISABLE_DEPRECATED
/* Simple button items */
GtkWidget* gtk_toolbar_append_item (GtkToolbar *toolbar,
const char *text,
const char *tooltip_text,
const char *tooltip_private_text,
GtkWidget *icon,
GtkSignalFunc callback,
gpointer user_data);
GtkWidget* gtk_toolbar_prepend_item (GtkToolbar *toolbar,
const char *text,
const char *tooltip_text,
const char *tooltip_private_text,
GtkWidget *icon,
GtkSignalFunc callback,
gpointer user_data);
GtkWidget* gtk_toolbar_insert_item (GtkToolbar *toolbar,
const char *text,
const char *tooltip_text,
const char *tooltip_private_text,
GtkWidget *icon,
GtkSignalFunc callback,
gpointer user_data,
gint position);
void gtk_toolbar_set_style (GtkToolbar *toolbar,
GtkToolbarStyle style);
void gtk_toolbar_set_icon_size (GtkToolbar *toolbar,
GtkIconSize icon_size);
void gtk_toolbar_unset_style (GtkToolbar *toolbar);
GtkWidget* gtk_toolbar_append_item (GtkToolbar *toolbar,
const char *text,
const char *tooltip_text,
const char *tooltip_private_text,
GtkWidget *icon,
GtkSignalFunc callback,
gpointer user_data);
GtkWidget* gtk_toolbar_prepend_item (GtkToolbar *toolbar,
const char *text,
const char *tooltip_text,
const char *tooltip_private_text,
GtkWidget *icon,
GtkSignalFunc callback,
gpointer user_data);
GtkWidget* gtk_toolbar_insert_item (GtkToolbar *toolbar,
const char *text,
const char *tooltip_text,
const char *tooltip_private_text,
GtkWidget *icon,
GtkSignalFunc callback,
gpointer user_data,
gint position);
/* Stock Items */
GtkWidget* gtk_toolbar_insert_stock (GtkToolbar *toolbar,
@ -154,8 +196,6 @@ GtkWidget* gtk_toolbar_insert_stock (GtkToolbar *toolbar,
gpointer user_data,
gint position);
/* Space Items */
void gtk_toolbar_append_space (GtkToolbar *toolbar);
void gtk_toolbar_prepend_space (GtkToolbar *toolbar);
@ -163,7 +203,6 @@ void gtk_toolbar_insert_space (GtkToolbar *toolbar,
gint position);
void gtk_toolbar_remove_space (GtkToolbar *toolbar,
gint position);
/* Any element type */
GtkWidget* gtk_toolbar_append_element (GtkToolbar *toolbar,
GtkToolbarChildType type,
@ -211,25 +250,9 @@ void gtk_toolbar_insert_widget (GtkToolbar *toolbar,
const char *tooltip_private_text,
gint position);
/* Style functions */
void gtk_toolbar_set_orientation (GtkToolbar *toolbar,
GtkOrientation orientation);
void gtk_toolbar_set_style (GtkToolbar *toolbar,
GtkToolbarStyle style);
void gtk_toolbar_set_icon_size (GtkToolbar *toolbar,
GtkIconSize icon_size);
void gtk_toolbar_set_tooltips (GtkToolbar *toolbar,
gboolean enable);
void gtk_toolbar_unset_style (GtkToolbar *toolbar);
void gtk_toolbar_unset_icon_size (GtkToolbar *toolbar);
#endif /* GTK_DISABLE_DEPRECATED */
GtkOrientation gtk_toolbar_get_orientation (GtkToolbar *toolbar);
GtkToolbarStyle gtk_toolbar_get_style (GtkToolbar *toolbar);
GtkIconSize gtk_toolbar_get_icon_size (GtkToolbar *toolbar);
gboolean gtk_toolbar_get_tooltips (GtkToolbar *toolbar);
#ifdef __cplusplus
}
#endif /* __cplusplus */
G_END_DECLS
#endif /* __GTK_TOOLBAR_H__ */

812
gtk/gtktoolbutton.c Normal file
View File

@ -0,0 +1,812 @@
/* gtktoolbutton.c
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#include "gtktoolbutton.h"
#include "gtkbutton.h"
#include "gtkhbox.h"
#include "gtkiconfactory.h"
#include "gtkimage.h"
#include "gtkimagemenuitem.h"
#include "gtklabel.h"
#include "gtkstock.h"
#include "gtkvbox.h"
#include "gtkintl.h"
#include <string.h>
#define MENU_ID "gtk-tool-button-menu-id"
enum {
CLICKED,
LAST_SIGNAL
};
enum {
PROP_0,
PROP_LABEL,
PROP_USE_UNDERLINE,
PROP_LABEL_WIDGET,
PROP_STOCK_ID,
PROP_ICON_SET,
PROP_ICON_WIDGET,
};
static void gtk_tool_button_init (GtkToolButton *button,
GtkToolButtonClass *klass);
static void gtk_tool_button_class_init (GtkToolButtonClass *klass);
static void gtk_tool_button_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_tool_button_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_tool_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_tool_button_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_tool_button_finalize (GObject *object);
static void gtk_tool_button_toolbar_reconfigured (GtkToolItem *tool_item);
static gboolean gtk_tool_button_create_menu_proxy (GtkToolItem *item);
static void button_clicked (GtkWidget *widget,
GtkToolButton *button);
static void gtk_tool_button_construct_contents (GtkToolItem *tool_item);
static GObjectClass *parent_class = NULL;
static guint toolbutton_signals[LAST_SIGNAL] = { 0 };
GType
gtk_tool_button_get_type (void)
{
static GtkType type = 0;
if (!type)
{
static const GTypeInfo type_info =
{
sizeof (GtkToolButtonClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gtk_tool_button_class_init,
(GClassFinalizeFunc) NULL,
NULL,
sizeof (GtkToolButton),
0, /* n_preallocs */
(GInstanceInitFunc) gtk_tool_button_init,
};
type = g_type_register_static (GTK_TYPE_TOOL_ITEM,
"GtkToolButton",
&type_info, 0);
}
return type;
}
static void
gtk_tool_button_class_init (GtkToolButtonClass *klass)
{
GObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkToolItemClass *tool_item_class;
parent_class = g_type_class_peek_parent (klass);
object_class = (GObjectClass *)klass;
widget_class = (GtkWidgetClass *)klass;
tool_item_class = (GtkToolItemClass *)klass;
object_class->set_property = gtk_tool_button_set_property;
object_class->get_property = gtk_tool_button_get_property;
object_class->finalize = gtk_tool_button_finalize;
widget_class->size_request = gtk_tool_button_size_request;
widget_class->size_allocate = gtk_tool_button_size_allocate;
tool_item_class->create_menu_proxy = gtk_tool_button_create_menu_proxy;
tool_item_class->toolbar_reconfigured = gtk_tool_button_toolbar_reconfigured;
klass->button_type = GTK_TYPE_BUTTON;
g_object_class_install_property (object_class,
PROP_LABEL,
g_param_spec_string ("label",
_("Label"),
_("Text to show in the item."),
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_USE_UNDERLINE,
g_param_spec_boolean ("use_underline",
_("Use underline"),
_("Interpret underlines in the item label"),
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_LABEL_WIDGET,
g_param_spec_object ("label_widget",
_("Label widget"),
_("Widget to use as the item label"),
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_STOCK_ID,
g_param_spec_string ("stock_id",
_("Stock Id"),
_("The stock icon displayed on the item"),
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_ICON_SET,
g_param_spec_boxed ("icon_set",
_("Icon set"),
_("Icon set to use to draw the item's icon"),
GTK_TYPE_ICON_SET,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_ICON_WIDGET,
g_param_spec_object ("icon_widget",
_("Icon widget"),
_("Icon widget to display in the item"),
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
toolbutton_signals[CLICKED] =
g_signal_new ("clicked",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkToolButtonClass, clicked),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
gtk_tool_button_init (GtkToolButton *button,
GtkToolButtonClass *klass)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (button);
toolitem->homogeneous = TRUE;
/* create button */
button->button = g_object_new (klass->button_type, NULL);
gtk_button_set_focus_on_click (button->button, FALSE);
g_signal_connect_object (button->button, "clicked",
G_CALLBACK (button_clicked), button, 0);
gtk_container_add (GTK_CONTAINER (button), button->button);
gtk_widget_show (button->button);
}
static void
gtk_tool_button_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
GtkWidget *child = GTK_BIN (widget)->child;
if (child && GTK_WIDGET_VISIBLE (child))
{
gtk_widget_size_request (child, requisition);
}
else
{
requisition->width = 0;
requisition->height = 0;
}
requisition->width += GTK_CONTAINER (widget)->border_width * 2;
requisition->height += GTK_CONTAINER (widget)->border_width * 2;
}
static void
gtk_tool_button_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (widget);
GtkAllocation child_allocation;
gint border_width;
GtkWidget *child = GTK_BIN (widget)->child;
widget->allocation = *allocation;
border_width = GTK_CONTAINER (widget)->border_width;
if (toolitem->drag_window && GTK_WIDGET_REALIZED (widget))
gdk_window_move_resize (toolitem->drag_window,
widget->allocation.x + border_width,
widget->allocation.y + border_width,
widget->allocation.width - border_width * 2,
widget->allocation.height - border_width * 2);
if (child && GTK_WIDGET_VISIBLE (child))
{
child_allocation.x = allocation->x + border_width;
child_allocation.y = allocation->y + border_width;
child_allocation.width = allocation->width - 2 * border_width;
child_allocation.height = allocation->height - 2 * border_width;
gtk_widget_size_allocate (child, &child_allocation);
}
}
static gchar *
elide_underscores (const gchar *original)
{
gchar *q, *result;
const gchar *p;
gboolean last_underscore;
q = result = g_malloc (strlen (original) + 1);
last_underscore = FALSE;
for (p = original; *p; p++)
{
if (!last_underscore && *p == '_')
last_underscore = TRUE;
else
{
last_underscore = FALSE;
*q++ = *p;
}
}
*q = '\0';
return result;
}
static void
gtk_tool_button_construct_contents (GtkToolItem *tool_item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (tool_item);
GtkWidget *label = NULL;
GtkWidget *icon = NULL;
GtkToolbarStyle style;
gboolean need_label = FALSE;
gboolean need_icon = FALSE;
GtkIconSize icon_size;
GtkWidget *box = NULL;
if (gtk_tool_item_get_proxy_menu_item (tool_item, MENU_ID))
{
/* Remove item, so it will be recreated on the next
* create_proxy_menu_item()
*/
gtk_tool_item_set_proxy_menu_item (tool_item, MENU_ID, NULL);
}
if (button->icon_widget && button->icon_widget->parent)
{
gtk_container_remove (GTK_CONTAINER (button->icon_widget->parent),
button->icon_widget);
}
if (button->label_widget && button->label_widget->parent)
{
gtk_container_remove (GTK_CONTAINER (button->label_widget->parent),
button->label_widget);
}
if (GTK_BIN (button->button)->child)
{
gtk_container_remove (GTK_CONTAINER (button->button),
GTK_BIN (button->button)->child);
}
style = gtk_tool_item_get_toolbar_style (GTK_TOOL_ITEM (button));
if (style != GTK_TOOLBAR_TEXT)
need_icon = TRUE;
if (style != GTK_TOOLBAR_ICONS)
need_label = TRUE;
if (need_label)
{
if (button->label_widget)
{
label = button->label_widget;
}
else
{
GtkStockItem stock_item;
gboolean elide = TRUE;
gchar *label_text;
if (button->label_text)
{
label_text = button->label_text;
elide = button->use_underline;
}
else if (button->stock_id && gtk_stock_lookup (button->stock_id, &stock_item))
label_text = stock_item.label;
else
label_text = "";
if (elide)
label_text = elide_underscores (label_text);
else
label_text = g_strdup (label_text);
label = gtk_label_new (label_text);
g_free (label_text);
gtk_widget_show (label);
}
}
icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
if (need_icon)
{
if (button->icon_set)
{
icon = gtk_image_new_from_icon_set (button->icon_set, icon_size);
gtk_widget_show (icon);
}
else if (button->icon_widget)
{
icon = button->icon_widget;
if (GTK_IS_IMAGE (icon))
{
GtkImage *image = GTK_IMAGE (icon);
GtkImageType storage_type = gtk_image_get_storage_type (image);
if (storage_type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
gtk_image_get_stock (image, &stock_id, NULL);
icon = gtk_image_new_from_stock (stock_id, icon_size);
gtk_widget_show (icon);
}
else if (storage_type == GTK_IMAGE_ICON_SET)
{
GtkIconSet *icon_set;
gtk_image_get_icon_set (image, &icon_set, NULL);
icon = gtk_image_new_from_icon_set (icon_set, icon_size);
gtk_widget_show (icon);
}
}
}
else if (button->stock_id)
{
icon = gtk_image_new_from_stock (button->stock_id, icon_size);
gtk_widget_show (icon);
}
}
switch (style)
{
case GTK_TOOLBAR_ICONS:
if (icon)
gtk_container_add (GTK_CONTAINER (button->button), icon);
break;
case GTK_TOOLBAR_BOTH:
box = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), icon, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (button->button), box);
break;
case GTK_TOOLBAR_BOTH_HORIZ:
box = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), icon, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (button->button), box);
break;
case GTK_TOOLBAR_TEXT:
gtk_container_add (GTK_CONTAINER (button->button), label);
break;
}
if (box)
gtk_widget_show (box);
gtk_button_set_relief (GTK_BUTTON (button->button),
gtk_tool_item_get_relief_style (GTK_TOOL_ITEM (button)));
gtk_widget_queue_resize (GTK_WIDGET (button));
}
static void
gtk_tool_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkToolButton *button = GTK_TOOL_BUTTON (object);
switch (prop_id)
{
case PROP_LABEL:
gtk_tool_button_set_label (button, g_value_get_string (value));
break;
case PROP_USE_UNDERLINE:
gtk_tool_button_set_use_underline (button, g_value_get_boolean (value));
break;
case PROP_LABEL_WIDGET:
gtk_tool_button_set_label_widget (button, g_value_get_object (value));
break;
case PROP_STOCK_ID:
gtk_tool_button_set_stock_id (button, g_value_get_string (value));
break;
case PROP_ICON_SET:
gtk_tool_button_set_icon_set (button, g_value_get_boxed (value));
break;
case PROP_ICON_WIDGET:
gtk_tool_button_set_icon_widget (button, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
gtk_tool_button_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkToolButton *button = GTK_TOOL_BUTTON (object);
switch (prop_id)
{
case PROP_LABEL:
g_value_set_string (value, gtk_tool_button_get_label (button));
break;
case PROP_LABEL_WIDGET:
g_value_set_object (value, gtk_tool_button_get_label_widget (button));
break;
case PROP_USE_UNDERLINE:
g_value_set_boolean (value, gtk_tool_button_get_use_underline (button));
break;
case PROP_STOCK_ID:
g_value_set_string (value, button->stock_id);
break;
case PROP_ICON_SET:
g_value_set_boxed (value, gtk_tool_button_get_icon_set (button));
break;
case PROP_ICON_WIDGET:
g_value_set_object (value, button->icon_widget);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
gtk_tool_button_finalize (GObject *object)
{
GtkToolButton *button = GTK_TOOL_BUTTON (object);
g_free (button->stock_id);
button->stock_id = NULL;
parent_class->finalize (object);
}
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (item);
GtkWidget *menu_item;
GtkWidget *menu_image = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label = "";
if (button->label_widget && GTK_IS_LABEL (button->label_widget))
label = gtk_label_get_label (GTK_LABEL (button->label_widget));
else if (button->label_text)
{
label = button->label_text;
use_mnemonic = button->use_underline;
}
else if (button->stock_id && gtk_stock_lookup (button->stock_id, &stock_item))
label = stock_item.label;
if (use_mnemonic)
menu_item = gtk_image_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_image_menu_item_new_with_label (label);
if (button->icon_set)
{
menu_image = gtk_image_new_from_icon_set (button->icon_set, GTK_ICON_SIZE_MENU);
}
else if (button->icon_widget && GTK_IS_IMAGE (button->icon_widget))
{
GtkImage *image = GTK_IMAGE (button->icon_widget);
GtkImageType storage_type = gtk_image_get_storage_type (image);
if (storage_type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
gtk_image_get_stock (image, &stock_id, NULL);
menu_image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
}
else if (storage_type == GTK_IMAGE_ICON_SET)
{
GtkIconSet *icon_set;
gtk_image_get_icon_set (image, &icon_set, NULL);
menu_image = gtk_image_new_from_icon_set (icon_set, GTK_ICON_SIZE_MENU);
}
}
else if (button->stock_id)
{
menu_image = gtk_image_new_from_stock (button->stock_id, GTK_ICON_SIZE_MENU);
}
if (menu_image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
G_OBJECT (GTK_TOOL_BUTTON (button)->button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
return TRUE;
}
static void
button_clicked (GtkWidget *widget,
GtkToolButton *button)
{
g_signal_emit_by_name (button, "clicked");
}
static void
gtk_tool_button_toolbar_reconfigured (GtkToolItem *tool_item)
{
gtk_tool_button_construct_contents (tool_item);
}
GtkToolItem *
gtk_tool_button_new_from_stock (const gchar *stock_id)
{
GtkToolButton *button;
g_return_val_if_fail (stock_id != NULL, NULL);
button = g_object_new (GTK_TYPE_TOOL_BUTTON,
"stock_id", stock_id,
NULL);
return GTK_TOOL_ITEM (button);
}
GtkToolItem *
gtk_tool_button_new (void)
{
GtkToolButton *button;
button = g_object_new (GTK_TYPE_TOOL_BUTTON,
NULL);
return GTK_TOOL_ITEM (button);
}
void
gtk_tool_button_set_label (GtkToolButton *button,
const gchar *label)
{
gchar *old_label;
g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
old_label = button->label_text;
button->label_text = g_strdup (label);
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "label");
if (old_label)
g_free (old_label);
}
G_CONST_RETURN gchar *
gtk_tool_button_get_label (GtkToolButton *button)
{
g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
return button->label_text;
}
void
gtk_tool_button_set_use_underline (GtkToolButton *button,
gboolean use_underline)
{
g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
use_underline = use_underline != FALSE;
if (use_underline != button->use_underline)
{
button->use_underline = use_underline;
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "use_underline");
}
}
gboolean
gtk_tool_button_get_use_underline (GtkToolButton *button)
{
g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), FALSE);
return button->use_underline;
}
void
gtk_tool_button_set_stock_id (GtkToolButton *button,
const gchar *stock_id)
{
gchar *old_stock_id;
g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
old_stock_id = button->stock_id;
button->stock_id = g_strdup (stock_id);
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "stock_id");
g_free (old_stock_id);
}
G_CONST_RETURN gchar *
gtk_tool_button_get_stock_id (GtkToolButton *button)
{
g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
return button->stock_id;
}
void
gtk_tool_button_set_icon_widget (GtkToolButton *button,
GtkWidget *icon)
{
g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
g_return_if_fail (icon == NULL || GTK_IS_WIDGET (icon));
if (icon != button->icon_widget)
{
g_object_freeze_notify (G_OBJECT (button));
if (button->icon_widget)
g_object_unref (G_OBJECT (button->icon_widget));
if (icon)
{
g_object_ref (icon);
gtk_object_sink (GTK_OBJECT (icon));
}
button->icon_widget = icon;
if (button->icon_widget && button->icon_set)
{
gtk_icon_set_unref (button->icon_set);
button->icon_set = NULL;
g_object_notify (G_OBJECT (button), "icon_set");
}
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "icon_widget");
g_object_thaw_notify (G_OBJECT (button));
}
}
void
gtk_tool_button_set_label_widget (GtkToolButton *button,
GtkWidget *label_widget)
{
g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
if (label_widget != button->label_widget)
{
if (button->label_widget)
g_object_unref (button->label_widget);
if (label_widget)
{
g_object_ref (label_widget);
gtk_object_sink (GTK_OBJECT (label_widget));
}
button->label_widget = label_widget;
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "label_widget");
}
}
GtkWidget *
gtk_tool_button_get_label_widget (GtkToolButton *button)
{
g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
return button->label_widget;
}
GtkWidget *
gtk_tool_button_get_icon_widget (GtkToolButton *button)
{
g_return_val_if_fail (GTK_IS_BUTTON (button), NULL);
return button->icon_widget;
}
void
gtk_tool_button_set_icon_set (GtkToolButton *button,
GtkIconSet *icon_set)
{
g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
if (icon_set != button->icon_set)
{
g_object_freeze_notify (G_OBJECT (button));
if (button->icon_set)
gtk_icon_set_unref (button->icon_set);
button->icon_set = icon_set;
if (button->icon_set && button->icon_widget)
{
g_object_unref (button->icon_widget);
button->icon_widget = NULL;
g_object_notify (G_OBJECT (button->icon_widget), "icon_widget");
}
gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
g_object_notify (G_OBJECT (button), "icon_set");
g_object_thaw_notify (G_OBJECT (button));
}
}
GtkIconSet *
gtk_tool_button_get_icon_set (GtkToolButton *button)
{
g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
return button->icon_set;
}

92
gtk/gtktoolbutton.h Normal file
View File

@ -0,0 +1,92 @@
/* gtktoolbutton.h
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#ifndef __GTK_TOOL_BUTTON_H__
#define __GTK_TOOL_BUTTON_H__
#include "gtktoolitem.h"
G_BEGIN_DECLS
#define GTK_TYPE_TOOL_BUTTON (gtk_tool_button_get_type ())
#define GTK_TOOL_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOL_BUTTON, GtkToolButton))
#define GTK_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOL_BUTTON, GtkToolButtonClass))
#define GTK_IS_TOOL_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOL_BUTTON))
#define GTK_IS_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GTK_TYPE_TOOL_BUTTON))
#define GTK_TOOL_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOOL_BUTTON, GtkToolButtonClass))
typedef struct _GtkToolButton GtkToolButton;
typedef struct _GtkToolButtonClass GtkToolButtonClass;
typedef struct _GtkToolButtonPrivate GtkToolButtonPrivate;
struct _GtkToolButton
{
GtkToolItem parent;
GtkWidget *button;
gchar *stock_id;
gchar *label_text;
GtkWidget *label_widget;
GtkWidget *icon_widget;
GtkIconSet *icon_set;
guint use_underline : 1;
};
struct _GtkToolButtonClass
{
GtkToolItemClass parent_class;
GType button_type;
/* signal */
void (* clicked) (GtkToolButton *tool_item);
};
GType gtk_tool_button_get_type (void);
GtkToolItem *gtk_tool_button_new (void);
GtkToolItem *gtk_tool_button_new_from_stock (const gchar *stock_id);
void gtk_tool_button_set_label (GtkToolButton *button,
const gchar *label);
G_CONST_RETURN gchar *gtk_tool_button_get_label (GtkToolButton *button);
void gtk_tool_button_set_use_underline (GtkToolButton *button,
gboolean use_underline);
gboolean gtk_tool_button_get_use_underline (GtkToolButton *button);
void gtk_tool_button_set_stock_id (GtkToolButton *button,
const gchar *stock_id);
G_CONST_RETURN gchar *gtk_tool_button_get_stock_id (GtkToolButton *button);
void gtk_tool_button_set_icon_set (GtkToolButton *button,
GtkIconSet *icon_set);
GtkIconSet * gtk_tool_button_get_icon_set (GtkToolButton *button);
void gtk_tool_button_set_icon_widget (GtkToolButton *button,
GtkWidget *icon);
GtkWidget * gtk_tool_button_get_icon_widget (GtkToolButton *button);
void gtk_tool_button_set_label_widget (GtkToolButton *button,
GtkWidget *label_widget);
GtkWidget * gtk_tool_button_get_label_widget (GtkToolButton *button);
G_END_DECLS
#endif /* __GTK_TOOL_BUTTON_H__ */

697
gtk/gtktoolitem.c Normal file
View File

@ -0,0 +1,697 @@
/* gtktoolitem.c
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#include "gtktoolitem.h"
#include "gtkmarshalers.h"
#include "gtktoolbar.h"
#include "gtkseparatormenuitem.h"
#include "gtkintl.h"
#include "gtkmain.h"
#include <string.h>
#define MENU_ID "gtk-tool-item-menu-id"
enum {
CREATE_MENU_PROXY,
TOOLBAR_RECONFIGURED,
SET_TOOLTIP,
LAST_SIGNAL
};
enum {
PROP_0,
PROP_VISIBLE_HORIZONTAL,
PROP_VISIBLE_VERTICAL,
};
static void gtk_tool_item_init (GtkToolItem *toolitem);
static void gtk_tool_item_class_init (GtkToolItemClass *class);
static void gtk_tool_item_finalize (GObject *object);
static void gtk_tool_item_parent_set (GtkWidget *toolitem,
GtkWidget *parent);
static void gtk_tool_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_tool_item_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_tool_item_realize (GtkWidget *widget);
static void gtk_tool_item_unrealize (GtkWidget *widget);
static void gtk_tool_item_map (GtkWidget *widget);
static void gtk_tool_item_unmap (GtkWidget *widget);
static void gtk_tool_item_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_tool_item_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gboolean gtk_tool_item_real_set_tooltip (GtkToolItem *tool_item,
GtkTooltips *tooltips,
const gchar *tip_text,
const gchar *tip_private);
static gboolean gtk_tool_item_create_menu_proxy (GtkToolItem *item);
static GObjectClass *parent_class = NULL;
static guint toolitem_signals[LAST_SIGNAL] = { 0 };
GType
gtk_tool_item_get_type (void)
{
static GtkType type = 0;
if (!type)
{
static const GTypeInfo type_info =
{
sizeof (GtkToolItemClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gtk_tool_item_class_init,
(GClassFinalizeFunc) NULL,
NULL,
sizeof (GtkToolItem),
0, /* n_preallocs */
(GInstanceInitFunc) gtk_tool_item_init,
};
type = g_type_register_static (GTK_TYPE_BIN,
"GtkToolItem",
&type_info, 0);
}
return type;
}
static void
gtk_tool_item_class_init (GtkToolItemClass *klass)
{
GObjectClass *object_class;
GtkWidgetClass *widget_class;
parent_class = g_type_class_peek_parent (klass);
object_class = (GObjectClass *)klass;
widget_class = (GtkWidgetClass *)klass;
object_class->set_property = gtk_tool_item_set_property;
object_class->get_property = gtk_tool_item_get_property;
object_class->finalize = gtk_tool_item_finalize;
widget_class->realize = gtk_tool_item_realize;
widget_class->unrealize = gtk_tool_item_unrealize;
widget_class->map = gtk_tool_item_map;
widget_class->unmap = gtk_tool_item_unmap;
widget_class->size_request = gtk_tool_item_size_request;
widget_class->size_allocate = gtk_tool_item_size_allocate;
widget_class->parent_set = gtk_tool_item_parent_set;
klass->create_menu_proxy = gtk_tool_item_create_menu_proxy;
klass->set_tooltip = gtk_tool_item_real_set_tooltip;
g_object_class_install_property (object_class,
PROP_VISIBLE_HORIZONTAL,
g_param_spec_boolean ("visible_horizontal",
_("Visible when horizontal"),
_("Whether the toolbar item is visible when the toolbar is in a horizontal orientation."),
TRUE,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_VISIBLE_VERTICAL,
g_param_spec_boolean ("visible_vertical",
_("Visible when vertical"),
_("Whether the toolbar item is visible when the toolbar is in a vertical orientation."),
TRUE,
G_PARAM_READWRITE));
toolitem_signals[CREATE_MENU_PROXY] =
g_signal_new ("create_menu_proxy",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolItemClass, create_menu_proxy),
_gtk_boolean_handled_accumulator, NULL, /* FIXME: use gtk_boolean_handled() when
* we are added to gtk+
*/
_gtk_marshal_BOOLEAN__VOID,
G_TYPE_BOOLEAN, 0);
toolitem_signals[TOOLBAR_RECONFIGURED] =
g_signal_new ("toolbar_reconfigured",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolItemClass, toolbar_reconfigured),
NULL, NULL,
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
toolitem_signals[SET_TOOLTIP] =
g_signal_new ("set_tooltip",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkToolItemClass, set_tooltip),
_gtk_boolean_handled_accumulator, NULL, /* FIXME: use gtk_boolean_handled() when
* we are added to gtk+
*/
_gtk_marshal_BOOLEAN__OBJECT_STRING_STRING,
G_TYPE_BOOLEAN, 3,
GTK_TYPE_TOOLTIPS,
G_TYPE_STRING,
G_TYPE_STRING);
}
static void
gtk_tool_item_init (GtkToolItem *toolitem)
{
GTK_WIDGET_UNSET_FLAGS (toolitem, GTK_CAN_FOCUS);
toolitem->visible_horizontal = TRUE;
toolitem->visible_vertical = TRUE;
toolitem->homogeneous = FALSE;
toolitem->expand = FALSE;
}
static void
gtk_tool_item_finalize (GObject *object)
{
GtkToolItem *item = GTK_TOOL_ITEM (object);
if (item->menu_item)
g_object_unref (item->menu_item);
if (G_OBJECT_CLASS (parent_class)->finalize)
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gtk_tool_item_parent_set (GtkWidget *toolitem,
GtkWidget *prev_parent)
{
gtk_tool_item_toolbar_reconfigured (GTK_TOOL_ITEM (toolitem));
}
static void
gtk_tool_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (object);
switch (prop_id)
{
case PROP_VISIBLE_HORIZONTAL:
gtk_tool_item_set_visible_horizontal (toolitem, g_value_get_boolean (value));
break;
case PROP_VISIBLE_VERTICAL:
gtk_tool_item_set_visible_horizontal (toolitem, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
gtk_tool_item_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (object);
switch (prop_id)
{
case PROP_VISIBLE_HORIZONTAL:
g_value_set_boolean (value, toolitem->visible_horizontal);
break;
case PROP_VISIBLE_VERTICAL:
g_value_set_boolean (value, toolitem->visible_vertical);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
create_drag_window (GtkToolItem *toolitem)
{
GtkWidget *widget;
GdkWindowAttr attributes;
gint attributes_mask, border_width;
g_return_if_fail (toolitem->use_drag_window == TRUE);
widget = GTK_WIDGET (toolitem);
border_width = GTK_CONTAINER (toolitem)->border_width;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x + border_width;
attributes.y = widget->allocation.y + border_width;
attributes.width = widget->allocation.width - border_width * 2;
attributes.height = widget->allocation.height - border_width * 2;
attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y;
toolitem->drag_window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (toolitem->drag_window, toolitem);
}
static void
gtk_tool_item_realize (GtkWidget *widget)
{
GtkToolItem *toolitem;
toolitem = GTK_TOOL_ITEM (widget);
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
widget->window = gtk_widget_get_parent_window (widget);
g_object_ref (widget->window);
if (toolitem->use_drag_window)
create_drag_window(toolitem);
widget->style = gtk_style_attach (widget->style, widget->window);
}
static void
destroy_drag_window (GtkToolItem *toolitem)
{
if (toolitem->drag_window)
{
gdk_window_set_user_data (toolitem->drag_window, NULL);
gdk_window_destroy (toolitem->drag_window);
toolitem->drag_window = NULL;
}
}
static void
gtk_tool_item_unrealize (GtkWidget *widget)
{
GtkToolItem *toolitem;
toolitem = GTK_TOOL_ITEM (widget);
destroy_drag_window (toolitem);
GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
}
static void
gtk_tool_item_map (GtkWidget *widget)
{
GtkToolItem *toolitem;
toolitem = GTK_TOOL_ITEM (widget);
GTK_WIDGET_CLASS (parent_class)->map (widget);
if (toolitem->drag_window)
gdk_window_show (toolitem->drag_window);
}
static void
gtk_tool_item_unmap (GtkWidget *widget)
{
GtkToolItem *toolitem;
toolitem = GTK_TOOL_ITEM (widget);
if (toolitem->drag_window)
gdk_window_hide (toolitem->drag_window);
GTK_WIDGET_CLASS (parent_class)->unmap (widget);
}
static void
gtk_tool_item_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
GtkWidget *child = GTK_BIN (widget)->child;
gint xthickness = widget->style->xthickness;
gint ythickness = widget->style->ythickness;
if (child && GTK_WIDGET_VISIBLE (child))
{
gtk_widget_size_request (child, requisition);
}
else
{
requisition->height = 0;
requisition->width = 0;
}
requisition->width += (xthickness + GTK_CONTAINER (widget)->border_width) * 2;
requisition->height += (ythickness + GTK_CONTAINER (widget)->border_width) * 2;
}
static void
gtk_tool_item_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (widget);
GtkAllocation child_allocation;
gint border_width;
GtkWidget *child = GTK_BIN (widget)->child;
widget->allocation = *allocation;
border_width = GTK_CONTAINER (widget)->border_width;
if (toolitem->drag_window)
gdk_window_move_resize (toolitem->drag_window,
widget->allocation.x + border_width,
widget->allocation.y + border_width,
widget->allocation.width - border_width * 2,
widget->allocation.height - border_width * 2);
if (child && GTK_WIDGET_VISIBLE (child))
{
gint xthickness = widget->style->xthickness;
gint ythickness = widget->style->ythickness;
child_allocation.x = allocation->x + border_width + xthickness;
child_allocation.y = allocation->y + border_width + ythickness;
child_allocation.width = allocation->width - 2 * (xthickness + border_width);
child_allocation.height = allocation->height - 2 * (ythickness + border_width);
gtk_widget_size_allocate (child, &child_allocation);
}
}
static gboolean
gtk_tool_item_create_menu_proxy (GtkToolItem *item)
{
if (!GTK_BIN (item)->child)
{
GtkWidget *menu_item = NULL;
menu_item = gtk_separator_menu_item_new();
gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item);
return TRUE;
}
return FALSE;
}
GtkToolItem *
gtk_tool_item_new (void)
{
GtkToolItem *item;
item = g_object_new (GTK_TYPE_TOOL_ITEM, NULL);
return item;
}
GtkIconSize
gtk_tool_item_get_icon_size (GtkToolItem *tool_item)
{
GtkWidget *parent;
g_return_val_if_fail (GTK_IS_TOOL_ITEM (tool_item), GTK_ICON_SIZE_LARGE_TOOLBAR);
parent = GTK_WIDGET (tool_item)->parent;
if (!parent || !GTK_IS_TOOLBAR (parent))
return GTK_ICON_SIZE_LARGE_TOOLBAR;
return gtk_toolbar_get_icon_size (GTK_TOOLBAR (parent));
}
GtkOrientation
gtk_tool_item_get_orientation (GtkToolItem *tool_item)
{
GtkWidget *parent;
g_return_val_if_fail (GTK_IS_TOOL_ITEM (tool_item), GTK_ORIENTATION_HORIZONTAL);
parent = GTK_WIDGET (tool_item)->parent;
if (!parent || !GTK_IS_TOOLBAR (parent))
return GTK_ORIENTATION_HORIZONTAL;
return gtk_toolbar_get_orientation (GTK_TOOLBAR (parent));
}
GtkToolbarStyle
gtk_tool_item_get_toolbar_style (GtkToolItem *tool_item)
{
GtkWidget *parent;
g_return_val_if_fail (GTK_IS_TOOL_ITEM (tool_item), GTK_TOOLBAR_ICONS);
parent = GTK_WIDGET (tool_item)->parent;
if (!parent || !GTK_IS_TOOLBAR (parent))
return GTK_TOOLBAR_ICONS;
return gtk_toolbar_get_style (GTK_TOOLBAR (parent));
}
GtkReliefStyle
gtk_tool_item_get_relief_style (GtkToolItem *tool_item)
{
GtkWidget *parent;
g_return_val_if_fail (GTK_IS_TOOL_ITEM (tool_item), GTK_RELIEF_NONE);
parent = GTK_WIDGET (tool_item)->parent;
if (!parent || !GTK_IS_TOOLBAR (parent))
return GTK_RELIEF_NONE;
return gtk_toolbar_get_relief_style (GTK_TOOLBAR (parent));
}
void
gtk_tool_item_toolbar_reconfigured (GtkToolItem *tool_item)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
g_signal_emit (tool_item, toolitem_signals[TOOLBAR_RECONFIGURED], 0);
}
void
gtk_tool_item_set_expand (GtkToolItem *tool_item,
gboolean expand)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
expand = expand != FALSE;
if (tool_item->expand != expand)
{
tool_item->expand = expand;
gtk_widget_child_notify (GTK_WIDGET (tool_item), "expand");
gtk_widget_queue_resize (GTK_WIDGET (tool_item));
}
}
void
gtk_tool_item_set_pack_end (GtkToolItem *tool_item,
gboolean pack_end)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
pack_end = pack_end != FALSE;
if (tool_item->pack_end != pack_end)
{
tool_item->pack_end = pack_end;
gtk_widget_child_notify (GTK_WIDGET (tool_item), "pack_end");
gtk_widget_queue_resize (GTK_WIDGET (tool_item));
}
}
void
gtk_tool_item_set_homogeneous (GtkToolItem *tool_item,
gboolean homogeneous)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
homogeneous = homogeneous != FALSE;
if (tool_item->homogeneous != homogeneous)
{
tool_item->homogeneous = homogeneous;
gtk_widget_child_notify (GTK_WIDGET (tool_item), "homogeneous");
gtk_widget_queue_resize (GTK_WIDGET (tool_item));
}
}
static gboolean
gtk_tool_item_real_set_tooltip (GtkToolItem *tool_item,
GtkTooltips *tooltips,
const gchar *tip_text,
const gchar *tip_private)
{
GtkWidget *child = GTK_BIN (tool_item)->child;
if (!child)
return FALSE;
gtk_tooltips_set_tip (tooltips, child, tip_text, tip_private);
return TRUE;
}
void
gtk_tool_item_set_tooltip (GtkToolItem *tool_item,
GtkTooltips *tooltips,
const gchar *tip_text,
const gchar *tip_private)
{
gboolean retval;
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
g_signal_emit (tool_item, toolitem_signals[SET_TOOLTIP], 0,
tooltips, tip_text, tip_private, &retval);
}
void
gtk_tool_item_set_use_drag_window (GtkToolItem *toolitem,
gboolean use_drag_window)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (toolitem));
use_drag_window = use_drag_window != FALSE;
if (toolitem->use_drag_window != use_drag_window)
{
toolitem->use_drag_window = use_drag_window;
if (use_drag_window)
{
if (!toolitem->drag_window && GTK_WIDGET_REALIZED (toolitem))
{
create_drag_window(toolitem);
if (GTK_WIDGET_MAPPED (toolitem))
gdk_window_show (toolitem->drag_window);
}
}
else
{
destroy_drag_window (toolitem);
}
}
}
void
gtk_tool_item_set_visible_horizontal (GtkToolItem *toolitem,
gboolean visible_horizontal)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (toolitem));
visible_horizontal = visible_horizontal != FALSE;
if (toolitem->visible_horizontal != visible_horizontal)
{
toolitem->visible_horizontal = visible_horizontal;
g_object_notify (G_OBJECT (toolitem), "visible_horizontal");
gtk_widget_queue_resize (GTK_WIDGET (toolitem));
}
}
gboolean
gtk_tool_item_get_visible_horizontal (GtkToolItem *toolitem)
{
g_return_val_if_fail (GTK_IS_TOOL_ITEM (toolitem), FALSE);
return toolitem->visible_horizontal;
}
void
gtk_tool_item_set_visible_vertical (GtkToolItem *toolitem,
gboolean visible_vertical)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (toolitem));
visible_vertical = visible_vertical != FALSE;
if (toolitem->visible_vertical != visible_vertical)
{
toolitem->visible_vertical = visible_vertical;
g_object_notify (G_OBJECT (toolitem), "visible_vertical");
gtk_widget_queue_resize (GTK_WIDGET (toolitem));
}
}
gboolean
gtk_tool_item_get_visible_vertical (GtkToolItem *toolitem)
{
g_return_val_if_fail (GTK_IS_TOOL_ITEM (toolitem), FALSE);
return toolitem->visible_vertical;
}
GtkWidget *
gtk_tool_item_retrieve_proxy_menu_item (GtkToolItem *tool_item)
{
gboolean retval;
g_return_val_if_fail (GTK_IS_TOOL_ITEM (tool_item), NULL);
g_signal_emit (tool_item, toolitem_signals[CREATE_MENU_PROXY], 0, &retval);
return tool_item->menu_item;
}
GtkWidget *
gtk_tool_item_get_proxy_menu_item (GtkToolItem *tool_item,
const gchar *menu_item_id)
{
g_return_val_if_fail (GTK_IS_TOOL_ITEM (tool_item), NULL);
g_return_val_if_fail (menu_item_id != NULL, NULL);
if (tool_item->menu_item_id && strcmp (tool_item->menu_item_id, menu_item_id) == 0)
return tool_item->menu_item;
return NULL;
}
void
gtk_tool_item_set_proxy_menu_item (GtkToolItem *tool_item,
const gchar *menu_item_id,
GtkWidget *menu_item)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
g_return_if_fail (menu_item == NULL || GTK_IS_MENU_ITEM (menu_item));
g_return_if_fail (menu_item_id != NULL);
if (tool_item->menu_item_id)
g_free (tool_item->menu_item_id);
tool_item->menu_item_id = g_strdup (menu_item_id);
if (tool_item->menu_item != menu_item)
{
if (tool_item->menu_item)
g_object_unref (G_OBJECT (tool_item->menu_item));
if (menu_item)
{
g_object_ref (menu_item);
gtk_object_sink (GTK_OBJECT (menu_item));
}
tool_item->menu_item = menu_item;
}
}

110
gtk/gtktoolitem.h Normal file
View File

@ -0,0 +1,110 @@
/* gtktoolitem.c
*
* Copyright (C) 2002 Anders Carlsson <andersca@codefactory.se>
* Copyright (C) 2002 James Henstridge <james@daa.com.au>
* Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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.
*/
#ifndef __GTK_TOOL_ITEM_H__
#define __GTK_TOOL_ITEM_H__
#include <gtk/gtkbin.h>
#include <gtk/gtktooltips.h>
#include <gtk/gtkmenuitem.h>
#define GTK_TYPE_TOOL_ITEM (gtk_tool_item_get_type ())
#define GTK_TOOL_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOL_ITEM, GtkToolItem))
#define GTK_TOOL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOL_ITEM, GtkToolItemClass))
#define GTK_IS_TOOL_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOL_ITEM))
#define GTK_IS_TOOL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), GTK_TYPE_TOOL_ITEM))
#define GTK_TOOL_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOOL_ITEM, GtkToolItemClass))
typedef struct _GtkToolItem GtkToolItem;
typedef struct _GtkToolItemClass GtkToolItemClass;
typedef struct _GtkToolItemPrivate GtkToolItemPrivate;
struct _GtkToolItem
{
GtkBin parent;
/*< private >*/
gchar *tip_text;
gchar *tip_private;
GdkWindow *drag_window;
guint visible_horizontal : 1;
guint visible_vertical : 1;
guint homogeneous : 1;
guint expand : 1;
guint pack_end : 1;
guint use_drag_window : 1;
guint overflow_item : 1;
GtkWidget *menu_item;
gchar *menu_item_id;
};
struct _GtkToolItemClass
{
GtkBinClass parent_class;
/* signals */
gboolean (* create_menu_proxy) (GtkToolItem *tool_item);
void (* toolbar_reconfigured) (GtkToolItem *tool_item);
gboolean (* set_tooltip) (GtkToolItem *tool_item,
GtkTooltips *tooltips,
const gchar *tip_text,
const gchar *tip_private);
};
GType gtk_tool_item_get_type (void);
GtkToolItem *gtk_tool_item_new (void);
void gtk_tool_item_toolbar_reconfigured (GtkToolItem *tool_item);
void gtk_tool_item_set_homogeneous (GtkToolItem *tool_item,
gboolean homogeneous);
void gtk_tool_item_set_expand (GtkToolItem *tool_item,
gboolean expand);
void gtk_tool_item_set_pack_end (GtkToolItem *tool_item,
gboolean pack_end);
void gtk_tool_item_set_tooltip (GtkToolItem *tool_item,
GtkTooltips *tooltips,
const gchar *tip_text,
const gchar *tip_private);
void gtk_tool_item_set_use_drag_window (GtkToolItem *toolitem,
gboolean use_drag_window);
void gtk_tool_item_set_visible_horizontal (GtkToolItem *toolitem,
gboolean visible_horizontal);
gboolean gtk_tool_item_get_visible_horizontal (GtkToolItem *toolitem);
void gtk_tool_item_set_visible_vertical (GtkToolItem *toolitem,
gboolean visible_horizontal);
gboolean gtk_tool_item_get_visible_vertical (GtkToolItem *toolitem);
GtkIconSize gtk_tool_item_get_icon_size (GtkToolItem *tool_item);
GtkOrientation gtk_tool_item_get_orientation (GtkToolItem *tool_item);
GtkToolbarStyle gtk_tool_item_get_toolbar_style (GtkToolItem *tool_item);
GtkReliefStyle gtk_tool_item_get_relief_style (GtkToolItem *tool_item);
GtkWidget * gtk_tool_item_retrieve_proxy_menu_item (GtkToolItem *tool_item);
GtkWidget * gtk_tool_item_get_proxy_menu_item (GtkToolItem *tool_item,
const gchar *menu_item_id);
void gtk_tool_item_set_proxy_menu_item (GtkToolItem *tool_item,
const gchar *menu_item_id,
GtkWidget *menu_item);
#endif /* __GTK_TOOL_ITEM_H__ */