AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
09e06dffde
gtk2/gtk/gtkspinbutton.c
Havoc Pennington df4fc36721 Make this compile without framebuffer enabled 
2000-06-20  Havoc Pennington  <hp@redhat.com>

* modules/linux-fb/Makefile.am: Make this compile
without framebuffer enabled

* gdk/linux-fb/Makefile.am: Add conditional to not build
framebuffer unless specified in configure

* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
the size of the target instead of source if -1 was passed for
width/height

* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix
width/height confusion.

2000-06-19  Havoc Pennington  <hp@redhat.com>

* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
GDK_DRAWABLE_XID. In the future, we probably want to make it
faster with G_DISABLE_CHECKS turned on.

2000-06-14  Havoc Pennington  <hp@redhat.com>

        * gdk/Makefile.am: add gdkpixmap.c

	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
	s/gdk_image_init/_gdk_windowing_image_init

	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
	ref/unref

	* gdk/gdkcolor.h: make GdkColormap a GObject subclass

	* gdk/gdkcompat.h: remove GdkWindowType compat, since
	GdkWindowType is now non-deprecated;
	change gdk_window_get_type() compat to be
	gdk_window_get_window_type().

	* gdk/gdkdnd.h: make GdkDragContext a GObject.

	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
	virtual GObject. Make all functions call into the vtable.
	Move gdk_image_put() guts in here. Remove GdkDrawableType
	and gdk_drawable_get_type(), these are now GdkWindow-specific.
	draw_image, get_depth, get_size, set_colormap, get_colormap,
	get_visual added to the vtable.

	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual
	GObject. Virtualize everything.
	(gdk_gc_new_with_values): remove check for destroyed window,
	because now GdkWindow::create_gc will check this.
	(gdk_gc_set_values): New function to set GC values, this
	was already implemented but wasn't in the header

	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.

	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
	remove _gdk_window_class; add _gdk_window_impl_get_type() and
	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
	_gdk_windowing_window_init, rename gdk_image_init to
	_gdk_windowing_image_init.

	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
	(gdk_draw_layout): Remove check for destroyed window,
	because all the drawable methods already check it.

	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
	Add gdkpixmap.c which contains implementation of GdkDrawable
	virtual table (by chaining to a platform-specific implementation
	object).

	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP,
	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
	GdkColormapPrivate.

	* gdk/gdktypes.h: #include <glib-object.h>

	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
	Move most functionality to platform-specific implementation
	object. GdkWindow itself now handles the backing store, then
	chains to the platform-specific implementation.
	(gdk_window_get_window_type): return GdkWindowType of the window.
	(gdk_window_peek_children): New routine, returns the children of
	a GdkWindow
	(gdk_window_get_children): Was in X11-specific code and did
	XQueryTree. Changed to simply return a copy of window->children;
	so it can go in cross-platform code.

	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path

	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of
	GdkColormap; just changed to use the new private data instead
	of casting to GdkColormapPrivate.

	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to
	gdk_cursor_new().

	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields
	(private data member in the GObject).
	(xdnd_manager_source_filter): Function had broken
	error handling, fix it (use gdk_error_trap_push).

	* gdk/x11/gdkdrawable-x11.c: This file now implements
	a base class for GdkWindowImplX11/GdkPixmapImplX11. This
	base class is purely for the convenience of the X port,
	and not part of the interface to cross-platform GDK.

	* gdk/x11/gdkevents-x11.c: Reflect various renamings.

	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
	specific to X, and returned by the create_gc virtual method
	of GdkDrawableImplX11.
	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
	rather than gchar, this was also changed in the GdkGC vtable.
	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
	mask is 0, return immediately, instead of checking every flag.
	This is faster, and keeps us from segfaulting if values is NULL
	and the mask contains some nonzero flags.

	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
	GdkWindow.

	* gdk/x11/gdkglobals-x11.c: change type of grab window, since
	GdkWindowPrivate is gone.

	* gdk/x11/gdkim-x11.c: rename things that got renamed.

	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and
	remove the image_put stuff that got transferred to GdkDrawable.

	* gdk/x11/gdkinput.c: renamings

	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>

	* gdk/x11/gdkpixmap-x11.c: GObject conversion

	* gdk/x11/gdkprivate-x11.h: indentation fixes

	* gdk/x11/gdkproperty-x11.c: renamings

	* gdk/x11/gdkselection-x11.c: renamings

	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now
	implements the platform-specific "impl" object.
	Moved gdk_window_get_children to gdk/gdkwindow.c

	* gdk/x11/gdkx.h: Remove all the private structs and private datas
	that no longer exist. Add declaration of GdkGCX11 object here.
	Fix all the macros to still work.

	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
	GdkDragContext from the boxed types since they are now GObjects.

	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
	moved xthickness/ythickness into the instance. GtkStyleClass
	functions are now in the standard vtable for GtkStyle, so you have
	to create a GObject subclass to write a theme engine.
	(gtk_style_copy): fixed a leaked PangoFontDescription
	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
	can be the standard GObject function.

	* Throughout GTK:
	s/style->klass->[xy]thickness/style->[xy]thickness
	s/pango_layout_unref/g_object_unref/

	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.

	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of
	accessing GDK internals.

	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of
	accessing GDK internals.
2000-06-20 21:04:44 +00:00

