示例程序代码GtkDial@GTK+ 2.0 中文教程连载

GtkDial

gtkdial.h

/* GTK - GIMP工具包
* 版权 (C) 1995-1997 Peter Mattis, Spencer Kimball 和 Josh MacDonald 所有
*
* 本程序是自由软件。你可以在自由软件基金发布的 GNU GPL 的条款下重新分发
* 或修改它。GPL 可以使用版本 2 或(由你选择)任何随后的版本。
*
* 本程序分发的目的是它可能对其他人有用,但不提供任何的担保,包括隐含的
* 和适合特定用途的保证。请查阅GNU通用公共许可证获得详细的信息。
*
* 你应该已经随该软件一起收到一份GNU通用公共许可。如果还没有,请写信给
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/

#ifndef __GTK_DIAL_H__
#define __GTK_DIAL_H__


#include <gdk/gdk.h>
#include <gtk/gtkadjustment.h>
#include <gtk/gtkwidget.h>


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


#define GTK_DIAL(obj) GTK_CHECK_CAST (obj, gtk_dial_get_type (), GtkDial)
#define GTK_DIAL_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_dial_get_type (), GtkDialClass)
#define GTK_IS_DIAL(obj) GTK_CHECK_TYPE (obj, gtk_dial_get_type ())


typedef struct _GtkDial GtkDial;
typedef struct _GtkDialClass GtkDialClass;

struct _GtkDial
{
GtkWidget widget;

/* 更新方式 (GTK_UPDATE_[CONTINUOUS/DELAYED/DISCONTINUOUS]) */
guint policy : 2;

/* 当前按下的按钮,如果没有该值是 0 */
guint8 button;

/* 表盘指针的大小 */
gint radius;
gint pointer_width;

/* 更新计时器的ID , 如果没有该值是 0 */
guint32 timer;

/* 当前角度 */
gfloat angle;
gfloat last_angle;

/* 将从调整对象中得到的旧值保存起来,这样在改变时我们就会知道 */
gfloat old_value;
gfloat old_lower;
gfloat old_upper;

/* 为这个表盘构件存储数据的调整对象 */
GtkAdjustment *adjustment;
};

struct _GtkDialClass
{
GtkWidgetClass parent_class;
};


GtkWidget* gtk_dial_new (GtkAdjustment *adjustment);
GtkType gtk_dial_get_type (void);
GtkAdjustment* gtk_dial_get_adjustment (GtkDial *dial);
void gtk_dial_set_update_policy (GtkDial *dial,
GtkUpdateType policy);

void gtk_dial_set_adjustment (GtkDial *dial,
GtkAdjustment *adjustment);
#ifdef __cplusplus
}
#endif /* __cplusplus */


#endif /* __GTK_DIAL_H__ */

gtkdial.c

/* GTK - GIMP工具包
* 版权 (C) 1995-1997 Peter Mattis, Spencer Kimball 和 Josh MacDonald 所有
*
* 本程序是自由软件。你可以在自由软件基金发布的 GNU GPL 的条款下重新分发
* 或修改它。GPL 可以使用版本 2 或(由你选择)任何随后的版本。
*
* 本程序分发的目的是它可能对其他人有用,但不提供任何的担保,包括隐含的
* 和适合特定用途的保证。请查阅GNU通用公共许可证获得详细的信息。
*
* 你应该已经随该软件一起收到一份GNU通用公共许可。如果还没有,请写信给
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/

#include <math.h>
#include <stdio.h>
#include <gtk/gtkmain.h>
#include <gtk/gtksignal.h>

#include "gtkdial.h"

#define SCROLL_DELAY_LENGTH 300
#define DIAL_DEFAULT_SIZE 100

/* 声明 */

