原文： http://zetcode.com/gui/gtk2/customwidget/

在 GTK+ 编程教程的这一部分中，我们创建一个自定义的 GTK+ 小部件。 我们使用 Cario 图形库。

CPU 小部件

在下一个示例中，我们创建一个自定义 CPU 小部件。

mycpu.h

  1. #ifndef __MY_CPU_H__
  2. #define __MY_CPU_H__
  4. #include <gtk/gtk.h>
  5. #include <cairo.h>
  7. G_BEGIN_DECLS
  9. /* Standart GObject macros */
  10. #define MY_TYPE_CPU (my_cpu_get_type())
  11. #define MY_CPU(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), MY_TYPE_CPU, MyCpu))
  12. #define MY_CPU_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), MY_TYPE_CPU, MyCpuClass))
  13. #define MY_IS_CPU(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MY_TYPE_CPU))
  14. #define MY_IS_CPU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), MY_TYPE_CPU))
  15. #define MY_CPU_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), MY_TYPE_CPU, MyCpuClass))
  17. /* Type definition */
  18. typedef struct _MyCpu        MyCpu;
  19. typedef struct _MyCpuClass   MyCpuClass;
  20. typedef struct _MyCpuPrivate MyCpuPrivate;
  22. struct _MyCpu {
  24.    GtkWidget parent;
  26.    /*< Private >*/
  27.    MyCpuPrivate *priv;
  28. };
  30. struct _MyCpuClass {
  32.    GtkWidgetClass parent_class;
  33. };
  35. /* Public API */
  36. GType      my_cpu_get_type(void) G_GNUC_CONST;
  37. GtkWidget *my_cpu_new(void);
  39. gdouble my_cpu_get_percent(MyCpu *cpu);
  40. void    my_cpu_set_percent(MyCpu *cpu, gdouble sel);
  42. G_END_DECLS
  44. #endif /* __MY_CPU_H__ */

在mycpu.h文件中，我们定义了自定义窗口小部件的类型，宏和函数。