1696 lines
46 KiB
C
Raw Blame History

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* GtkSpinButton widget for GTK+
* Copyright (C) 1998 Lars Hamann and Stefan Jeske
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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.
*/
/*
* Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <locale.h>
#include "gdk/gdkkeysyms.h"
#include "gtkspinbutton.h"
#include "gtkmain.h"
#include "gtksignal.h"
#define MIN_SPIN_BUTTON_WIDTH 30
#define ARROW_SIZE 11
#define SPIN_BUTTON_INITIAL_TIMER_DELAY 200
#define SPIN_BUTTON_TIMER_DELAY 20
#define MAX_TEXT_LENGTH 256
#define MAX_TIMER_CALLS 5
#define EPSILON 1e-5
enum {
ARG_0,
ARG_ADJUSTMENT,
ARG_CLIMB_RATE,
ARG_DIGITS,
ARG_SNAP_TO_TICKS,
ARG_NUMERIC,
ARG_WRAP,
ARG_UPDATE_POLICY,
ARG_SHADOW_TYPE,
ARG_VALUE
};
/* Signals */
enum
{
INPUT,
OUTPUT,
LAST_SIGNAL
};
static void gtk_spin_button_class_init (GtkSpinButtonClass *klass);
static void gtk_spin_button_init (GtkSpinButton *spin_button);
static void gtk_spin_button_finalize (GObject *object);
static void gtk_spin_button_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
static void gtk_spin_button_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
static void gtk_spin_button_map (GtkWidget *widget);
static void gtk_spin_button_unmap (GtkWidget *widget);
static void gtk_spin_button_realize (GtkWidget *widget);
static void gtk_spin_button_unrealize (GtkWidget *widget);
static void gtk_spin_button_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_spin_button_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_spin_button_paint (GtkWidget *widget,
GdkRectangle *area);
static void gtk_spin_button_draw (GtkWidget *widget,
GdkRectangle *area);
static gint gtk_spin_button_expose (GtkWidget *widget,
GdkEventExpose *event);
static gint gtk_spin_button_button_press (GtkWidget *widget,
GdkEventButton *event);
static gint gtk_spin_button_button_release (GtkWidget *widget,
GdkEventButton *event);
static gint gtk_spin_button_motion_notify (GtkWidget *widget,
GdkEventMotion *event);
static gint gtk_spin_button_enter_notify (GtkWidget *widget,
GdkEventCrossing *event);
static gint gtk_spin_button_leave_notify (GtkWidget *widget,
GdkEventCrossing *event);
static gint gtk_spin_button_focus_out (GtkWidget *widget,
GdkEventFocus *event);
static void gtk_spin_button_draw_arrow (GtkSpinButton *spin_button,
guint arrow);
static gint gtk_spin_button_timer (GtkSpinButton *spin_button);
static void gtk_spin_button_value_changed (GtkAdjustment *adjustment,
GtkSpinButton *spin_button);
static gint gtk_spin_button_key_press (GtkWidget *widget,
GdkEventKey *event);
static gint gtk_spin_button_key_release (GtkWidget *widget,
GdkEventKey *event);
static gint gtk_spin_button_scroll (GtkWidget *widget,
GdkEventScroll *event);
static void gtk_spin_button_activate (GtkEditable *editable);
static void gtk_spin_button_snap (GtkSpinButton *spin_button,
gfloat val);
static void gtk_spin_button_insert_text (GtkEditable *editable,
const gchar *new_text,
gint new_text_length,
gint *position);
static void gtk_spin_button_real_spin (GtkSpinButton *spin_button,
gfloat step);
static gint gtk_spin_button_default_input (GtkSpinButton *spin_button,
gfloat *new_val);
static gint gtk_spin_button_default_output (GtkSpinButton *spin_button);
static GtkEntryClass *parent_class = NULL;
static guint spinbutton_signals[LAST_SIGNAL] = {0};
GtkType
gtk_spin_button_get_type (void)
{
static guint spin_button_type = 0;
if (!spin_button_type)
{
static const GtkTypeInfo spin_button_info =
{
"GtkSpinButton",
sizeof (GtkSpinButton),
sizeof (GtkSpinButtonClass),
(GtkClassInitFunc) gtk_spin_button_class_init,
(GtkObjectInitFunc) gtk_spin_button_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
spin_button_type = gtk_type_unique (GTK_TYPE_ENTRY, &spin_button_info);
}
return spin_button_type;
}
static void
gtk_spin_button_class_init (GtkSpinButtonClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkEditableClass *editable_class;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
editable_class = (GtkEditableClass*) class;
parent_class = gtk_type_class (GTK_TYPE_ENTRY);
gobject_class->finalize = gtk_spin_button_finalize;
object_class->set_arg = gtk_spin_button_set_arg;
object_class->get_arg = gtk_spin_button_get_arg;
widget_class->map = gtk_spin_button_map;
widget_class->unmap = gtk_spin_button_unmap;
widget_class->realize = gtk_spin_button_realize;
widget_class->unrealize = gtk_spin_button_unrealize;
widget_class->size_request = gtk_spin_button_size_request;
widget_class->size_allocate = gtk_spin_button_size_allocate;
widget_class->draw = gtk_spin_button_draw;
widget_class->expose_event = gtk_spin_button_expose;
widget_class->scroll_event = gtk_spin_button_scroll;
widget_class->button_press_event = gtk_spin_button_button_press;
widget_class->button_release_event = gtk_spin_button_button_release;
widget_class->motion_notify_event = gtk_spin_button_motion_notify;
widget_class->key_press_event = gtk_spin_button_key_press;
widget_class->key_release_event = gtk_spin_button_key_release;
widget_class->enter_notify_event = gtk_spin_button_enter_notify;
widget_class->leave_notify_event = gtk_spin_button_leave_notify;
widget_class->focus_out_event = gtk_spin_button_focus_out;
editable_class->insert_text = gtk_spin_button_insert_text;
editable_class->activate = gtk_spin_button_activate;
class->input = NULL;
class->output = NULL;
gtk_object_add_arg_type ("GtkSpinButton::adjustment",
GTK_TYPE_ADJUSTMENT,
GTK_ARG_READWRITE,
ARG_ADJUSTMENT);
gtk_object_add_arg_type ("GtkSpinButton::climb_rate",
GTK_TYPE_FLOAT,
GTK_ARG_READWRITE,
ARG_CLIMB_RATE);
gtk_object_add_arg_type ("GtkSpinButton::digits",
GTK_TYPE_UINT,
GTK_ARG_READWRITE,
ARG_DIGITS);
gtk_object_add_arg_type ("GtkSpinButton::snap_to_ticks",
GTK_TYPE_BOOL,
GTK_ARG_READWRITE,
ARG_SNAP_TO_TICKS);
gtk_object_add_arg_type ("GtkSpinButton::numeric",
GTK_TYPE_BOOL,
GTK_ARG_READWRITE,
ARG_NUMERIC);
gtk_object_add_arg_type ("GtkSpinButton::wrap",
GTK_TYPE_BOOL,
GTK_ARG_READWRITE,
ARG_WRAP);
gtk_object_add_arg_type ("GtkSpinButton::update_policy",
GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY,
GTK_ARG_READWRITE,
ARG_UPDATE_POLICY);
gtk_object_add_arg_type ("GtkSpinButton::shadow_type",
GTK_TYPE_SHADOW_TYPE,
GTK_ARG_READWRITE,
ARG_SHADOW_TYPE);
gtk_object_add_arg_type ("GtkSpinButton::value",
GTK_TYPE_FLOAT,
GTK_ARG_READWRITE,
ARG_VALUE);
spinbutton_signals[INPUT] =
gtk_signal_new ("input",
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkSpinButtonClass, input),
gtk_marshal_INT__POINTER,
GTK_TYPE_INT, 1, GTK_TYPE_POINTER);
spinbutton_signals[OUTPUT] =
gtk_signal_new ("output",
GTK_RUN_LAST,
GTK_CLASS_TYPE (object_class),
GTK_SIGNAL_OFFSET (GtkSpinButtonClass, output),
gtk_marshal_BOOL__NONE,
GTK_TYPE_BOOL, 0);
gtk_object_class_add_signals (object_class, spinbutton_signals, LAST_SIGNAL);
}
static void
gtk_spin_button_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id)
{
GtkSpinButton *spin_button;
spin_button = GTK_SPIN_BUTTON (object);
switch (arg_id)
{
GtkAdjustment *adjustment;
case ARG_ADJUSTMENT:
adjustment = GTK_VALUE_POINTER (*arg);
if (!adjustment)
adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
gtk_spin_button_set_adjustment (spin_button, adjustment);
break;
case ARG_CLIMB_RATE:
gtk_spin_button_configure (spin_button,
spin_button->adjustment,
GTK_VALUE_FLOAT (*arg),
spin_button->digits);
break;
case ARG_DIGITS:
gtk_spin_button_configure (spin_button,
spin_button->adjustment,
spin_button->climb_rate,
GTK_VALUE_UINT (*arg));
break;
case ARG_SNAP_TO_TICKS:
gtk_spin_button_set_snap_to_ticks (spin_button, GTK_VALUE_BOOL (*arg));
break;
case ARG_NUMERIC:
gtk_spin_button_set_numeric (spin_button, GTK_VALUE_BOOL (*arg));
break;
case ARG_WRAP:
gtk_spin_button_set_wrap (spin_button, GTK_VALUE_BOOL (*arg));
break;
case ARG_UPDATE_POLICY:
gtk_spin_button_set_update_policy (spin_button, GTK_VALUE_ENUM (*arg));
break;
case ARG_SHADOW_TYPE:
gtk_spin_button_set_shadow_type (spin_button, GTK_VALUE_ENUM (*arg));
break;
case ARG_VALUE:
gtk_spin_button_set_value (spin_button, GTK_VALUE_FLOAT (*arg));
break;
default:
break;
}
}
static void
gtk_spin_button_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id)
{
GtkSpinButton *spin_button;
spin_button = GTK_SPIN_BUTTON (object);
switch (arg_id)
{
case ARG_ADJUSTMENT:
GTK_VALUE_POINTER (*arg) = spin_button->adjustment;
break;
case ARG_CLIMB_RATE:
GTK_VALUE_FLOAT (*arg) = spin_button->climb_rate;
break;
case ARG_DIGITS:
GTK_VALUE_UINT (*arg) = spin_button->digits;
break;
case ARG_SNAP_TO_TICKS:
GTK_VALUE_BOOL (*arg) = spin_button->snap_to_ticks;
break;
case ARG_NUMERIC:
GTK_VALUE_BOOL (*arg) = spin_button->numeric;
break;
case ARG_WRAP:
GTK_VALUE_BOOL (*arg) = spin_button->wrap;
break;
case ARG_UPDATE_POLICY:
GTK_VALUE_ENUM (*arg) = spin_button->update_policy;
break;
case ARG_SHADOW_TYPE:
GTK_VALUE_ENUM (*arg) = spin_button->shadow_type;
break;
case ARG_VALUE:
GTK_VALUE_FLOAT (*arg) = spin_button->adjustment->value;
break;
default:
arg->type = GTK_TYPE_INVALID;
break;
}
}
static void
gtk_spin_button_init (GtkSpinButton *spin_button)
{
spin_button->adjustment = NULL;
spin_button->panel = NULL;
spin_button->shadow_type = GTK_SHADOW_NONE;
spin_button->timer = 0;
spin_button->ev_time = 0;
spin_button->climb_rate = 0.0;
spin_button->timer_step = 0.0;
spin_button->update_policy = GTK_UPDATE_ALWAYS;
spin_button->in_child = 2;
spin_button->click_child = 2;
spin_button->button = 0;
spin_button->need_timer = FALSE;
spin_button->timer_calls = 0;
spin_button->digits = 0;
spin_button->numeric = FALSE;
spin_button->wrap = FALSE;
spin_button->snap_to_ticks = FALSE;
gtk_spin_button_set_adjustment (spin_button,
(GtkAdjustment*) gtk_adjustment_new (0, 0, 0, 0, 0, 0));
}
static void
gtk_spin_button_finalize (GObject *object)
{
g_return_if_fail (GTK_IS_SPIN_BUTTON (object));
gtk_object_unref (GTK_OBJECT (GTK_SPIN_BUTTON (object)->adjustment));
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gtk_spin_button_map (GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
{
GTK_WIDGET_CLASS (parent_class)->map (widget);
gdk_window_show (GTK_SPIN_BUTTON (widget)->panel);
}
}
static void
gtk_spin_button_unmap (GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
if (GTK_WIDGET_MAPPED (widget))
{
gdk_window_hide (GTK_SPIN_BUTTON (widget)->panel);
GTK_WIDGET_CLASS (parent_class)->unmap (widget);
}
}
static void
gtk_spin_button_realize (GtkWidget *widget)
{
GtkSpinButton *spin_button;
GdkWindowAttr attributes;
gint attributes_mask;
guint real_width;
gint return_val;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
spin_button = GTK_SPIN_BUTTON (widget);
real_width = widget->allocation.width;
widget->allocation.width -= ARROW_SIZE + 2 * widget->style->xthickness;
gtk_widget_set_events (widget, gtk_widget_get_events (widget) |
GDK_KEY_RELEASE_MASK);
GTK_WIDGET_CLASS (parent_class)->realize (widget);
widget->allocation.width = real_width;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
attributes.x = (widget->allocation.x + widget->allocation.width - ARROW_SIZE -
2 * widget->style->xthickness);
attributes.y = widget->allocation.y + (widget->allocation.height -
widget->requisition.height) / 2;
attributes.width = ARROW_SIZE + 2 * widget->style->xthickness;
attributes.height = widget->requisition.height;
spin_button->panel = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (spin_button->panel, widget);
gtk_style_set_background (widget->style, spin_button->panel, GTK_STATE_NORMAL);
return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (spin_button), spinbutton_signals[OUTPUT],
&return_val);
if (return_val == FALSE)
gtk_spin_button_default_output (spin_button);
}
static void
gtk_spin_button_unrealize (GtkWidget *widget)
{
GtkSpinButton *spin;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
spin = GTK_SPIN_BUTTON (widget);
GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
if (spin->panel)
{
gdk_window_set_user_data (spin->panel, NULL);
gdk_window_destroy (spin->panel);
spin->panel = NULL;
}
}
static void
gtk_spin_button_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (requisition != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
requisition->width = MIN_SPIN_BUTTON_WIDTH + ARROW_SIZE
+ 2 * widget->style->xthickness;
}
static void
gtk_spin_button_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkAllocation child_allocation;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
g_return_if_fail (allocation != NULL);
child_allocation = *allocation;
if (child_allocation.width > ARROW_SIZE + 2 * widget->style->xthickness)
child_allocation.width -= ARROW_SIZE + 2 * widget->style->xthickness;
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
child_allocation.x += ARROW_SIZE + 2 * widget->style->xthickness;
GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, &child_allocation);
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
{
child_allocation.width = ARROW_SIZE + 2 * widget->style->xthickness;
child_allocation.height = widget->requisition.height;
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
child_allocation.x = (allocation->x + allocation->width - ARROW_SIZE -
2 * widget->style->xthickness);
else
child_allocation.x = allocation->x;
child_allocation.y = allocation->y + (allocation->height - widget->requisition.height) / 2;
gdk_window_move_resize (GTK_SPIN_BUTTON (widget)->panel,
child_allocation.x,
child_allocation.y,
child_allocation.width,
child_allocation.height);
}
}
static void
gtk_spin_button_paint (GtkWidget *widget,
GdkRectangle *area)
{
GtkSpinButton *spin;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
spin = GTK_SPIN_BUTTON (widget);
if (GTK_WIDGET_DRAWABLE (widget))
{
if (spin->shadow_type != GTK_SHADOW_NONE)
gtk_paint_box (widget->style, spin->panel,
GTK_STATE_NORMAL, spin->shadow_type,
area, widget, "spinbutton",
0, 0,
ARROW_SIZE + 2 * widget->style->xthickness,
widget->requisition.height);
else
{
gdk_window_set_back_pixmap (spin->panel, NULL, TRUE);
gdk_window_clear_area (spin->panel, area->x, area->y, area->width, area->height);
}
gtk_spin_button_draw_arrow (spin, GTK_ARROW_UP);
gtk_spin_button_draw_arrow (spin, GTK_ARROW_DOWN);
GTK_WIDGET_CLASS (parent_class)->draw (widget, area);
}
}
static void
gtk_spin_button_draw (GtkWidget *widget,
GdkRectangle *area)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
g_return_if_fail (area != NULL);
if (GTK_WIDGET_DRAWABLE (widget))
gtk_spin_button_paint (widget, area);
}
static gint
gtk_spin_button_expose (GtkWidget *widget,
GdkEventExpose *event)
{
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (GTK_WIDGET_DRAWABLE (widget))
gtk_spin_button_paint (widget, &event->area);
return FALSE;
}
static void
gtk_spin_button_draw_arrow (GtkSpinButton *spin_button,
guint arrow)
{
GtkStateType state_type;
GtkShadowType shadow_type;
GtkWidget *widget;
gint x;
gint y;
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
widget = GTK_WIDGET (spin_button);
if (GTK_WIDGET_DRAWABLE (spin_button))
{
if (!spin_button->wrap &&
(((arrow == GTK_ARROW_UP &&
(spin_button->adjustment->upper - spin_button->adjustment->value
<= EPSILON))) ||
((arrow == GTK_ARROW_DOWN &&
(spin_button->adjustment->value - spin_button->adjustment->lower
<= EPSILON)))))
{
shadow_type = GTK_SHADOW_ETCHED_IN;
state_type = GTK_STATE_NORMAL;
}
else
{
if (spin_button->in_child == arrow)
{
if (spin_button->click_child == arrow)
state_type = GTK_STATE_ACTIVE;
else
state_type = GTK_STATE_PRELIGHT;
}
else
state_type = GTK_STATE_NORMAL;
if (spin_button->click_child == arrow)
shadow_type = GTK_SHADOW_IN;
else
shadow_type = GTK_SHADOW_OUT;
}
if (arrow == GTK_ARROW_UP)
{
if (spin_button->shadow_type != GTK_SHADOW_NONE)
{
x = widget->style->xthickness;
y = widget->style->ythickness;
}
else
{
x = widget->style->xthickness - 1;
y = widget->style->ythickness - 1;
}
gtk_paint_arrow (widget->style, spin_button->panel,
state_type, shadow_type,
NULL, widget, "spinbutton",
arrow, TRUE,
x, y, ARROW_SIZE, widget->requisition.height / 2
- widget->style->ythickness);
}
else
{
if (spin_button->shadow_type != GTK_SHADOW_NONE)
{
x = widget->style->xthickness;
y = widget->requisition.height / 2;
}
else
{
x = widget->style->xthickness - 1;
y = widget->requisition.height / 2 + 1;
}
gtk_paint_arrow (widget->style, spin_button->panel,
state_type, shadow_type,
NULL, widget, "spinbutton",
arrow, TRUE,
x, y, ARROW_SIZE, widget->requisition.height / 2
- widget->style->ythickness);
}
}
}
static gint
gtk_spin_button_enter_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
if (event->window == spin->panel)
{
gint x;
gint y;
gdk_window_get_pointer (spin->panel, &x, &y, NULL);
if (y <= widget->requisition.height / 2)
{
spin->in_child = GTK_ARROW_UP;
if (spin->click_child == 2)
gtk_spin_button_draw_arrow (spin, GTK_ARROW_UP);
}
else
{
spin->in_child = GTK_ARROW_DOWN;
if (spin->click_child == 2)
gtk_spin_button_draw_arrow (spin, GTK_ARROW_DOWN);
}
}
return FALSE;
}
static gint
gtk_spin_button_leave_notify (GtkWidget *widget,
GdkEventCrossing *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
if (event->window == spin->panel && spin->click_child == 2)
{
if (spin->in_child == GTK_ARROW_UP)
{
spin->in_child = 2;
gtk_spin_button_draw_arrow (spin, GTK_ARROW_UP);
}
else
{
spin->in_child = 2;
gtk_spin_button_draw_arrow (spin, GTK_ARROW_DOWN);
}
}
return FALSE;
}
static gint
gtk_spin_button_focus_out (GtkWidget *widget,
GdkEventFocus *event)
{
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (GTK_EDITABLE (widget)->editable)
gtk_spin_button_update (GTK_SPIN_BUTTON (widget));
return GTK_WIDGET_CLASS (parent_class)->focus_out_event (widget, event);
}
static gint
gtk_spin_button_scroll (GtkWidget *widget,
GdkEventScroll *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
if (event->direction == GDK_SCROLL_UP)
{
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_spin_button_real_spin (spin, spin->adjustment->step_increment);
}
else if (event->direction == GDK_SCROLL_DOWN)
{
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_spin_button_real_spin (spin, -spin->adjustment->step_increment);
}
else
return FALSE;
return TRUE;
}
static gint
gtk_spin_button_button_press (GtkWidget *widget,
GdkEventButton *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
if (!spin->button)
{
if (event->window == spin->panel)
{
if (!GTK_WIDGET_HAS_FOCUS (widget))
gtk_widget_grab_focus (widget);
gtk_grab_add (widget);
spin->button = event->button;
if (GTK_EDITABLE (widget)->editable)
gtk_spin_button_update (spin);
if (event->y <= widget->requisition.height / 2)
{
spin->click_child = GTK_ARROW_UP;
if (event->button == 1)
{
gtk_spin_button_real_spin (spin,
spin->adjustment->step_increment);
if (!spin->timer)
{
spin->timer_step = spin->adjustment->step_increment;
spin->need_timer = TRUE;
spin->timer = gtk_timeout_add
(SPIN_BUTTON_INITIAL_TIMER_DELAY,
(GtkFunction) gtk_spin_button_timer, (gpointer) spin);
}
}
else if (event->button == 2)
{
gtk_spin_button_real_spin (spin,
spin->adjustment->page_increment);
if (!spin->timer)
{
spin->timer_step = spin->adjustment->page_increment;
spin->need_timer = TRUE;
spin->timer = gtk_timeout_add
(SPIN_BUTTON_INITIAL_TIMER_DELAY,
(GtkFunction) gtk_spin_button_timer, (gpointer) spin);
}
}
gtk_spin_button_draw_arrow (spin, GTK_ARROW_UP);
}
else
{
spin->click_child = GTK_ARROW_DOWN;
if (event->button == 1)
{
gtk_spin_button_real_spin (spin,
-spin->adjustment->step_increment);
if (!spin->timer)
{
spin->timer_step = spin->adjustment->step_increment;
spin->need_timer = TRUE;
spin->timer = gtk_timeout_add
(SPIN_BUTTON_INITIAL_TIMER_DELAY,
(GtkFunction) gtk_spin_button_timer, (gpointer) spin);
}
}
else if (event->button == 2)
{
gtk_spin_button_real_spin (spin,
-spin->adjustment->page_increment);
if (!spin->timer)
{
spin->timer_step = spin->adjustment->page_increment;
spin->need_timer = TRUE;
spin->timer = gtk_timeout_add
(SPIN_BUTTON_INITIAL_TIMER_DELAY,
(GtkFunction) gtk_spin_button_timer, (gpointer) spin);
}
}
gtk_spin_button_draw_arrow (spin, GTK_ARROW_DOWN);
}
}
else
GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
}
return FALSE;
}
static gint
gtk_spin_button_button_release (GtkWidget *widget,
GdkEventButton *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
if (event->button == spin->button)
{
guint click_child;
if (spin->timer)
{
gtk_timeout_remove (spin->timer);
spin->timer = 0;
spin->timer_calls = 0;
spin->need_timer = FALSE;
}
if (event->button == 3)
{
if (event->y >= 0 && event->x >= 0 &&
event->y <= widget->requisition.height &&
event->x <= ARROW_SIZE + 2 * widget->style->xthickness)
{
if (spin->click_child == GTK_ARROW_UP &&
event->y <= widget->requisition.height / 2)
{
gfloat diff;
diff = spin->adjustment->upper - spin->adjustment->value;
if (diff > EPSILON)
gtk_spin_button_real_spin (spin, diff);
}
else if (spin->click_child == GTK_ARROW_DOWN &&
event->y > widget->requisition.height / 2)
{
gfloat diff;
diff = spin->adjustment->value - spin->adjustment->lower;
if (diff > EPSILON)
gtk_spin_button_real_spin (spin, -diff);
}
}
}
gtk_grab_remove (widget);
click_child = spin->click_child;
spin->click_child = 2;
spin->button = 0;
gtk_spin_button_draw_arrow (spin, click_child);
}
else
GTK_WIDGET_CLASS (parent_class)->button_release_event (widget, event);
return FALSE;
}
static gint
gtk_spin_button_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
if (spin->button)
return FALSE;
if (event->window == spin->panel)
{
gint y;
y = event->y;
if (event->is_hint)
gdk_window_get_pointer (spin->panel, NULL, &y, NULL);
if (y <= widget->requisition.height / 2 &&
spin->in_child == GTK_ARROW_DOWN)
{
spin->in_child = GTK_ARROW_UP;
gtk_spin_button_draw_arrow (spin, GTK_ARROW_UP);
gtk_spin_button_draw_arrow (spin, GTK_ARROW_DOWN);
}
else if (y > widget->requisition.height / 2 &&
spin->in_child == GTK_ARROW_UP)
{
spin->in_child = GTK_ARROW_DOWN;
gtk_spin_button_draw_arrow (spin, GTK_ARROW_UP);
gtk_spin_button_draw_arrow (spin, GTK_ARROW_DOWN);
}
return FALSE;
}
return GTK_WIDGET_CLASS (parent_class)->motion_notify_event (widget, event);
}
static gint
gtk_spin_button_timer (GtkSpinButton *spin_button)
{
gboolean retval = FALSE;
GDK_THREADS_ENTER ();
if (spin_button->timer)
{
if (spin_button->click_child == GTK_ARROW_UP)
gtk_spin_button_real_spin (spin_button, spin_button->timer_step);
else
gtk_spin_button_real_spin (spin_button, -spin_button->timer_step);
if (spin_button->need_timer)
{
spin_button->need_timer = FALSE;
spin_button->timer = gtk_timeout_add
(SPIN_BUTTON_TIMER_DELAY, (GtkFunction) gtk_spin_button_timer,
(gpointer) spin_button);
}
else
{
if (spin_button->climb_rate > 0.0 && spin_button->timer_step
< spin_button->adjustment->page_increment)
{
if (spin_button->timer_calls < MAX_TIMER_CALLS)
spin_button->timer_calls++;
else
{
spin_button->timer_calls = 0;
spin_button->timer_step += spin_button->climb_rate;
}
}
retval = TRUE;
}
}
GDK_THREADS_LEAVE ();
return retval;
}
static void
gtk_spin_button_value_changed (GtkAdjustment *adjustment,
GtkSpinButton *spin_button)
{
gint return_val;
g_return_if_fail (adjustment != NULL);
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (spin_button), spinbutton_signals[OUTPUT],
&return_val);
if (return_val == FALSE)
gtk_spin_button_default_output (spin_button);
}
static gint
gtk_spin_button_key_press (GtkWidget *widget,
GdkEventKey *event)
{
GtkSpinButton *spin;
gint key;
gboolean key_repeat = FALSE;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
spin = GTK_SPIN_BUTTON (widget);
key = event->keyval;
key_repeat = (event->time == spin->ev_time);
if (GTK_EDITABLE (widget)->editable &&
(key == GDK_Up || key == GDK_Down ||
key == GDK_Page_Up || key == GDK_Page_Down))
gtk_spin_button_update (spin);
switch (key)
{
case GDK_Up:
if (GTK_WIDGET_HAS_FOCUS (widget))
{
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget),
"key_press_event");
if (!key_repeat)
spin->timer_step = spin->adjustment->step_increment;
gtk_spin_button_real_spin (spin, spin->timer_step);
if (key_repeat)
{
if (spin->climb_rate > 0.0 && spin->timer_step
< spin->adjustment->page_increment)
{
if (spin->timer_calls < MAX_TIMER_CALLS)
spin->timer_calls++;
else
{
spin->timer_calls = 0;
spin->timer_step += spin->climb_rate;
}
}
}
return TRUE;
}
return FALSE;
case GDK_Down:
if (GTK_WIDGET_HAS_FOCUS (widget))
{
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget),
"key_press_event");
if (!key_repeat)
spin->timer_step = spin->adjustment->step_increment;
gtk_spin_button_real_spin (spin, -spin->timer_step);
if (key_repeat)
{
if (spin->climb_rate > 0.0 && spin->timer_step
< spin->adjustment->page_increment)
{
if (spin->timer_calls < MAX_TIMER_CALLS)
spin->timer_calls++;
else
{
spin->timer_calls = 0;
spin->timer_step += spin->climb_rate;
}
}
}
return TRUE;
}
return FALSE;
case GDK_Page_Up:
if (event->state & GDK_CONTROL_MASK)
{
gfloat diff = spin->adjustment->upper - spin->adjustment->value;
if (diff > EPSILON)
gtk_spin_button_real_spin (spin, diff);
}
else
gtk_spin_button_real_spin (spin, spin->adjustment->page_increment);
return TRUE;
case GDK_Page_Down:
if (event->state & GDK_CONTROL_MASK)
{
gfloat diff = spin->adjustment->value - spin->adjustment->lower;
if (diff > EPSILON)
gtk_spin_button_real_spin (spin, -diff);
}
else
gtk_spin_button_real_spin (spin, -spin->adjustment->page_increment);
return TRUE;
default:
break;
}
return GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
}
static gint
gtk_spin_button_key_release (GtkWidget *widget,
GdkEventKey *event)
{
GtkSpinButton *spin;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (widget), FALSE);
spin = GTK_SPIN_BUTTON (widget);
spin->ev_time = event->time;
return TRUE;
}
static void
gtk_spin_button_snap (GtkSpinButton *spin_button,
gfloat val)
{
gfloat inc;
gfloat tmp;
inc = spin_button->adjustment->step_increment;
tmp = (val - spin_button->adjustment->lower) / inc;
if (tmp - floor (tmp) < ceil (tmp) - tmp)
val = spin_button->adjustment->lower + floor (tmp) * inc;
else
val = spin_button->adjustment->lower + ceil (tmp) * inc;
if (fabs (val - spin_button->adjustment->value) > EPSILON)
gtk_adjustment_set_value (spin_button->adjustment, val);
else
{
gint return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (spin_button), spinbutton_signals[OUTPUT],
&return_val);
if (return_val == FALSE)
gtk_spin_button_default_output (spin_button);
}
}
static void
gtk_spin_button_activate (GtkEditable *editable)
{
g_return_if_fail (editable != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (editable));
if (editable->editable)
gtk_spin_button_update (GTK_SPIN_BUTTON (editable));
}
static void
gtk_spin_button_insert_text (GtkEditable *editable,
const gchar *new_text,
gint new_text_length,
gint *position)
{
GtkEntry *entry;
GtkSpinButton *spin;
g_return_if_fail (editable != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (editable));
entry = GTK_ENTRY (editable);
spin = GTK_SPIN_BUTTON (editable);
if (spin->numeric)
{
struct lconv *lc;
gboolean sign;
gint dotpos = -1;
gint i;
GdkWChar pos_sign;
GdkWChar neg_sign;
guint entry_length;
entry_length = entry->text_length;
lc = localeconv ();
if (*(lc->negative_sign))
neg_sign = *(lc->negative_sign);
else
neg_sign = '-';
if (*(lc->positive_sign))
pos_sign = *(lc->positive_sign);
else
pos_sign = '+';
for (sign=0, i=0; i<entry_length; i++)
if ((entry->text[i] == neg_sign) ||
(entry->text[i] == pos_sign))
{
sign = 1;
break;
}
if (sign && !(*position))
return;
for (dotpos=-1, i=0; i<entry_length; i++)
if (entry->text[i] == *(lc->decimal_point))
{
dotpos = i;
break;
}
if (dotpos > -1 && *position > dotpos &&
spin->digits - entry_length
+ dotpos - new_text_length + 1 < 0)
return;
for (i = 0; i < new_text_length; i++)
{
if (new_text[i] == neg_sign || new_text[i] == pos_sign)
{
if (sign || (*position) || i)
return;
sign = TRUE;
}
else if (new_text[i] == *(lc->decimal_point))
{
if (!spin->digits || dotpos > -1 ||
(new_text_length - 1 - i + entry_length
- *position > spin->digits))
return;
dotpos = *position + i;
}
else if (new_text[i] < 0x30 || new_text[i] > 0x39)
return;
}
}
GTK_EDITABLE_CLASS (parent_class)->insert_text (editable, new_text,
new_text_length, position);
}
static void
gtk_spin_button_real_spin (GtkSpinButton *spin_button,
gfloat increment)
{
GtkAdjustment *adj;
gfloat new_value = 0.0;
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
adj = spin_button->adjustment;
new_value = adj->value + increment;
if (increment > 0)
{
if (spin_button->wrap)
{
if (fabs (adj->value - adj->upper) < EPSILON)
new_value = adj->lower;
else if (new_value > adj->upper)
new_value = adj->upper;
}
else
new_value = MIN (new_value, adj->upper);
}
else if (increment < 0)
{
if (spin_button->wrap)
{
if (fabs (adj->value - adj->lower) < EPSILON)
new_value = adj->upper;
else if (new_value < adj->lower)
new_value = adj->lower;
}
else
new_value = MAX (new_value, adj->lower);
}
if (fabs (new_value - adj->value) > EPSILON)
gtk_adjustment_set_value (adj, new_value);
}
static gint
gtk_spin_button_default_input (GtkSpinButton *spin_button,
gfloat *new_val)
{
gchar *err = NULL;
*new_val = strtod (gtk_entry_get_text (GTK_ENTRY (spin_button)), &err);
if (*err)
return INPUT_ERROR;
else
return FALSE;
}
static gint
gtk_spin_button_default_output (GtkSpinButton *spin_button)
{
gchar buf[MAX_TEXT_LENGTH];
sprintf (buf, "%0.*f", spin_button->digits, spin_button->adjustment->value);
if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
return FALSE;
}
/***********************************************************
***********************************************************
*** Public interface ***
***********************************************************
***********************************************************/
void
gtk_spin_button_configure (GtkSpinButton *spin_button,
GtkAdjustment *adjustment,
gfloat climb_rate,
guint digits)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
g_return_if_fail (digits < 6);
if (adjustment)
gtk_spin_button_set_adjustment (spin_button, adjustment);
else
adjustment = spin_button->adjustment;
spin_button->digits = digits;
spin_button->climb_rate = climb_rate;
gtk_adjustment_value_changed (adjustment);
}
GtkWidget *
gtk_spin_button_new (GtkAdjustment *adjustment,
gfloat climb_rate,
guint digits)
{
GtkSpinButton *spin;
if (adjustment)
g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), NULL);
g_return_val_if_fail (digits < 6, NULL);
spin = gtk_type_new (GTK_TYPE_SPIN_BUTTON);
gtk_spin_button_configure (spin, adjustment, climb_rate, digits);
return GTK_WIDGET (spin);
}
void
gtk_spin_button_set_adjustment (GtkSpinButton *spin_button,
GtkAdjustment *adjustment)
{
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
if (spin_button->adjustment != adjustment)
{
if (spin_button->adjustment)
{
gtk_signal_disconnect_by_data (GTK_OBJECT (spin_button->adjustment),
(gpointer) spin_button);
gtk_object_unref (GTK_OBJECT (spin_button->adjustment));
}
spin_button->adjustment = adjustment;
if (adjustment)
{
gtk_object_ref (GTK_OBJECT (adjustment));
gtk_object_sink (GTK_OBJECT (adjustment));
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
(GtkSignalFunc) gtk_spin_button_value_changed,
(gpointer) spin_button);
}
}
}
GtkAdjustment *
gtk_spin_button_get_adjustment (GtkSpinButton *spin_button)
{
g_return_val_if_fail (spin_button != NULL, NULL);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), NULL);
return spin_button->adjustment;
}
void
gtk_spin_button_set_digits (GtkSpinButton *spin_button,
guint digits)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
g_return_if_fail (digits < 6);
if (spin_button->digits != digits)
{
spin_button->digits = digits;
gtk_spin_button_value_changed (spin_button->adjustment, spin_button);
}
}
gfloat
gtk_spin_button_get_value_as_float (GtkSpinButton *spin_button)
{
g_return_val_if_fail (spin_button != NULL, 0.0);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), 0.0);
return spin_button->adjustment->value;
}
gint
gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button)
{
gfloat val;
g_return_val_if_fail (spin_button != NULL, 0);
g_return_val_if_fail (GTK_IS_SPIN_BUTTON (spin_button), 0);
val = spin_button->adjustment->value;
if (val - floor (val) < ceil (val) - val)
return floor (val);
else
return ceil (val);
}
void
gtk_spin_button_set_value (GtkSpinButton *spin_button,
gfloat value)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
if (fabs (value - spin_button->adjustment->value) > EPSILON)
gtk_adjustment_set_value (spin_button->adjustment, value);
else
{
gint return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (spin_button), spinbutton_signals[OUTPUT],
&return_val);
if (return_val == FALSE)
gtk_spin_button_default_output (spin_button);
}
}
void
gtk_spin_button_set_update_policy (GtkSpinButton *spin_button,
GtkSpinButtonUpdatePolicy policy)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
spin_button->update_policy = policy;
}
void
gtk_spin_button_set_numeric (GtkSpinButton *spin_button,
gboolean numeric)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
spin_button->numeric = (numeric != 0);
}
void
gtk_spin_button_set_wrap (GtkSpinButton *spin_button,
gboolean wrap)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
spin_button->wrap = (wrap != 0);
}
void
gtk_spin_button_set_shadow_type (GtkSpinButton *spin_button,
GtkShadowType shadow_type)
{
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
if (shadow_type != spin_button->shadow_type)
{
spin_button->shadow_type = shadow_type;
if (GTK_WIDGET_DRAWABLE (spin_button))
gtk_widget_queue_draw (GTK_WIDGET (spin_button));
}
}
void
gtk_spin_button_set_snap_to_ticks (GtkSpinButton *spin_button,
gboolean snap_to_ticks)
{
guint new_val;
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
new_val = (snap_to_ticks != 0);
if (new_val != spin_button->snap_to_ticks)
{
spin_button->snap_to_ticks = new_val;
if (new_val && GTK_EDITABLE (spin_button)->editable)
gtk_spin_button_update (spin_button);
}
}
void
gtk_spin_button_spin (GtkSpinButton *spin_button,
GtkSpinType direction,
gfloat increment)
{
GtkAdjustment *adj;
gfloat diff;
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
adj = spin_button->adjustment;
/* for compatibility with the 1.0.x version of this function */
if (increment != 0 && increment != adj->step_increment &&
(direction == GTK_SPIN_STEP_FORWARD ||
direction == GTK_SPIN_STEP_BACKWARD))
{
if (direction == GTK_SPIN_STEP_BACKWARD && increment > 0)
increment = -increment;
direction = GTK_SPIN_USER_DEFINED;
}
switch (direction)
{
case GTK_SPIN_STEP_FORWARD:
gtk_spin_button_real_spin (spin_button, adj->step_increment);
break;
case GTK_SPIN_STEP_BACKWARD:
gtk_spin_button_real_spin (spin_button, -adj->step_increment);
break;
case GTK_SPIN_PAGE_FORWARD:
gtk_spin_button_real_spin (spin_button, adj->page_increment);
break;
case GTK_SPIN_PAGE_BACKWARD:
gtk_spin_button_real_spin (spin_button, -adj->page_increment);
break;
case GTK_SPIN_HOME:
diff = adj->value - adj->lower;
if (diff > EPSILON)
gtk_spin_button_real_spin (spin_button, -diff);
break;
case GTK_SPIN_END:
diff = adj->upper - adj->value;
if (diff > EPSILON)
gtk_spin_button_real_spin (spin_button, diff);
break;
case GTK_SPIN_USER_DEFINED:
if (increment != 0)
gtk_spin_button_real_spin (spin_button, increment);
break;
default:
break;
}
}
void
gtk_spin_button_update (GtkSpinButton *spin_button)
{
gfloat val;
gint error = 0;
gint return_val;
g_return_if_fail (spin_button != NULL);
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (spin_button), spinbutton_signals[INPUT],
&val, &return_val);
if (return_val == FALSE)
{
return_val = gtk_spin_button_default_input (spin_button, &val);
error = (return_val == INPUT_ERROR);
}
else if (return_val == INPUT_ERROR)
error = 1;
if (spin_button->update_policy == GTK_UPDATE_ALWAYS)
{
if (val < spin_button->adjustment->lower)
val = spin_button->adjustment->lower;
else if (val > spin_button->adjustment->upper)
val = spin_button->adjustment->upper;
}
else if ((spin_button->update_policy == GTK_UPDATE_IF_VALID) &&
(error ||
val < spin_button->adjustment->lower ||
val > spin_button->adjustment->upper))
{
gtk_spin_button_value_changed (spin_button->adjustment, spin_button);
return;
}
if (spin_button->snap_to_ticks)
gtk_spin_button_snap (spin_button, val);
else
{
if (fabs (val - spin_button->adjustment->value) > EPSILON)
gtk_adjustment_set_value (spin_button->adjustment, val);
else
{
return_val = FALSE;
gtk_signal_emit (GTK_OBJECT (spin_button), spinbutton_signals[OUTPUT],
&return_val);
if (return_val == FALSE)
gtk_spin_button_default_output (spin_button);
}
}
}
Reference in New Issue View Git Blame Copy Permalink