static void gtk_dial_class_init (GtkDialClass *klass);
static void gtk_dial_init (GtkDial *dial);
static void gtk_dial_destroy (GtkObject *object);
static void gtk_dial_realize (GtkWidget *widget);
static void gtk_dial_size_request (GtkWidget *widget,
GtkRequisition *requisition);
static void gtk_dial_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static gint gtk_dial_expose (GtkWidget *widget,
GdkEventExpose *event);
static gint gtk_dial_button_press (GtkWidget *widget,
GdkEventButton *event);
static gint gtk_dial_button_release (GtkWidget *widget,
GdkEventButton *event);
static gint gtk_dial_motion_notify (GtkWidget *widget,
GdkEventMotion *event);
static gint gtk_dial_timer (GtkDial *dial);

static void gtk_dial_update_mouse (GtkDial *dial, gint x, gint y);
static void gtk_dial_update (GtkDial *dial);
static void gtk_dial_adjustment_changed (GtkAdjustment *adjustment,
gpointer data);
static void gtk_dial_adjustment_value_changed (GtkAdjustment *adjustment,
gpointer data);

/* 局部数据 */

static GtkWidgetClass *parent_class = NULL;

GType
gtk_dial_get_type ()
{
static GType dial_type = 0;

if (!dial_type)
{
static const GTypeInfo dial_info =
{
sizeof (GtkDialClass),
NULL,
NULL,
(GClassInitFunc) gtk_dial_class_init,
NULL,
NULL,
sizeof (GtkDial),
0,
(GInstanceInitFunc) gtk_dial_init,
};

dial_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkDial", &dial_info, 0);
}

return dial_type;
}

static void
gtk_dial_class_init (GtkDialClass *class)
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;

object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;

parent_class = gtk_type_class (gtk_widget_get_type ());

object_class->destroy = gtk_dial_destroy;

widget_class->realize = gtk_dial_realize;
widget_class->expose_event = gtk_dial_expose;
widget_class->size_request = gtk_dial_size_request;
widget_class->size_allocate = gtk_dial_size_allocate;
widget_class->button_press_event = gtk_dial_button_press;
widget_class->button_release_event = gtk_dial_button_release;
widget_class->motion_notify_event = gtk_dial_motion_notify;
}

static void
gtk_dial_init (GtkDial *dial)
{
dial->button = 0;
dial->policy = GTK_UPDATE_CONTINUOUS;
dial->timer = 0;
dial->radius = 0;
dial->pointer_width = 0;
dial->angle = 0.0;
dial->old_value = 0.0;
dial->old_lower = 0.0;
dial->old_upper = 0.0;
dial->adjustment = NULL;
}

GtkWidget*
gtk_dial_new (GtkAdjustment *adjustment)
{
GtkDial *dial;

dial = g_object_new (gtk_dial_get_type (), NULL);

if (!adjustment)
adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);

gtk_dial_set_adjustment (dial, adjustment);

return GTK_WIDGET (dial);
}

static void
gtk_dial_destroy (GtkObject *object)
{
GtkDial *dial;

g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_DIAL (object));

dial = GTK_DIAL (object);

if (dial->adjustment)
g_object_unref (GTK_OBJECT (dial->adjustment));

if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}

GtkAdjustment*
gtk_dial_get_adjustment (GtkDial *dial)
{
g_return_val_if_fail (dial != NULL, NULL);
g_return_val_if_fail (GTK_IS_DIAL (dial), NULL);

return dial->adjustment;
}

void
gtk_dial_set_update_policy (GtkDial *dial,
GtkUpdateType policy)
{
g_return_if_fail (dial != NULL);
g_return_if_fail (GTK_IS_DIAL (dial));

dial->policy = policy;
}

void
gtk_dial_set_adjustment (GtkDial *dial,
GtkAdjustment *adjustment)
{
g_return_if_fail (dial != NULL);
g_return_if_fail (GTK_IS_DIAL (dial));

if (dial->adjustment)
{
g_signal_handlers_disconnect_by_func (GTK_OBJECT (dial->adjustment), NULL, (gpointer) dial);
g_object_unref (GTK_OBJECT (dial->adjustment));
}

dial->adjustment = adjustment;
g_object_ref (GTK_OBJECT (dial->adjustment));

g_signal_connect (GTK_OBJECT (adjustment), "changed",
GTK_SIGNAL_FUNC (gtk_dial_adjustment_changed),
(gpointer) dial);
g_signal_connect (GTK_OBJECT (adjustment), "value_changed",
GTK_SIGNAL_FUNC (gtk_dial_adjustment_value_changed),
(gpointer) dial);

dial->old_value = adjustment->value;
dial->old_lower = adjustment->lower;
dial->old_upper = adjustment->upper;

gtk_dial_update (dial);
}

