AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Add private function to get the aux info structure fo the widget.

Browse Source 
Wed Mar 28 20:30:26 2001  Owen Taylor  <otaylor@redhat.com>

	* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
	to get the aux info structure fo the widget.

	* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
	above function.

        [ Patch from  Havoc Pennington  <hp@redhat.com> ]

	* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
	to get the size of the window manager frame, basically the same
	code that gdk_window_get_root_origin() had
	(gdk_window_get_root_origin): use gdk_window_get_frame_extents()

	* gtk/gtkwindow.c (gtk_window_set_default_size): use
	gdk_window_resize() if the window is realized and resizeable

	* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
	typo so that setting gravity works

	* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
	allocation if auto_shrink is on, even if the default size
	has not changed.

	* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
	g_return_if_fail
This commit is contained in:
Owen Taylor 2001-03-29 23:02:30 +00:00 committed by Owen Taylor
parent f19af6f49c
commit f67ae736ee
18 changed files with 1510 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
ChangeLog
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

28
ChangeLog.pre-2-0
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

28
ChangeLog.pre-2-10
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

28
ChangeLog.pre-2-2
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

28
ChangeLog.pre-2-4
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

28
ChangeLog.pre-2-6
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

28
ChangeLog.pre-2-8
View File

@ -1,3 +1,31 @@
Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
to get the aux info structure fo the widget.
* gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
above function.
[ Patch from Havoc Pennington <hp@redhat.com> ]
* gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
to get the size of the window manager frame, basically the same
code that gdk_window_get_root_origin() had
(gdk_window_get_root_origin): use gdk_window_get_frame_extents()
* gtk/gtkwindow.c (gtk_window_set_default_size): use
gdk_window_resize() if the window is realized and resizeable
* gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
typo so that setting gravity works
* gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
allocation if auto_shrink is on, even if the default size
has not changed.
* gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
g_return_if_fail
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive

2
docs/reference/gtk/tmpl/gtkwidget.sgml
View File

@ -294,6 +294,8 @@ GtkWidget
@y:
@width:
@height:
@x_set:
@y_set:
<!-- ##### STRUCT GtkWidgetShapeInfo ##### -->
<para>

2
gdk/gdkwindow.h
View File