mycpu.c

  1. /* mycpu.c */
  3. #include "mycpu.h"
  5. /* Properties enum */
  6. enum {
  8.    P_0, /* Padding */
  9.    P_PERCENT
  10. };
  12. /* Private data structure */
  13. struct _MyCpuPrivate {
  15.    gdouble percent;
  16.    GdkWindow *window;
  17. };
  19. const gint WIDTH = 80;
  20. const gint HEIGHT = 100;
  22. /* Internal API */
  23. static void my_cpu_set_property(GObject *object, guint prop_id, 
  24.     const GValue *value, GParamSpec *pspec);
  25. static void my_cpu_get_property(GObject *object, guint prop_id,
  26.     GValue *value, GParamSpec *pspec);
  27. static void my_cpu_size_request(GtkWidget *widget, 
  28.     GtkRequisition *requisition);
  29. static void my_cpu_size_allocate(GtkWidget *widget, 
  30.     GtkAllocation *allocation);
  31. static void my_cpu_realize(GtkWidget *widget);
  32. static gboolean my_cpu_expose(GtkWidget *widget, 
  33.     GdkEventExpose *event);
  35. /* Define type */
  36. G_DEFINE_TYPE(MyCpu, my_cpu, GTK_TYPE_WIDGET)
  38. /* Initialization */
  39. static void my_cpu_class_init(MyCpuClass *klass) {
  41.    GObjectClass *g_class;
  42.    GtkWidgetClass *w_class;
  43.    GParamSpec *pspec;
  45.    g_class = G_OBJECT_CLASS(klass);
  46.    w_class = GTK_WIDGET_CLASS(klass);
  48.    /* Override widget class methods */
  49.    g_class->set_property  = my_cpu_set_property;
  50.    g_class->get_property  = my_cpu_get_property;
  52.    w_class->realize       = my_cpu_realize;
  53.    w_class->size_request  = my_cpu_size_request;
  54.    w_class->size_allocate = my_cpu_size_allocate;
  55.    w_class->expose_event  = my_cpu_expose;
  57.    /* Install property */
  58.    pspec = g_param_spec_double("percent", "Percent", 
  59.        "What CPU load should be displayed", 0, 1, 0, 
  60.        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  62.    g_object_class_install_property(g_class, P_PERCENT, pspec);
  64.    /* Add private data */
  65.    g_type_class_add_private(g_class, sizeof(MyCpuPrivate));
  66. }
  68. static void my_cpu_init(MyCpu *cpu) {
  70.    MyCpuPrivate *priv;
  72.    priv = G_TYPE_INSTANCE_GET_PRIVATE(cpu, MY_TYPE_CPU, MyCpuPrivate);
  74.    gtk_widget_set_has_window(GTK_WIDGET(cpu), TRUE);
  76.    /* Set default values */
  77.    priv->percent = 0;
  79.    /* Create cache for faster access */
  80.    cpu->priv = priv;
  81. }
  83. /* Overriden virtual methods */
  84. static void my_cpu_set_property(GObject *object, guint prop_id,
  85.     const GValue *value, GParamSpec *pspec) {
  87.    MyCpu *cpu = MY_CPU(object);
  89.    switch(prop_id) {
  91.       case P_PERCENT:
  93.          my_cpu_set_percent(cpu, g_value_get_double(value));
  94.          break;
  96.       default:
  98.          G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
  99.          break;
  100.    }
  101. }
  103. static void my_cpu_get_property(GObject *object, guint prop_id,
  104.                 GValue *value, GParamSpec *pspec) {
  106.    MyCpu *cpu = MY_CPU(object);
  108.    switch(prop_id) {
  110.       case P_PERCENT:
  111.          g_value_set_double(value, cpu->priv->percent);
  112.          break;
  114.       default:
  115.          G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
  116.          break;
  117.    }
  118. }
  120. static void my_cpu_realize(GtkWidget *widget) {
  122.    MyCpuPrivate *priv = MY_CPU(widget)->priv;
  123.    GtkAllocation alloc;
  124.    GdkWindowAttr attrs;
  125.    guint attrs_mask;
  127.    gtk_widget_set_realized(widget, TRUE);
  129.    gtk_widget_get_allocation(widget, &alloc);
  131.    attrs.x           = alloc.x;
  132.    attrs.y           = alloc.y;
  133.    attrs.width       = alloc.width;
  134.    attrs.height      = alloc.height;
  135.    attrs.window_type = GDK_WINDOW_CHILD;
  136.    attrs.wclass      = GDK_INPUT_OUTPUT;
  137.    attrs.event_mask  = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
  139.    attrs_mask = GDK_WA_X | GDK_WA_Y;
  141.    priv->window = gdk_window_new(gtk_widget_get_parent_window(widget),
  142.                &attrs, attrs_mask);
  143.    gdk_window_set_user_data(priv->window, widget);
  144.    gtk_widget_set_window(widget, priv->window);
  146.    widget->style = gtk_style_attach(gtk_widget_get_style( widget ),
  147.                              priv->window);
  148.    gtk_style_set_background(widget->style, priv->window, GTK_STATE_NORMAL);
  149. }
  151. static void my_cpu_size_request(GtkWidget *widget, 
  152.     GtkRequisition *requisition) {
  154.    requisition->width  = WIDTH;
  155.    requisition->height = HEIGHT;
  156. }
  158. static void my_cpu_size_allocate(GtkWidget *widget,
  159.                  GtkAllocation *allocation) {
  161.    MyCpuPrivate *priv;
  163.    priv = MY_CPU(widget)->priv;
  165.    gtk_widget_set_allocation(widget, allocation);
  167.    if (gtk_widget_get_realized(widget)) {
  169.       gdk_window_move_resize(priv->window, allocation->x, allocation->y,
  170.           WIDTH, HEIGHT);
  171.    }
  172. }
  174. static gboolean my_cpu_expose(GtkWidget *widget, 
  175.     GdkEventExpose *event) {
  177.    MyCpuPrivate *priv = MY_CPU(widget)->priv;
  178.    cairo_t *cr;
  179.    gint limit;
  180.    gint i;
  182.    cr = gdk_cairo_create(event->window);
  184.    cairo_translate(cr, 0, 7);
  186.    cairo_set_source_rgb(cr, 0, 0, 0);
  187.    cairo_paint(cr);
  189.    limit = 20 - priv->percent / 5;
  191.    for (i = 1; i <= 20; i++) {
  193.       if (i > limit) {
  194.          cairo_set_source_rgb(cr, 0.6, 1.0, 0);
  195.       } else {
  196.          cairo_set_source_rgb(cr, 0.2, 0.4, 0);
  197.       }
  199.       cairo_rectangle(cr, 8,  i * 4, 30, 3);
  200.       cairo_rectangle(cr, 42, i * 4, 30, 3);
  201.       cairo_fill(cr);
  202.    }
  204.    cairo_destroy(cr);
  206.    return TRUE;
  207. }
  209. /* Public API */
  210. GtkWidget *my_cpu_new(void) {
  212.    return(g_object_new(MY_TYPE_CPU, NULL));
  213. }
  215. gdouble my_cpu_get_percent(MyCpu *cpu) {
  217.    g_return_val_if_fail(MY_IS_CPU(cpu), 0);
  219.    return(cpu->priv->percent);
  220. }
  222. void my_cpu_set_percent(MyCpu *cpu, gdouble sel) {
  224.    g_return_if_fail(MY_IS_CPU(cpu));
  226.    cpu->priv->percent = sel;
  227.    gtk_widget_queue_draw(GTK_WIDGET(cpu));
  228. }

mycpu.c是 CPU 小部件的实现。 CPU 小部件是GtkWidget，我们可以使用 Cairo API 在其上进行绘制。 我们绘制一个黑色背景和 40 个小矩形。 矩形以两种颜色绘制：深绿色和亮绿色。 GtkVScale小部件控制在小部件上绘制的鲜绿色矩形的数量。

main.c

  1. #include "mycpu.h"
  3. void cb_changed(GtkRange *range, GtkWidget *cpu) {
  5.    my_cpu_set_percent(MY_CPU(cpu), gtk_range_get_value(range));
  6. }
  8. int main(int argc, char *argv[]) {
  10.    GtkWidget *window;
  11.    GtkWidget *hbox;
  12.    GtkWidget *vbox;
  13.    GtkWidget *cpu;
  14.    GtkWidget *scale;
  16.    gtk_init(&argc, &argv);
  18.    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  19.    gtk_container_set_border_width(GTK_CONTAINER(window), 15);
  20.    gtk_window_set_title(GTK_WINDOW(window), "CPU widget");
  22.    vbox = gtk_vbox_new(FALSE, 0);
  23.    hbox = gtk_hbox_new(FALSE, 25);
  25.    cpu = my_cpu_new();
  26.    gtk_box_pack_start(GTK_BOX(hbox), cpu, FALSE, FALSE, 0);
  28.    scale = gtk_vscale_new_with_range(0, 100, 1);
  29.    gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
  30.    gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
  31.    gtk_box_pack_start(GTK_BOX(hbox), scale, FALSE, FALSE, 0);
  33.    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
  34.    gtk_container_add(GTK_CONTAINER(window), vbox);
  36.    g_signal_connect(scale, "value-changed", G_CALLBACK(cb_changed), cpu);
  37.    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
  39.    gtk_widget_show_all(window);
  41.    gtk_main();
  43.    return 0;
  44. }

这是主文件。 我们创建自定义 CPU 小部件，并使其与GtkVScale小部件一起使用。

  1. gcc -Wall $(pkg-config --cflags gtk+-2.0) -o mycpu.o -c mycpu.c
  2. gcc -Wall $(pkg-config --cflags gtk+-2.0) -o main.o -c main.c
  3. gcc -o test_cpu main.o mycpu.o $(pkg-config --libs gtk+-2.0)

使用这些命令，我们构建了示例。

自定义 GTK 小部件 - 图1

图：CPU小部件

在本章中，我们创建了一个自定义的 GTK+ 小部件。