static void
gtk_dial_realize (GtkWidget *widget)
{
GtkDial *dial;
GdkWindowAttr attributes;
gint attributes_mask;

g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_DIAL (widget));

GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
dial = GTK_DIAL (widget);

attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.event_mask = gtk_widget_get_events (widget) |
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);

attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);

widget->style = gtk_style_attach (widget->style, widget->window);

gdk_window_set_user_data (widget->window, widget);

gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
}

static void
gtk_dial_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
requisition->width = DIAL_DEFAULT_SIZE;
requisition->height = DIAL_DEFAULT_SIZE;
}

static void
gtk_dial_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkDial *dial;

g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_DIAL (widget));
g_return_if_fail (allocation != NULL);

widget->allocation = *allocation;
dial = GTK_DIAL (widget);

if (GTK_WIDGET_REALIZED (widget))
{

gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);

}
dial->radius = MIN (allocation->width, allocation->height) * 0.45;
dial->pointer_width = dial->radius / 5;
}

static gint
gtk_dial_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkDial *dial;
GdkPoint points[6];
gdouble s,c;
gdouble theta, last, increment;
GtkStyle *blankstyle;
gint xc, yc;
gint upper, lower;
gint tick_length;
gint i, inc;

g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);

if (event->count > 0)
return FALSE;

dial = GTK_DIAL (widget);

/* gdk_window_clear_area (widget->window,
0, 0,
widget->allocation.width,
widget->allocation.height);
*/
xc = widget->allocation.width / 2;
yc = widget->allocation.height / 2;

upper = dial->adjustment->upper;
lower = dial->adjustment->lower;

/* Erase old pointer */

s = sin (dial->last_angle);
c = cos (dial->last_angle);
dial->last_angle = dial->angle;

points[0].x = xc + s*dial->pointer_width/2;
points[0].y = yc + c*dial->pointer_width/2;
points[1].x = xc + c*dial->radius;
points[1].y = yc - s*dial->radius;
points[2].x = xc - s*dial->pointer_width/2;
points[2].y = yc - c*dial->pointer_width/2;
points[3].x = xc - c*dial->radius/10;
points[3].y = yc + s*dial->radius/10;
points[4].x = points[0].x;
points[4].y = points[0].y;

blankstyle = gtk_style_new ();
blankstyle->bg_gc[GTK_STATE_NORMAL] =
widget->style->bg_gc[GTK_STATE_NORMAL];
blankstyle->dark_gc[GTK_STATE_NORMAL] =
widget->style->bg_gc[GTK_STATE_NORMAL];
blankstyle->light_gc[GTK_STATE_NORMAL] =
widget->style->bg_gc[GTK_STATE_NORMAL];
blankstyle->black_gc =
widget->style->bg_gc[GTK_STATE_NORMAL];

gtk_paint_polygon (blankstyle,
widget->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL,
widget,
NULL,
points, 5,
FALSE);

g_object_unref (blankstyle);


/* 绘制刻度 */

if ((upper - lower) == 0)
return FALSE;

increment = (100*M_PI) / (dial->radius*dial->radius);

inc = (upper - lower);

while (inc < 100) inc *= 10;
while (inc >= 1000) inc /= 10;
last = -1;