@ -416,6 +416,8 @@ gboolean gdk_window_get_deskrelative_origin (GdkWindow *window,
void gdk_window_get_root_origin (GdkWindow *window,
gint *x,
gint *y);
void gdk_window_get_frame_extents (GdkWindow *window,
GdkRectangle *rect);
GdkWindow* gdk_window_get_pointer (GdkWindow *window,
gint *x,
gint *y,

86
gdk/x11/gdkwindow-x11.c
View File

@ -1676,6 +1676,19 @@ gdk_window_get_geometry (GdkWindow *window,
}
}
/**
* gdk_window_get_origin:
* @window: a #GdkWindow
* @x: return location for X coordinate
* @y: return location for Y coordinate
*
* Obtains the position of a window in root window coordinates.
* (Compare with gdk_window_get_position() and
* gdk_window_get_geometry() which return the position of a window
* relative to its parent window.)
*
* Return value: not meaningful, ignore
**/
gint
gdk_window_get_origin (GdkWindow *window,
gint *x,
@ -1708,6 +1721,21 @@ gdk_window_get_origin (GdkWindow *window,
return return_val;
}
/**
* gdk_window_get_deskrelative_origin:
* @window: a #GdkWindow
* @x: return location for X coordinate
* @y: return location for Y coordinate
*
* This gets the origin of a #GdkWindow relative to
* an Enlightenment-window-manager desktop. As long as you don't
* assume that the user's desktop/workspace covers the entire
* root window (i.e. you don't assume that the desktop begins
* at root window coordinate 0,0) this function is not necessary.
* It's deprecated for that reason.
*
* Return value: not meaningful
**/
gboolean
gdk_window_get_deskrelative_origin (GdkWindow *window,
gint *x,
@ -1772,10 +1800,48 @@ gdk_window_get_deskrelative_origin (GdkWindow *window,
return return_val;
}
/**
* gdk_window_get_root_origin:
* @window: a #GdkWindow
* @x: return location for X position of window frame
* @y: return location for Y position of window frame
*
* Obtains the top-left corner of the window manager frame in root
* window coordinates.
*
**/
void
gdk_window_get_root_origin (GdkWindow *window,
gint *x,
gint *y)
{
GdkRectangle rect;
g_return_if_fail (GDK_IS_WINDOW (window));
gdk_window_get_frame_extents (window, &rect);
if (x)
*x = rect.x;
if (y)
*y = rect.y;
}
/**
* gdk_window_get_frame_extents:
* @window: a #GdkWindow
* @rect: rectangle to fill with bounding box of the window frame
*
* Obtains the bounding box of the window, including window manager
* titlebar/borders if any. The frame position is given in root window
* coordinates. To get the position of the window itself (rather than
* the frame) in root window coordinates, use gdk_window_get_origin().
*
**/
void
gdk_window_get_frame_extents (GdkWindow *window,
GdkRectangle *rect)
{
GdkWindowObject *private;
Window xwindow;
@ -1784,14 +1850,15 @@ gdk_window_get_root_origin (GdkWindow *window,
Window *children;
unsigned int nchildren;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (rect != NULL);
private = (GdkWindowObject*) window;
if (x)
*x = 0;
if (y)
*y = 0;
rect->x = 0;
rect->y = 0;
rect->width = 1;
rect->height = 1;
if (GDK_WINDOW_DESTROYED (window))
return;
@ -1822,10 +1889,10 @@ gdk_window_get_root_origin (GdkWindow *window,
if (XGetGeometry (GDK_WINDOW_XDISPLAY (window), xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
{
if (x)
*x = wx;
if (y)
*y = wy;
rect->x = wx;
rect->y = wy;
rect->width = ww;
rect->height = wh;
}
}
}
@ -3442,7 +3509,6 @@ update_pos (gint new_root_x,
w += dx;
h += dy;
break;
}
w = MAX (w, 1);

2
gtk/gtklabel.c
View File

@ -1013,7 +1013,7 @@ gtk_label_ensure_layout (GtkLabel *label,
gint width, height;
gint real_width;
aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
aux_info = _gtk_widget_get_aux_info (widget, FALSE);
if (aux_info && aux_info->width > 0)
{
pango_layout_set_width (label->layout, aux_info->width * PANGO_SCALE);

12
gtk/gtkscrolledwindow.c
View File

@ -666,20 +666,14 @@ gtk_scrolled_window_size_request (GtkWidget *widget,
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
static guint quark_aux_info = 0;
if (!quark_aux_info)
quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
gtk_widget_size_request (bin->child, &child_requisition);
if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
requisition->width += child_requisition.width;
else
{
GtkWidgetAuxInfo *aux_info;
GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (bin->child), quark_aux_info);
if (aux_info && aux_info->width > 0)
{
requisition->width += aux_info->width;
@ -693,9 +687,7 @@ gtk_scrolled_window_size_request (GtkWidget *widget,
requisition->height += child_requisition.height;
else
{
GtkWidgetAuxInfo *aux_info;
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (bin->child), quark_aux_info);
GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
if (aux_info && aux_info->height > 0)
{
requisition->height += aux_info->height;

136
gtk/gtkwidget.c
View File

@ -198,6 +198,8 @@ static gboolean gtk_widget_real_activate_mnemonic (GtkWidget *widget,
static GtkWidgetAuxInfo* gtk_widget_aux_info_new (void);
static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
static void gtk_widget_do_uposition (GtkWidget *widget);
static gpointer parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
@ -837,6 +839,7 @@ gtk_widget_set_arg (GtkObject *object,
guint arg_id)
{
GtkWidget *widget;
GtkWidgetAuxInfo *aux_info;
widget = GTK_WIDGET (object);
@ -851,10 +854,26 @@ gtk_widget_set_arg (GtkObject *object,
gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget);
break;
case ARG_X:
gtk_widget_set_uposition (widget, GTK_VALUE_INT (*arg), -2);
aux_info = _gtk_widget_get_aux_info (widget, TRUE);
if (GTK_VALUE_INT (*arg) == -1)
aux_info->x_set = FALSE;
else
{
aux_info->x_set = TRUE;
aux_info->x = GTK_VALUE_INT (*arg);
}
gtk_widget_do_uposition (widget);
break;
case ARG_Y:
gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg));
aux_info = _gtk_widget_get_aux_info (widget, TRUE);
if (GTK_VALUE_INT (*arg) == -1)
aux_info->y_set = FALSE;
else
{
aux_info->y_set = TRUE;
aux_info->y = GTK_VALUE_INT (*arg);
}
gtk_widget_do_uposition (widget);
break;
case ARG_WIDTH:
gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -2);
@ -960,28 +979,28 @@ gtk_widget_get_arg (GtkObject *object,
GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent;
break;
case ARG_X:
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
if (!aux_info)
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (!aux_info || !aux_info->x_set)
GTK_VALUE_INT (*arg) = -1;
else
GTK_VALUE_INT (*arg) = aux_info->x;
break;
case ARG_Y:
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
if (!aux_info)
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (!aux_info || !aux_info->y_set)
GTK_VALUE_INT (*arg) = -1;
else
GTK_VALUE_INT (*arg) = aux_info->y;
break;
case ARG_WIDTH:
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (!aux_info)
GTK_VALUE_INT (*arg) = -1;
else
GTK_VALUE_INT (*arg) = aux_info->width;
break;
case ARG_HEIGHT:
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (!aux_info)
GTK_VALUE_INT (*arg) = -1;
else
@ -1970,7 +1989,7 @@ gtk_widget_get_child_requisition (GtkWidget *widget,
*requisition = widget->requisition;
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
{
if (aux_info->width > 0)
@ -2001,7 +2020,7 @@ gtk_widget_size_allocate (GtkWidget *widget,
g_return_if_fail (GTK_IS_WIDGET (widget));
real_allocation = *allocation;
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
{
@ -3930,11 +3949,26 @@ gtk_widget_get_parent_window (GtkWidget *widget)
return (parent_window != NULL) ? parent_window : widget->parent->window;
}
/* Update the position from aux_info. Used from gtk_widget_set_uposition
* and gtk_widget_set_arg().
*/
static void
gtk_widget_do_uposition (GtkWidget *widget)
{
GtkWidgetAuxInfo *aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (GTK_IS_WINDOW (widget) && aux_info->x_set && aux_info->y_set)
gtk_window_reposition (GTK_WINDOW (widget), aux_info->x, aux_info->y);
if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
gtk_widget_size_allocate (widget, &widget->allocation);
}
/**
* gtk_widget_set_uposition:
* @widget: a #GtkWidget
* @x: x position
* @y: y position
* @x: x position; -1 to unset x; -2 to leave x unchanged
* @y: y position; -1 to unset y; -2 to leave y unchanged
*
*
* Sets the position of a widget. The funny "u" in the name comes from
@ -3946,7 +3980,12 @@ gtk_widget_get_parent_window (GtkWidget *widget)
* window; most window managers will do the centering on your behalf
* if you call gtk_window_set_transient_for(), and it's really not
* possible to get the centering to work correctly in all cases from
* application code.
* application code. But if you insist, use gtk_window_set_position()
* to set #GTK_WIN_POS_CENTER_ON_PARENT, don't do the centering
* manually.
*
* Note that although x and y can be individually unset, the position
* is not honoured unless both x and y are set.
**/
void
gtk_widget_set_uposition (GtkWidget *widget,
@ -3958,25 +3997,33 @@ gtk_widget_set_uposition (GtkWidget *widget,
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
if (!aux_info)
{
aux_info = gtk_widget_aux_info_new ();
gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info);
}
aux_info =_gtk_widget_get_aux_info (widget, TRUE);
/* keep this in sync with gtk_window_compute_reposition() */
/* keep this in sync with gtk_window_set_location() */
if (x > -2)
{
if (x == -1)
aux_info->x_set = FALSE;
else
{
aux_info->x_set = TRUE;
aux_info->x = x;
}
}
if (y > -2)
{
if (y == -1)
aux_info->y_set = FALSE;
else
{
aux_info->y_set = TRUE;
aux_info->y = y;
}
}
if (GTK_IS_WINDOW (widget) && (aux_info->x != -1) && (aux_info->y != -1))
gtk_window_reposition (GTK_WINDOW (widget), x, y);
if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
gtk_widget_size_allocate (widget, &widget->allocation);
gtk_widget_do_uposition (widget);
}
/**
@ -4014,12 +4061,7 @@ gtk_widget_set_usize (GtkWidget *widget,
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
if (!aux_info)
{
aux_info = gtk_widget_aux_info_new ();
gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info);
}
aux_info =_gtk_widget_get_aux_info (widget, TRUE);
if (width > -2)
aux_info->width = width;
@ -4742,7 +4784,7 @@ gtk_widget_finalize (GObject *object)
if (widget->name)
g_free (widget->name);
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
gtk_widget_aux_info_destroy (aux_info);
@ -4978,6 +5020,36 @@ gtk_widget_propagate_state (GtkWidget *widget,
}
}
/**
* _gtk_widget_get_aux_info:
* @widget: a #GtkWidget
* @create: if %TRUE, create the structure if it doesn't exist
*
* Get the #GtkWidgetAuxInfo structure for the widget.
*
* Return value: the #GtkAuxInfo structure for the widget, or
* %NULL if @create is %FALSE and one doesn't already exist.
**/
GtkWidgetAuxInfo *
_gtk_widget_get_aux_info (GtkWidget *widget,
gboolean create)
{
GtkWidgetAuxInfo *aux_info;
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
if (!aux_info && create)
{
aux_info = gtk_widget_aux_info_new ();
gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info);
aux_info->width = aux_info->height = -1;
aux_info->x = aux_info->y = 0;
aux_info->x_set = aux_info->y_set = FALSE;
}
return aux_info;
}
/*****************************************
* gtk_widget_aux_info_new:
*

4
gtk/gtkwidget.h
View File

@ -394,6 +394,8 @@ struct _GtkWidgetAuxInfo
gint y;
gint width;
gint height;
guint x_set : 1;
guint y_set : 1;
};
struct _GtkWidgetShapeInfo
@ -679,6 +681,8 @@ void gtk_widget_class_path (GtkWidget *widget,
# define gtk_widget_unref gtk_object_unref
#endif /* GTK_TRACE_OBJECTS && __GNUC__ */
GtkWidgetAuxInfo *_gtk_widget_get_aux_info (GtkWidget *widget,
gboolean create);
#ifdef __cplusplus
}

463
gtk/gtkwindow.c
View File

@ -93,7 +93,7 @@ typedef struct {
GdkGeometry geometry; /* Geometry hints */
GdkWindowHints mask;
GtkWidget *widget; /* subwidget to which hints apply */
gint width; /* Default size */
gint width; /* gtk_window_set_default_size () */
gint height;
GtkWindowLastGeometryInfo last;
@ -166,7 +166,7 @@ static void gtk_window_constrain_size (GtkWindow *window,
static void gtk_window_compute_hints (GtkWindow *window,
GdkGeometry *new_geometry,
guint *new_flags);
static void gtk_window_compute_reposition (GtkWindow *window,
static gboolean gtk_window_compute_reposition (GtkWindow *window,
gint new_width,
gint new_height,
gint *x,
@ -450,6 +450,7 @@ gtk_window_init (GtkWindow *window)
window->frame_top = 0;
window->frame_bottom = 0;
window->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
window->gravity = GDK_GRAVITY_NORTH_WEST;
window->decorated = TRUE;
window->mnemonic_modifier = GDK_MOD1_MASK;
@ -1479,6 +1480,22 @@ gtk_window_set_default_size (GtkWindow *window,
if (height >= 0)
g_object_notify (G_OBJECT (window), "height");
if (GTK_WIDGET_REALIZED (window) && window->allow_grow)
{
/* Resize as if the user had resized */
GdkGeometry new_geometry;
GdkWindowHints new_flags;
gtk_window_compute_hints (window, &new_geometry, &new_flags);
gtk_window_constrain_size (window,
&new_geometry, new_flags,
width, height,
&width, &height);
gdk_window_resize (GTK_WIDGET (window)->window,
width, height);
}
else
gtk_widget_queue_resize (GTK_WIDGET (window));
}
@ -2457,6 +2474,7 @@ gtk_window_move_resize (GtkWindow *window)
GtkWindowLastGeometryInfo saved_last_info;
GdkGeometry new_geometry;
guint new_flags;
gboolean need_reposition;
gint x, y;
gint width, height;
gint new_width, new_height;
@ -2502,10 +2520,10 @@ gtk_window_move_resize (GtkWindow *window)
/* From the default size and the allocation, figure out the size
* the window should be.
*/
if (!default_size_changed ||
(!window->auto_shrink &&
new_width <= widget->allocation.width &&
new_height <= widget->allocation.height))
if (!window->auto_shrink &&
(!default_size_changed ||
(new_width <= widget->allocation.width &&
new_height <= widget->allocation.height)))
{
new_width = widget->allocation.width;
new_height = widget->allocation.height;
@ -2519,8 +2537,8 @@ gtk_window_move_resize (GtkWindow *window)
/* compute new window position if a move is required
*/
gtk_window_compute_reposition (window, new_width, new_height, &x, &y);
if (x != 1 && y != -1 && !(new_flags & GDK_HINT_POS))
need_reposition = gtk_window_compute_reposition (window, new_width, new_height, &x, &y);
if (need_reposition && !(new_flags & GDK_HINT_POS))
{
new_flags |= GDK_HINT_POS;
hints_changed = TRUE;
@ -2583,7 +2601,7 @@ gtk_window_move_resize (GtkWindow *window)
* the new size had been set.
*/
if (x != -1 && y != -1)
if (need_reposition)
{
if (window->frame)
gdk_window_move (window->frame, x - window->frame_left, y - window->frame_top);
@ -2632,7 +2650,7 @@ gtk_window_move_resize (GtkWindow *window)
*/
/* request a new window size */
if (x != -1 && y != -1)
if (need_reposition)
{
if (window->frame)
{
@ -2675,7 +2693,7 @@ gtk_window_move_resize (GtkWindow *window)
}
else
{
if (x != -1 && y != -1)
if (need_reposition)
{
if (window->frame)
gdk_window_move (window->frame, x - window->frame_left, y - window->frame_top);
@ -2724,6 +2742,10 @@ gtk_window_compare_hints (GdkGeometry *geometry_a,
geometry_a->height_inc != geometry_b->height_inc))
return FALSE;
if ((flags_a & GDK_HINT_WIN_GRAVITY) &&
(geometry_a->win_gravity != geometry_b->win_gravity))
return FALSE;
return TRUE;
}
@ -2837,8 +2859,8 @@ gtk_window_compute_hints (GtkWindow *window,
ux = 0;
uy = 0;
aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
if (aux_info && (aux_info->x != -1) && (aux_info->y != -1))
aux_info = _gtk_widget_get_aux_info (widget, FALSE);
if (aux_info && aux_info->x_set && aux_info->y_set)
{
ux = aux_info->x;
uy = aux_info->y;
@ -2899,13 +2921,16 @@ gtk_window_compute_hints (GtkWindow *window,
new_geometry->max_width = requisition.width;
new_geometry->max_height = requisition.height;
}
*new_flags |= GDK_HINT_WIN_GRAVITY;
new_geometry->win_gravity = window->gravity;
}
/* Compute a new position for the window based on a new
* size. *x and *y will be set to the new coordinates, or to -1 if the
* window does not need to be moved
* size. *x and *y will be set to the new coordinates. Returns
* TRUE if the window needs to be moved;
*/
static void
static gboolean
gtk_window_compute_reposition (GtkWindow *window,
gint new_width,
gint new_height,
@ -2915,12 +2940,10 @@ gtk_window_compute_reposition (GtkWindow *window,
GtkWidget *widget;
GtkWindowPosition pos;
GtkWidget *parent_widget;
gboolean result = FALSE;
widget = GTK_WIDGET (window);
*x = -1;
*y = -1;
parent_widget = (GtkWidget*) window->transient_parent;
pos = window->position;
@ -2940,6 +2963,8 @@ gtk_window_compute_reposition (GtkWindow *window,
*x = (screen_width - new_width) / 2;
*y = (screen_height - new_height) / 2;
result = TRUE;
}
break;
@ -2952,6 +2977,8 @@ gtk_window_compute_reposition (GtkWindow *window,
*x = ox + (parent_widget->allocation.width - new_width) / 2;
*y = oy + (parent_widget->allocation.height - new_height) / 2;
result = TRUE;
}
break;
@ -2966,43 +2993,37 @@ gtk_window_compute_reposition (GtkWindow *window,
*y -= new_height / 2;
*x = CLAMP (*x, 0, screen_width - new_width);
*y = CLAMP (*y, 0, screen_height - new_height);
result = TRUE;
}
break;
default:
if (window->use_uposition)
{
GtkWidgetAuxInfo *aux_info;
aux_info = gtk_object_get_data (GTK_OBJECT (window), "gtk-aux-info");
if (aux_info &&
aux_info->x != -1 && aux_info->y != -1 &&
aux_info->x != -2 && aux_info->y != -2)
GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (widget, FALSE);
if (aux_info && aux_info->x_set && aux_info->y_set)
{
*x = aux_info->x;
*y = aux_info->y;
}
result = TRUE;
}
break;
}
if (*x != -1 && *y != -1)
if (result)
{
GtkWidgetAuxInfo *aux_info;
GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (widget, TRUE);
/* we handle necessary window positioning by hand here,
* so we can coalesce the window movement with possible
* resizes to get only one configure event.
* keep this in sync with gtk_widget_set_uposition()
* and gtk_window_reposition().
*/
gtk_widget_set_uposition (widget, -1, -1); /* ensure we have aux_info */
aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
aux_info->x_set = aux_info->y_set = TRUE;
aux_info->x = *x;
aux_info->y = *y;
window->use_uposition = FALSE;
}
return result;
}
/***********************
@ -3374,6 +3395,375 @@ gtk_window_unmaximize (GtkWindow *window)
gdk_window_unmaximize (toplevel);
}
/**
* gtk_window_set_resizeable:
* @window: a #GtkWindow
* @setting: %TRUE if the user can resize this window
*
* Sets whether the user can resize a window. Windows are user resizeable
* by default.
*
**/
void
gtk_window_set_resizeable (GtkWindow *window,
gboolean setting)
{
g_return_if_fail (GTK_IS_WINDOW (window));
if (setting)
gtk_window_set_policy (window, FALSE, TRUE, FALSE);
else
gtk_window_set_policy (window, FALSE, FALSE, TRUE);
}
/**
* gtk_window_get_resizeable:
* @window: a #GtkWindow
*
* Gets the value set by gtk_window_set_resizeable().
*
* Return value: %TRUE if the user can resize the window
**/
gboolean
gtk_window_get_resizeable (GtkWindow *window)
{
g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
/* allow_grow is most likely to indicate the semantic concept we
* mean by "resizeable" (and will be a reliable indicator if
* set_policy() hasn't been called)
*/
return window->allow_grow;
}
/**
* gtk_window_set_size:
* @window: a #GtkWindow
* @width: width, or -1 to use the default width
* @height: height, or -1 to use the default height
*
* Sets the size of @window, but only works for resizeable windows
* (see gtk_window_set_resizeable()). Setting the size emulates a user
* resize operation. Therefore, setting the size less than the minimum
* size for the window will simply make the window its minimum size,
* and the user will be able to change the size that's set.
*
* This call also sets the default size of the window, so replaces
* gtk_window_set_default_size().
*
* To set a minimum size, or to set the size of a non-resizeable window,
* use gtk_widget_set_usize() on the window. Though normally it makes
* more sense to instead call gtk_widget_set_usize() on a child widget inside
* the window, rather than the window itself.
*
* Under the X Window System, window managers are allowed to ignore GTK+'s
* request to change a window's size. So your program should not rely on
* getting a specific size. (And, as noted in gtk_window_get_size(),
* a program that crucially relies on a specific size will generally have
* race conditions and be buggy anyway - rather than assuming a
* call to gtk_window_set_size() has taken effect, you should react
* to configure_event signals on your #GtkWindow.)
*
* If you set a geometry widget for the window with
* gtk_window_set_geometry_hints(), the size applies to the geometry
* widget, not the window itself.
*
* If you've called the deprecated gtk_window_set_policy() function,
* gtk_window_set_size() may not behave as expected, due to interaction
* with window policies.
**/
void
gtk_window_set_size (GtkWindow *window,
gint width,
gint height)
{
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (width != 0);
g_return_if_fail (height != 0);
/* set_default_size() uses "0" to mean "unset", but we allow "-1"
* for that in this newer function
*/
if (width < 0)
width = 0;
if (height < 0)
height = 0;
gtk_window_set_default_size (window, width, height);
}
/**
* gtk_window_get_size:
* @window: a #GtkWindow
* @width: return location for current width, or %NULL
* @height: return location for current height, or %NULL
*
* Obtains the current size of @window. If the window is not onscreen
* (i.e. has not been received its first configure_event after being
* shown with gtk_widget_show()), the size will be the size GTK+ will
* request for this window when it's shown. The window manager may
* not choose to give the window exactly this requested size.
*
* In general, code which depends on window size should connect to the
* configure_event on the window so that it can respond to changes in
* size caused by the user or by the window manager, in addition to
* changes in size created by your program.
*
* If you set a geometry widget for the window with
* gtk_window_set_geometry_hints(), the size retrieved is the size of
* the geometry widget, not the window itself.
*
**/
void
gtk_window_get_size (GtkWindow *window,
gint *width,
gint *height)
{
GtkWindowGeometryInfo *info;
GtkWidget *widget = GTK_WIDGET (window);
g_return_if_fail (GTK_IS_WINDOW (window));
if (GTK_WIDGET_REALIZED (window))
{
gdk_window_get_size (GTK_WIDGET (window)->window,
width, height);
}
else
{
GdkGeometry new_geometry;
GdkWindowHints new_flags;
gint w, h;
gtk_widget_size_request (widget, NULL);
gtk_window_compute_default_size (window, &w, &h);
gtk_window_compute_hints (window, &new_geometry, &new_flags);
gtk_window_constrain_size (window,
&new_geometry, new_flags,
w, h,
&w, &h);
if (width)
*width = w;
if (height)
*height = h;
}
info = gtk_window_get_geometry_info (window, TRUE);
if (info->widget)
{
gint extra_width = widget->requisition.width - info->widget->requisition.width;
gint extra_height = widget->requisition.height - info->widget->requisition.height;
if (width)
*width -= extra_width;
if (height)
*height -= extra_height;
}
}
/**
* gtk_window_set_location:
* @window: a #GtkWindow
* @root_x: X position of gravity-determined reference point in root window coordinates
* @root_y: Y position of gravity-determined reference point in root window coordinates
*
* Requests a new position for a #GtkWindow. The position is given in
* root window coordinates, and is the position of the window's
* "reference point" as determined by the window gravity (see
* gtk_window_set_gravity()). By default, the reference point is the
* northwest (top left) corner of the window's titlebar. So if you
* set the window position to (0,0), the window's titlebar will end up
* in the top left corner of the root window. Note that the root
* window does not always correspond to the user's desktop area, so
* you may want to call gdk_workspace_get_extents() or
* gdk_desktop_get_extents() to decide where to place a window. The
* extents of the root window can be obtained using gdk_screen_width()
* and gdk_screen_height().
*
**/
void
gtk_window_set_location (GtkWindow *window,
gint root_x,
gint root_y)
{
GtkWidgetAuxInfo *aux_info;
g_return_if_fail (GTK_IS_WINDOW (window));
aux_info = _gtk_widget_get_aux_info (GTK_WIDGET (window), TRUE);
aux_info->x_set = aux_info->y_set = TRUE;
aux_info->x = root_x;
aux_info->y = root_y;
gtk_window_reposition (window, root_x, root_y);
}
/**
* gtk_window_get_location:
* @window: a #GtkWindow
* @root_x: return location for X coordinate of gravity-determined reference point
* @root_y: return location for Y coordinate of gravity-determined reference point
*
* Attempts to obtain the current position of the reference point, as
* set by gtk_window_set_position(). This computation is accurate when
* the reference point is a corner of the window itself (as with
* #GDK_GRAVITY_STATIC), but may not be accurate when the reference
* point is a position on the titlebar or window border, because the X
* Window System does not provide a reliable way of obtaining this
* information. GTK+ will do a "best guess" which may not be fully
* accurate with some window managers, but will probably be
* reasonable.
*
**/
void
gtk_window_get_location (GtkWindow *window,
gint *root_x,
gint *root_y)
{
GdkRectangle frame_extents;
GtkWidget *widget;
GtkWidgetAuxInfo *aux_info;
g_return_if_fail (GTK_IS_WINDOW (window));
widget = GTK_WIDGET (window);
if (GTK_WIDGET_REALIZED (window))
{
if (window->gravity == GDK_GRAVITY_STATIC)
{
gdk_window_get_origin (widget->window, root_x, root_y);
return;
}
else
{
gint x, y;
gdk_window_get_frame_extents (widget->window, &frame_extents);
x = frame_extents.x;
y = frame_extents.y;
switch (window->gravity)
{
case GDK_GRAVITY_NORTH:
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_SOUTH:
x += frame_extents.width / 2;
break;
case GDK_GRAVITY_SOUTH_EAST:
case GDK_GRAVITY_EAST:
case GDK_GRAVITY_NORTH_EAST:
x += frame_extents.width;
break;
default:
break;
}
switch (window->gravity)
{
case GDK_GRAVITY_WEST:
case GDK_GRAVITY_CENTER:
case GDK_GRAVITY_EAST:
y += frame_extents.height / 2;
break;
case GDK_GRAVITY_SOUTH_WEST:
case GDK_GRAVITY_SOUTH:
case GDK_GRAVITY_SOUTH_EAST:
y += frame_extents.height;
break;
default:
break;
}
if (root_x)
*root_x = x;
if (root_y)
*root_y = y;
}
}
else
{
/* We really don't have a location yet, so we make up some stuff,
* using the uposition if it's been set.
*/
if (root_x)
*root_x = 0;
if (root_y)
*root_y = 0;
aux_info = _gtk_widget_get_aux_info (widget, FALSE);
if (aux_info && aux_info->x_set && aux_info->y_set)
{
*root_x = aux_info->x;
*root_y = aux_info->y;
}
}
}
/**
* gtk_window_set_gravity:
* @window: a #GtkWindow
* @gravity: window gravity
*
* Window gravity defines the "reference point" to be used when
* positioning or resizing a window. Calls to
* gtk_window_set_position() will position a different point on the
* window depending on the window gravity. When the window changes size
* the reference point determined by the window's gravity will stay in
* a fixed location.
*
* See #GdkGravity for full details. To briefly summarize,
* #GDK_GRAVITY_NORTH_WEST means that the reference point is the
* northwest (top left) corner of the window
* frame. #GDK_GRAVITY_SOUTH_EAST would be the bottom right corner of
* the frame, and so on. If you want to position the window contents,
* rather than the window manager's frame, #GDK_GRAVITY_STATIC moves
* the reference point to the northwest corner of the #GtkWindow
* itself.
*
* The default window gravity is #GDK_GRAVITY_NORTH_WEST.
*
**/
void
gtk_window_set_gravity (GtkWindow *window,
GdkGravity gravity)
{
g_return_if_fail (GTK_IS_WINDOW (window));
if (gravity != window->gravity)
{
window->gravity = gravity;
/* This is sort of odd, but it keeps the hints recomputation
* in one place. Otherwise we're likely to mess up the
* recording of the last hints, etc.
*/
gtk_widget_queue_resize (GTK_WIDGET (window));
}
}
/**
* gtk_window_get_gravity:
* @window: a #GtkWindow
*
* Gets the value set by gtk_window_set_gravity().
*
* Return value: window gravity
**/
GdkGravity
gtk_window_get_gravity (GtkWindow *window)
{
g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
return window->gravity;
}
/**
* gtk_window_begin_resize_drag:
* @window: a #GtkWindow
@ -3417,7 +3807,6 @@ gtk_window_begin_resize_drag (GtkWindow *window,
timestamp);
}
/**
* gtk_window_begin_move_drag:
* @button: mouse button that initiated the drag

59
gtk/gtkwindow.h
View File

@ -93,7 +93,9 @@ struct _GtkWindow
guint decorated : 1;
GdkWindowTypeHint type_hint : 2;
GdkWindowTypeHint type_hint : 3;
GdkGravity gravity : 5;
guint frame_left;
guint frame_top;
@ -123,10 +125,6 @@ void gtk_window_set_wmclass (GtkWindow *window,
const gchar *wmclass_class);
void gtk_window_set_role (GtkWindow *window,
const gchar *role);
void gtk_window_set_policy (GtkWindow *window,
gboolean allow_shrink,
gboolean allow_grow,
gboolean auto_shrink);
void gtk_window_add_accel_group (GtkWindow *window,
GtkAccelGroup *accel_group);
void gtk_window_remove_accel_group (GtkWindow *window,
@ -142,22 +140,41 @@ void gtk_window_set_type_hint (GtkWindow *window,
GdkWindowTypeHint hint);
void gtk_window_set_destroy_with_parent (GtkWindow *window,
gboolean setting);
void gtk_window_set_geometry_hints (GtkWindow *window,
GtkWidget *geometry_widget,
GdkGeometry *geometry,
GdkWindowHints geom_mask);
void gtk_window_set_decorations_hint (GtkWindow *window,
GdkWMDecoration decorations);
void gtk_window_set_functions_hint (GtkWindow *window,
GdkWMFunction functions);
/* The following differs from gtk_widget_set_usize, in that
* gtk_widget_set_usize() overrides the requisition, so sets a minimum
* size, while this only sets the size requested from the WM.
*/
void gtk_window_set_default_size (GtkWindow *window,
void gtk_window_set_resizeable (GtkWindow *window,
gboolean setting);
gboolean gtk_window_get_resizeable (GtkWindow *window);
void gtk_window_set_size (GtkWindow *window,
gint width,
gint height);
void gtk_window_get_size (GtkWindow *window,
gint *width,
gint *height);
void gtk_window_set_location (GtkWindow *window,
gint root_x,
gint root_y);
void gtk_window_get_location (GtkWindow *window,
gint *root_x,
gint *root_y);
void gtk_window_set_gravity (GtkWindow *window,
GdkGravity gravity);
GdkGravity gtk_window_get_gravity (GtkWindow *window);
void gtk_window_set_geometry_hints (GtkWindow *window,
GtkWidget *geometry_widget,
GdkGeometry *geometry,
GdkWindowHints geom_mask);
/* gtk_window_set_has_frame () must be called before realizing the window_*/
void gtk_window_set_has_frame (GtkWindow *window);
void gtk_window_set_frame_dimensions (GtkWindow *window,
@ -186,7 +203,6 @@ gboolean gtk_window_activate_mnemonic (GtkWindow *window,
void gtk_window_set_mnemonic_modifier (GtkWindow *window,
GdkModifierType modifier);
void gtk_window_present (GtkWindow *window);
void gtk_window_iconify (GtkWindow *window);
void gtk_window_deiconify (GtkWindow *window);
@ -207,6 +223,19 @@ void gtk_window_begin_move_drag (GtkWindow *window,
gint root_y,
guint32 timestamp);
#ifndef GTK_DISABLE_DEPRECATED
void gtk_window_set_policy (GtkWindow *window,
gint allow_shrink,
gint allow_grow,
gint auto_shrink);
/* The following differs from gtk_widget_set_usize, in that
* gtk_widget_set_usize() overrides the requisition, so sets a minimum
* size, while this only sets the size requested from the WM.
*/
void gtk_window_set_default_size (GtkWindow *window,
gint width,
gint height);
#endif
/* --- internal functions --- */
void gtk_window_set_focus (GtkWindow *window,

320
gtk/testgtk.c
View File

@ -8206,6 +8206,325 @@ create_window_states (void)
gtk_widget_destroy (window);
}
/*
* Window sizing
*/
static gint
configure_event_callback (GtkWidget *widget,
GdkEventConfigure *event,
gpointer data)
{
GtkWidget *label = data;
gchar *msg;
gint x, y;
gtk_window_get_location (GTK_WINDOW (widget), &x, &y);
msg = g_strdup_printf ("event: %d,%d %d x %d\n"
"location: %d, %d",
event->x, event->y, event->width, event->height,
x, y);
gtk_label_set_text (GTK_LABEL (label), msg);
g_free (msg);
return FALSE;
}
static void
get_ints (GtkWidget *window,
gint *a,
gint *b)
{
GtkWidget *spin1;
GtkWidget *spin2;
spin1 = g_object_get_data (G_OBJECT (window), "spin1");
spin2 = g_object_get_data (G_OBJECT (window), "spin2");
*a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
*b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
}
static void
set_size_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_window_set_size (g_object_get_data (data, "target"),
w, h);
}
static void
set_default_size_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_window_set_default_size (g_object_get_data (data, "target"),
w, h);
}
static void
set_usize_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_widget_set_usize (g_object_get_data (data, "target"),
w, h);
}
static void
set_location_callback (GtkWidget *widget,
gpointer data)
{
gint x, y;
get_ints (data, &x, &y);
gtk_window_set_location (g_object_get_data (data, "target"),
x, y);
}
static void
allow_shrink_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (G_OBJECT (g_object_get_data (data, "target")),
"allow_shrink",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
}
static void
allow_grow_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (G_OBJECT (g_object_get_data (data, "target")),
"allow_grow",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
}
static void
auto_shrink_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (G_OBJECT (g_object_get_data (data, "target")),
"auto_shrink",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
}
static void
gravity_selected (GtkWidget *widget,
gpointer data)
{
gtk_window_set_gravity (G_OBJECT (g_object_get_data (data, "target")),
gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
}
static GtkWidget*
window_controls (GtkWidget *window)
{
GtkWidget *control_window;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *spin;
GtkAdjustment *adj;
GtkWidget *om;
GtkWidget *menu;
gint i;
control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
g_object_set_data (G_OBJECT (control_window),
"target",
window);
gtk_signal_connect_object (GTK_OBJECT (control_window),
"destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (control_window), vbox);
label = gtk_label_new ("<no configure events>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (window),
"configure_event",
GTK_SIGNAL_FUNC (configure_event_callback),
label);
adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
5.0, 0.0);
spin = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin1", spin);
adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
5.0, 0.0);
spin = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin2", spin);
button = gtk_button_new_with_label ("Queue resize");
gtk_signal_connect_object (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set size");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_size_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set default size");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_default_size_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set usize");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_usize_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set location");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_location_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Allow shrink");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_signal_connect (GTK_WIDGET (button),
"toggled",
GTK_SIGNAL_FUNC (allow_shrink_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Allow grow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_WIDGET (button),
"toggled",
GTK_SIGNAL_FUNC (allow_grow_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Auto shrink");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_signal_connect (GTK_WIDGET (button),
"toggled",
GTK_SIGNAL_FUNC (auto_shrink_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
menu = gtk_menu_new ();
i = 0;
while (i < 10)
{
GtkWidget *mi;
static gchar *names[10] = {
"GDK_GRAVITY_NORTH_WEST",
"GDK_GRAVITY_NORTH",
"GDK_GRAVITY_NORTH_EAST",
"GDK_GRAVITY_WEST",
"GDK_GRAVITY_CENTER",
"GDK_GRAVITY_EAST",
"GDK_GRAVITY_SOUTH_WEST",
"GDK_GRAVITY_SOUTH",
"GDK_GRAVITY_SOUTH_EAST",
"GDK_GRAVITY_STATIC",
NULL
};
g_assert (names[i]);
mi = gtk_menu_item_new_with_label (names[i]);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
++i;
}
gtk_widget_show_all (menu);
om = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
gtk_signal_connect (GTK_OBJECT (om),
"changed",
GTK_SIGNAL_FUNC (gravity_selected),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return control_window;
}
void
create_window_sizing (void)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *label;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
gtk_container_add (GTK_CONTAINER (window), label);
gtk_widget_show (label);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Window to size");
gtk_widget_show (window_controls (window));
}
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* GtkProgressBar
*/
@ -9848,6 +10167,7 @@ create_main_window (void)
{ "tooltips", create_tooltips },
{ "tree", create_tree_mode_window},
{ "WM hints", create_wmhints },
{ "window sizing", create_window_sizing },
{ "window states", create_window_states }
};
int nbuttons = sizeof (buttons) / sizeof (buttons[0]);

320
tests/testgtk.c
View File

@ -8206,6 +8206,325 @@ create_window_states (void)
gtk_widget_destroy (window);
}
/*
* Window sizing
*/
static gint
configure_event_callback (GtkWidget *widget,
GdkEventConfigure *event,
gpointer data)
{
GtkWidget *label = data;
gchar *msg;
gint x, y;
gtk_window_get_location (GTK_WINDOW (widget), &x, &y);
msg = g_strdup_printf ("event: %d,%d %d x %d\n"
"location: %d, %d",
event->x, event->y, event->width, event->height,
x, y);
gtk_label_set_text (GTK_LABEL (label), msg);
g_free (msg);
return FALSE;
}
static void
get_ints (GtkWidget *window,
gint *a,
gint *b)
{
GtkWidget *spin1;
GtkWidget *spin2;
spin1 = g_object_get_data (G_OBJECT (window), "spin1");
spin2 = g_object_get_data (G_OBJECT (window), "spin2");
*a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
*b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
}
static void
set_size_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_window_set_size (g_object_get_data (data, "target"),
w, h);
}
static void
set_default_size_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_window_set_default_size (g_object_get_data (data, "target"),
w, h);
}
static void
set_usize_callback (GtkWidget *widget,
gpointer data)
{
gint w, h;
get_ints (data, &w, &h);
gtk_widget_set_usize (g_object_get_data (data, "target"),
w, h);
}
static void
set_location_callback (GtkWidget *widget,
gpointer data)
{
gint x, y;
get_ints (data, &x, &y);
gtk_window_set_location (g_object_get_data (data, "target"),
x, y);
}
static void
allow_shrink_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (G_OBJECT (g_object_get_data (data, "target")),
"allow_shrink",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
}
static void
allow_grow_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (G_OBJECT (g_object_get_data (data, "target")),
"allow_grow",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
}
static void
auto_shrink_callback (GtkWidget *widget,
gpointer data)
{
g_object_set (G_OBJECT (g_object_get_data (data, "target")),
"auto_shrink",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
}
static void
gravity_selected (GtkWidget *widget,
gpointer data)
{
gtk_window_set_gravity (G_OBJECT (g_object_get_data (data, "target")),
gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
}
static GtkWidget*
window_controls (GtkWidget *window)
{
GtkWidget *control_window;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *spin;
GtkAdjustment *adj;
GtkWidget *om;
GtkWidget *menu;
gint i;
control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
g_object_set_data (G_OBJECT (control_window),
"target",
window);
gtk_signal_connect_object (GTK_OBJECT (control_window),
"destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (control_window), vbox);
label = gtk_label_new ("<no configure events>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (window),
"configure_event",
GTK_SIGNAL_FUNC (configure_event_callback),
label);
adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
5.0, 0.0);
spin = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin1", spin);
adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
5.0, 0.0);
spin = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin2", spin);
button = gtk_button_new_with_label ("Queue resize");
gtk_signal_connect_object (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set size");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_size_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set default size");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_default_size_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set usize");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_usize_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set location");
gtk_signal_connect (GTK_WIDGET (button),
"clicked",
GTK_SIGNAL_FUNC (set_location_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Allow shrink");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_signal_connect (GTK_WIDGET (button),
"toggled",
GTK_SIGNAL_FUNC (allow_shrink_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Allow grow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_WIDGET (button),
"toggled",
GTK_SIGNAL_FUNC (allow_grow_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_check_button_new_with_label ("Auto shrink");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_signal_connect (GTK_WIDGET (button),
"toggled",
GTK_SIGNAL_FUNC (auto_shrink_callback),
GTK_OBJECT (control_window));
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
menu = gtk_menu_new ();
i = 0;
while (i < 10)
{
GtkWidget *mi;
static gchar *names[10] = {
"GDK_GRAVITY_NORTH_WEST",
"GDK_GRAVITY_NORTH",
"GDK_GRAVITY_NORTH_EAST",
"GDK_GRAVITY_WEST",
"GDK_GRAVITY_CENTER",
"GDK_GRAVITY_EAST",
"GDK_GRAVITY_SOUTH_WEST",
"GDK_GRAVITY_SOUTH",
"GDK_GRAVITY_SOUTH_EAST",
"GDK_GRAVITY_STATIC",
NULL
};
g_assert (names[i]);
mi = gtk_menu_item_new_with_label (names[i]);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
++i;
}
gtk_widget_show_all (menu);
om = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
gtk_signal_connect (GTK_OBJECT (om),
"changed",
GTK_SIGNAL_FUNC (gravity_selected),
control_window);
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return control_window;
}
void
create_window_sizing (void)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *label;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
gtk_container_add (GTK_CONTAINER (window), label);
gtk_widget_show (label);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
gtk_window_set_title (GTK_WINDOW (window), "Window to size");
gtk_widget_show (window_controls (window));
}
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
/*
* GtkProgressBar
*/
@ -9848,6 +10167,7 @@ create_main_window (void)
{ "tooltips", create_tooltips },
{ "tree", create_tree_mode_window},
{ "WM hints", create_wmhints },
{ "window sizing", create_window_sizing },
{ "window states", create_window_states }
};
int nbuttons = sizeof (buttons) / sizeof (buttons[0]);