for (i = 0; i <= inc; i++)
{
theta = ((gfloat)i*M_PI / (18*inc/24.) - M_PI/6.);

if ((theta - last) < (increment))
continue;
last = theta;

s = sin (theta);
c = cos (theta);

tick_length = (i%(inc/10) == 0) ? dial->pointer_width : dial->pointer_width / 2;

gdk_draw_line (widget->window,
widget->style->fg_gc[widget->state],
xc + c*(dial->radius - tick_length),
yc - s*(dial->radius - tick_length),
xc + c*dial->radius,
yc - s*dial->radius);
}

/* 绘制指针 */

s = sin (dial->angle);
c = cos (dial->angle);
dial->last_angle = dial->angle;

points[0].x = xc + s*dial->pointer_width/2;
points[0].y = yc + c*dial->pointer_width/2;
points[1].x = xc + c*dial->radius;
points[1].y = yc - s*dial->radius;
points[2].x = xc - s*dial->pointer_width/2;
points[2].y = yc - c*dial->pointer_width/2;
points[3].x = xc - c*dial->radius/10;
points[3].y = yc + s*dial->radius/10;
points[4].x = points[0].x;
points[4].y = points[0].y;


gtk_paint_polygon (widget->style,
widget->window,
GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL,
widget,
NULL,
points, 5,
TRUE);

return FALSE;
}

static gint
gtk_dial_button_press (GtkWidget *widget,
GdkEventButton *event)
{
GtkDial *dial;
gint dx, dy;
double s, c;
double d_parallel;
double d_perpendicular;

g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);

dial = GTK_DIAL (widget);

/* 判断按钮是否是在表盘指针里按下 - 我们通过计算鼠标按下
点到表盘指针中线的水平和垂直距离来判断。 */

dx = event->x - widget->allocation.width / 2;
dy = widget->allocation.height / 2 - event->y;

s = sin (dial->angle);
c = cos (dial->angle);

d_parallel = s*dy + c*dx;
d_perpendicular = fabs (s*dx - c*dy);

if (!dial->button &&
(d_perpendicular < dial->pointer_width/2) &&
(d_parallel > - dial->pointer_width))
{
gtk_grab_add (widget);

dial->button = event->button;

gtk_dial_update_mouse (dial, event->x, event->y);
}

return FALSE;
}

static gint
gtk_dial_button_release (GtkWidget *widget,
GdkEventButton *event)
{
GtkDial *dial;

g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);

dial = GTK_DIAL (widget);

if (dial->button == event->button)
{
gtk_grab_remove (widget);

dial->button = 0;

if (dial->policy == GTK_UPDATE_DELAYED)
gtk_timeout_remove (dial->timer);

if ((dial->policy != GTK_UPDATE_CONTINUOUS) &&
(dial->old_value != dial->adjustment->value))
g_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
}

return FALSE;
}

static gint
gtk_dial_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
GtkDial *dial;
GdkModifierType mods;
gint x, y, mask;

g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);

dial = GTK_DIAL (widget);

if (dial->button != 0)
{
x = event->x;
y = event->y;

if (event->is_hint || (event->window != widget->window))
gdk_window_get_pointer (widget->window, &x, &y, &mods);

switch (dial->button)
{
case 1:
mask = GDK_BUTTON1_MASK;
break;
case 2:
mask = GDK_BUTTON2_MASK;
break;
case 3:
mask = GDK_BUTTON3_MASK;
break;
default:
mask = 0;
break;
}

if (mods & mask)
gtk_dial_update_mouse (dial, x,y);
}

return FALSE;
}

static gint
gtk_dial_timer (GtkDial *dial)
{
g_return_val_if_fail (dial != NULL, FALSE);
g_return_val_if_fail (GTK_IS_DIAL (dial), FALSE);

if (dial->policy == GTK_UPDATE_DELAYED)
g_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");

return FALSE;
}

static void
gtk_dial_update_mouse (GtkDial *dial, gint x, gint y)
{
gint xc, yc;
gfloat old_value;

g_return_if_fail (dial != NULL);
g_return_if_fail (GTK_IS_DIAL (dial));

xc = GTK_WIDGET(dial)->allocation.width / 2;
yc = GTK_WIDGET(dial)->allocation.height / 2;

old_value = dial->adjustment->value;
dial->angle = atan2(yc-y, x-xc);

if (dial->angle < -M_PI/2.)
dial->angle += 2*M_PI;

if (dial->angle < -M_PI/6)
dial->angle = -M_PI/6;

if (dial->angle > 7.*M_PI/6.)
dial->angle = 7.*M_PI/6.;

dial->adjustment->value = dial->adjustment->lower + (7.*M_PI/6 - dial->angle) *
(dial->adjustment->upper - dial->adjustment->lower) / (4.*M_PI/3.);

if (dial->adjustment->value != old_value)
{
if (dial->policy == GTK_UPDATE_CONTINUOUS)
{
g_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
}
else
{
gtk_widget_queue_draw (GTK_WIDGET (dial));

if (dial->policy == GTK_UPDATE_DELAYED)
{
if (dial->timer)
gtk_timeout_remove (dial->timer);

dial->timer = gtk_timeout_add (SCROLL_DELAY_LENGTH,
(GtkFunction) gtk_dial_timer,
(gpointer) dial);
}
}
}
}

static void
gtk_dial_update (GtkDial *dial)
{
gfloat new_value;

g_return_if_fail (dial != NULL);
g_return_if_fail (GTK_IS_DIAL (dial));

new_value = dial->adjustment->value;

if (new_value < dial->adjustment->lower)
new_value = dial->adjustment->lower;

if (new_value > dial->adjustment->upper)
new_value = dial->adjustment->upper;

if (new_value != dial->adjustment->value)
{
dial->adjustment->value = new_value;
g_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
}

dial->angle = 7.*M_PI/6. - (new_value - dial->adjustment->lower) * 4.*M_PI/3. /
(dial->adjustment->upper - dial->adjustment->lower);

gtk_widget_queue_draw (GTK_WIDGET (dial));
}

static void
gtk_dial_adjustment_changed (GtkAdjustment *adjustment,
gpointer data)
{
GtkDial *dial;

g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);

dial = GTK_DIAL (data);

if ((dial->old_value != adjustment->value) ||
(dial->old_lower != adjustment->lower) ||
(dial->old_upper != adjustment->upper))
{
gtk_dial_update (dial);

dial->old_value = adjustment->value;
dial->old_lower = adjustment->lower;
dial->old_upper = adjustment->upper;
}
}

static void
gtk_dial_adjustment_value_changed (GtkAdjustment *adjustment,
gpointer data)
{
GtkDial *dial;

g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);

dial = GTK_DIAL (data);

if (dial->old_value != adjustment->value)
{
gtk_dial_update (dial);

dial->old_value = adjustment->value;
}
}

dial_test.c

#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include "gtkdial.h"

void value_changed( GtkAdjustment *adjustment,
GtkWidget *label )
{
char buffer[16];

sprintf(buffer,"%4.2f",adjustment->value);
gtk_label_set_text (GTK_LABEL (label), buffer);
}

int main( int argc,
char *argv[])
{
GtkWidget *window;
GtkAdjustment *adjustment;
GtkWidget *dial;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *label;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_title (GTK_WINDOW (window), "Dial");

g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (exit), NULL);

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);

frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (vbox), frame);
gtk_widget_show (frame);

adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 0.01, 0.1, 0));

dial = gtk_dial_new (adjustment);
gtk_dial_set_update_policy (GTK_DIAL (dial), GTK_UPDATE_DELAYED);
/* gtk_widget_set_size_request (dial, 100, 100); */

gtk_container_add (GTK_CONTAINER (frame), dial);
gtk_widget_show (dial);

label = gtk_label_new ("0.00");
gtk_box_pack_end (GTK_BOX (vbox), label, 0, 0, 0);
gtk_widget_show (label);

g_signal_connect (G_OBJECT (adjustment), "value_changed",
G_CALLBACK (value_changed), label);

gtk_widget_show (window);

gtk_main ();

return 0;
}

<<< Previous Home Next >>>
示例程序代码Up Scribble
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值