Chinaunix首页 | 论坛 | 博客

nketcnketc.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

nketc

  • 博客访问： 43190
  • 博文数量： 3
  • 博客积分： 321
  • 博客等级： 一等列兵
  • 技术积分： 40
  • 用 户 组： 普通用户
  • 注册时间： 2010-04-25 14:20
文章分类

全部博文（3）

文章存档

2011年（2）

2010年（1）

我的朋友
最近访客
推荐博文
相关博文
Gtk顶级窗口嵌入技术------glade技术分析之一

分类： Delphi

2011-03-20 21:52:45

Glade是Gtk+的界面设计器，详见：.基本上是一个所见即所得的Gtk+界面设计工具，本文讨论Glade“所见”的实现方法，即下图中正在设计中的界面是怎样画出来的。

就是上上图中被红色矩形框包围的部分是怎样画出来的。

在Gtk+的体系结构中是不允许一个toplevel类型的Widget（即：GtkWindow）中放置一个toplevel类型的Widget的。像下面的代码这样：
  1. GtkWidget *window_embedded = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  2. GtkWidget *window_embedder = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  4. ..........
  5. ..........
  6. gtk_container_add (GTK_CONTAINER (window_embedder), window_embedded);
是不能工作的。那么，glade是使用什么神秘的技术实现设计中的界面的绘制的呢？
查看glade的代码，完成这部分工作的是其中的GladeDesignLayout这个类，代码就在 gladeui/glade-design-layout.c 中。其工作原理是：
1）GladeDesignLayout继承自GtkBin作为一个容器，用来容纳toplevel类型的Widget（即：GtkWindow）
2）GladeDesignLayout内部使用一个GDK_WINDOW_OFFSCREEN类型的GdkWindow作为它要容纳的Widget的parent window。这样被嵌入的Widget都绘制在这个offscreen类型的GdkWindow上。
3）GladeDesignLayout再把offscreen gdk window中的内容绘制出来
具体细节：
1）gtk_widget_set_parent_window (window_embedded, offscreen_window)
window_embedded是要嵌入显示的GtkWindow，offscreen_window是GladeDesignLayout内部的那个offscreen gdk window。当上面那句话执行的时候gtk实际上会把window_embedded的toplevel标记去掉，这样window_embedded时间上就和一个GtkContainer（vbox，table，grid之类的）一样了。
2）gtk_container_propagate_draw （window_embedded)
这个函数调用配合上面的gtk_widget_set_parent_window就实现了把window_embedded的内容绘制到了offscreen gdk window中。
最后GladeDesignLayout在上面的基础上再绘制一些辅助元素（第一幅图中的红色矩形框，表示选择的半透明矩形，对于尚未填充内容的容器绘制为placeholder等）

下面是根据GladeDesignLayout缩写的一个Gtk+控件：SupperContainer，之所以叫这个名字，是因为它像GladeDesignLayout一样可以容纳toplevel类型的Widget。

suppercontainer.c
  1. #include <gtk/gtk.h>

  3. #include "suppercontainer.h"

  5. struct _SupperContainerPriv
  6. {
  7.   GdkWindow *window;
  8.   GdkWindow *offscreen_window;

  10.   gint inner_border;
  11.   gint child_offset;
  12. };

  14. G_DEFINE_TYPE (SupperContainer, supper_container, GTK_TYPE_BIN)

  16. static void
  17. supper_container_get_preferred_height (GtkWidget *widget,
  18.                                        gint *min, gint *nat)
  19. {
  20.   SupperContainerPriv *priv;
  21.   GtkWidget *child;
  22.   gint child_height = 0;
  23.   gint border_width = 0;

  25.   priv = SUPPER_CONTAINER (widget)->priv;

  27.   *min = 0;

  29.   child = gtk_bin_get_child (GTK_BIN (widget));

  31.   if (child && gtk_widget_get_visible (child))
  32.   {
  33.     GtkRequisition req;

  35.     gtk_widget_get_preferred_size (child, &req, NULL);

  37.     *min = req.height;
  38.   }

  40.   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
  41.   *min += border_width * 2;
  42.   *min += priv->inner_border * 2;

  44.   *nat = *min;
  45. }

  47. static void
  48. supper_container_get_preferred_width (GtkWidget *widget,
  49.                                       gint *min, gint *nat)
  50. {
  51.   SupperContainerPriv *priv;
  52.   GtkWidget *child;
  53.   gint child_height = 0;
  54.   gint border_width = 0;

  56.   priv = SUPPER_CONTAINER (widget)->priv;

  58.   *min = 0;

  60.   child = gtk_bin_get_child (GTK_BIN (widget));

  62.   if (child && gtk_widget_get_visible (child))
  63.   {
  64.     GtkRequisition req;

  66.     gtk_widget_get_preferred_size (child, &req, NULL);

  68.     *min = req.width;
  69.   }

  71.   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
  72.   *min += border_width * 2;
  73.   *min += priv->inner_border * 2;

  75.   *nat = *min;
  76. }

  78. static void
  79. supper_container_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
  80. {
  81.   GtkWidget *child;

  83.   gtk_widget_set_allocation (widget, allocation);

  85.   if (gtk_widget_get_realized (widget))
  86.     gdk_window_move_resize (gtk_widget_get_window (widget),
  87.      allocation->x, allocation->y,
  88.                             allocation->width, allocation->height);

  90.   child = gtk_bin_get_child (GTK_BIN (widget));

  92.   if (child && gtk_widget_get_visible (child))
  93.   {
  94.     SupperContainerPriv *priv = SUPPER_CONTAINER (widget)->priv;
  95.     GtkAllocation alloc;
  96.     gint height, offset;

  98.     offset = gtk_container_get_border_width (GTK_CONTAINER (widget));
  99.     offset += priv->inner_border;
  100.     priv->child_offset = offset;

  102.     alloc.x = alloc.y = 0;
  103.     alloc.width = allocation->width - offset * 2;
  104.     alloc.height = allocation->height - offset * 2;

  106.     if (gtk_widget_get_realized (widget))
  107.      gdk_window_move_resize (priv->offscreen_window,
  108.      0, 0, alloc.width, alloc.height);
  109.     
  110.     gtk_widget_size_allocate (child, &alloc);
  111.   }
  112. }

  114. static void
  115. supper_container_add (GtkContainer *container, GtkWidget *widget)
  116. {
  117.   SupperContainer *supper_container = SUPPER_CONTAINER (container);
  118.   SupperContainerPriv *priv = supper_container->priv;

  120.   gtk_widget_set_parent_window (widget, priv->offscreen_window);

  122.   GTK_CONTAINER_CLASS (supper_container_parent_class)->add (container, widget);

  124.   gtk_widget_queue_draw (GTK_WIDGET (container));
  125. }

  127. static void
  128. supper_container_remove (GtkContainer *container, GtkWidget *widget)
  129. {
  130.   GTK_CONTAINER_CLASS (supper_container_parent_class)->remove (container, widget);

  132.   gtk_widget_queue_draw (GTK_WIDGET (container));
  133. }

  135. static gboolean
  136. supper_container_damage (GtkWidget *widget, GdkEventExpose *event)
  137. {
  138.   gdk_window_invalidate_rect (gtk_widget_get_window (widget), NULL, TRUE);

  140.   return TRUE;
  141. }

  143. static gboolean
  144. supper_container_draw (GtkWidget *widget, cairo_t *cr)
  145. {
  146.   SupperContainerPriv *priv = SUPPER_CONTAINER (widget)->priv;
  147.   GtkStyleContext *context;
  148.   GtkStateFlags state;
  149.   gint width, height;

  151.   context = gtk_widget_get_style_context (widget);
  152.   state = gtk_widget_get_state_flags (widget);

  154.   gtk_style_context_set_state (context, state);


  157.   if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
  158.   {
  159.     GtkWidget *child;
  160.     GdkRGBA color;

  162.     gdk_window_get_geometry (gtk_widget_get_window (widget), NULL, NULL, &width, &height);

  164.     gtk_render_background (context, cr, 0, 0, width, height);

  166.     child = gtk_bin_get_child (GTK_BIN (widget));

  168.     if (child && gtk_widget_get_visible (child))
  169.     {
  170.      gdk_cairo_set_source_window (cr, priv->offscreen_window,
  171.      priv->child_offset, priv->child_offset);
  172.      cairo_rectangle (cr, priv->child_offset, priv->child_offset,
  173.      gdk_window_get_width (priv->offscreen_window),
  174.                      gdk_window_get_height (priv->offscreen_window));
  175.      cairo_fill (cr);

  177.       /* draw frame border */
  178.      gtk_style_context_get_color (context, state, &color);
  179.       gdk_cairo_set_source_rgba (cr, &color);
  180.       
  181.      cairo_set_line_width (cr, priv->inner_border);
  182.      cairo_rectangle (cr, priv->inner_border, priv->inner_border,
  183.      width - priv->inner_border * 2,
  184.                      height - priv->inner_border * 2);
  185.      cairo_stroke (cr);
  186.     }
  187.   }
  188.   else if (gtk_cairo_should_draw_window (cr, priv->offscreen_window))
  189.   {
  190.     GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));

  192.     gtk_render_background (context, cr, 0, 0,
  193.      gdk_window_get_width (priv->offscreen_window),
  194.                          gdk_window_get_height (priv->offscreen_window));
  195.     
  196.     if (child)
  197.      gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
  198.   }

  200.   return FALSE;
  201. }

  203. static inline void
  204. to_child (SupperContainer *bin,
  205.           double widget_x,
  206.           double widget_y,
  207.           double *x_out,
  208.           double *y_out)
  209. {
  210.   SupperContainerPriv *priv = SUPPER_CONTAINER (bin)->priv;

  212.   *x_out = widget_x - priv->child_offset;
  213.   *y_out = widget_y - priv->child_offset;
  214. }

  216. static inline void
  217. to_parent (SupperContainer *bin,
  218.            double offscreen_x,
  219.            double offscreen_y,
  220.            double *x_out,
  221.            double *y_out)
  222. {
  223.   SupperContainerPriv *priv = SUPPER_CONTAINER (bin)->priv;
  224.  
  225.   *x_out = offscreen_x + priv->child_offset;
  226.   *y_out = offscreen_y + priv->child_offset;
  227. }

  229. static GdkWindow*
  230. pick_offscreen_child (GdkWindow *window, double widget_x, double widget_y,
  231.                       SupperContainer *bin)
  232. {
  233.   SupperContainerPriv *priv = SUPPER_CONTAINER (bin)->priv;
  234.   GtkWidget *child = gtk_bin_get_child (GTK_BIN (bin));

  236.   if (child && gtk_widget_get_visible (child))
  237.   {
  238.     GtkAllocation child_area;
  239.     double x, y;

  241.     to_child (bin, widget_x, widget_y, &x, &y);

  243.     gtk_widget_get_allocation (child, &child_area);

  245.     if (x >= 0 && x < child_area.width &&
  246.      y >= 0 && y < child_area.height)
  247.      return priv->offscreen_window;
  248.   }

  250.   return NULL;
  251. }

  253. static void
  254. offscreen_window_to_parent (GdkWindow *offscreen_window,
  255.                             double offscreen_x,
  256.                             double offscreen_y,
  257.                             double *parent_x,
  258.                             double *parent_y,
  259.                             SupperContainer *bin)
  260. {
  261.   to_parent (bin, offscreen_x, offscreen_y, parent_x, parent_y);
  262. }

  264. static void
  265. offscreen_window_from_parent (GdkWindow *window,
  266.                               double parent_x,
  267.                               double parent_y,
  268.                               double *offscreen_x,
  269.                               double *offscreen_y,
  270.                               SupperContainer *bin)
  271. {
  272.   to_child (bin, parent_x, parent_y, offscreen_x, offscreen_y);
  273. }

  275. static void
  276. supper_container_realize (GtkWidget *widget)
  277. {
  278.   SupperContainerPriv *priv;
  279.   GtkStyleContext *context;
  280.   GdkWindowAttr attributes;
  281.   GtkWidget *child;
  282.   gint attributes_mask, border_width;
  283.   GtkAllocation allocation;

  285.   priv = SUPPER_CONTAINER (widget)->priv;

  287.   gtk_widget_set_realized (widget, TRUE);

  289.   gtk_widget_get_allocation (widget, &allocation);
  290.   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  292.   attributes.x = allocation.x + border_width;
  293.   attributes.y = allocation.y + border_width;
  294.   attributes.width = allocation.width - 2 * border_width;
  295.   attributes.height = allocation.height - 2 * border_width;
  296.   attributes.window_type = GDK_WINDOW_CHILD;
  297.   attributes.event_mask = gtk_widget_get_events (widget)
  298.                         | GDK_EXPOSURE_MASK
  299.                         | GDK_POINTER_MOTION_MASK
  300.                         | GDK_BUTTON_PRESS_MASK;
  301.   attributes.visual = gtk_widget_get_visual (widget);
  302.   attributes.wclass = GDK_INPUT_OUTPUT;

  304.   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;

  306.   priv->window = gdk_window_new (gtk_widget_get_parent_window (widget),
  307.                                  &attributes, attributes_mask);
  308.   gtk_widget_set_window (widget, priv->window);
  309.   gdk_window_set_user_data (priv->window, widget);

  311.   g_signal_connect (priv->window, "pick-embedded-child",
  312.                     G_CALLBACK (pick_offscreen_child), widget);

  314.   child = gtk_bin_get_child (GTK_BIN (widget));
  315.   attributes.window_type = GDK_WINDOW_OFFSCREEN;
  316.   attributes.x = attributes.y = 0;

  318.   if (child && gtk_widget_get_visible (child))
  319.   {
  320.     GtkAllocation alloc;

  322.     gtk_widget_get_allocation (child, &alloc);
  323.     attributes.width = allocation.width;
  324.     attributes.height = allocation.height;
  325.   }
  326.   else
  327.     attributes.width = attributes.height = 0;

  329.   priv->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget),
  330.                                            &attributes, attributes_mask);
  331.   gdk_window_set_user_data (priv->offscreen_window, widget);

  333.   if (child)
  334.     gtk_widget_set_parent_window (child, priv->offscreen_window);

  336.   gdk_offscreen_window_set_embedder (priv->offscreen_window, priv->window);

  338.   g_signal_connect (priv->offscreen_window, "to-embedder",
  339.                     G_CALLBACK (offscreen_window_to_parent), widget);
  340.   g_signal_connect (priv->offscreen_window, "from-embedder",
  341.                     G_CALLBACK (offscreen_window_from_parent), widget);

  343.   context = gtk_widget_get_style_context (widget);
  344.   gtk_style_context_set_background (context, priv->window);
  345.   gtk_style_context_set_background (context, priv->offscreen_window);
  346.   gdk_window_show (priv->offscreen_window);
  347. }

  349. static void
  350. supper_container_unrealize (GtkWidget *widget)
  351. {
  352.   SupperContainerPriv *priv = SUPPER_CONTAINER (widget)->priv;

  354.   if (priv->offscreen_window)
  355.   {
  356.     gdk_window_set_user_data (priv->offscreen_window, NULL);
  357.     gdk_window_destroy (priv->offscreen_window);
  358.     priv->offscreen_window = NULL;
  359.   }

  361.   GTK_WIDGET_CLASS (supper_container_parent_class)->unrealize (widget);
  362. }

  364. static void
  365. supper_container_init (SupperContainer *supper)
  366. {
  367.   SupperContainerPriv *priv;

  369.   supper->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (supper, SUPPER_CONTAINER_TYPE, SupperContainerPriv);

  371.   priv->inner_border = 2;

  373.   gtk_widget_set_has_window (GTK_WIDGET (supper), TRUE);
  374. }

  376. static void
  377. supper_container_class_init (SupperContainerClass *klass)
  378. {
  379.   GObjectClass *object_class;
  380.   GtkWidgetClass *widget_class;
  381.   GtkContainerClass *container_class;

  383.   object_class = G_OBJECT_CLASS (klass);
  384.   widget_class = GTK_WIDGET_CLASS (klass);
  385.   container_class = GTK_CONTAINER_CLASS (klass);

  387.   container_class->add = supper_container_add;
  388.   container_class->remove = supper_container_remove;

  390.   widget_class->realize = supper_container_realize;
  391.   widget_class->unrealize = supper_container_unrealize;
  392.   widget_class->draw = supper_container_draw;
  393.   widget_class->get_preferred_width = supper_container_get_preferred_width;
  394.   widget_class->get_preferred_height = supper_container_get_preferred_height;
  395.   widget_class->size_allocate = supper_container_size_allocate;

  397.   g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
  398.                                    SUPPER_CONTAINER_TYPE,
  399.                                  g_cclosure_new (G_CALLBACK (supper_container_damage),
  400.                                  NULL, NULL));

  402.   g_type_class_add_private (object_class, sizeof (SupperContainerPriv));
  403. }

  405. GtkWidget*
  406. supper_container_new (void)
  407. {
  408.   return g_object_new (SUPPER_CONTAINER_TYPE, NULL);
  409. }
suppercontainer.h
  1. #ifndef __SUPPER_CONTAINER_H__
  2. #define __SUPPER_CONTAINER_H__

  4. #include <gtk/gtk.h>

  6. G_BEGIN_DECLS

  8. #define SUPPER_CONTAINER_TYPE (supper_container_get_type ())
  9. #define SUPPER_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), SUPPER_CONTAINER_TYPE, SupperContainer))
  10. #define SUPPER_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), SUPPER_CONTAINER_TYPE, SupperContainerClass))
  11. #define IS_SUPPER_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), SUPPER_CONTAINER_TYPE))
  12. #define IS_SUPPER_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), SUPPER_CONTAINER_TYPE))
  13. #define SUPPER_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), SUPPER_CONTAINER_TYPE, SupperContainerClass))

  15. typedef struct _SupperContainer SupperContainer;
  16. typedef struct _SupperContainerPriv SupperContainerPriv;
  17. typedef struct _SupperContainerClass SupperContainerClass;

  19. struct _SupperContainer
  20. {
  21.   GtkBin parent_instance;

  23.   SupperContainerPriv *priv;
  24. };

  26. struct _SupperContainerClass
  27. {
  28.   GtkBinClass parent_class;
  29. };

  31. GType supper_container_get_type (void) G_GNUC_CONST;

  33. GtkWidget* supper_container_new (void);

  35. G_END_DECLS

  37. #endif
测试程序（test.c）：
  1. #include <gtk/gtk.h>
  2. #include "suppercontainer.h"

  4. int main (int argc, char *argv[])
  5. {
  6.   GtkWidget *window, *embedded_window;
  7.   GtkWidget *supper;
  8.   GtkWidget *label_embedded;
  9.   GtkWidget *label_embedder;
  10.   GtkWidget *vbox;

  12.   gtk_init (&argc, &argv);

  14.   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  15.   gtk_widget_set_size_request (window, 400, 300);
  16.   
  17.   vbox = gtk_vbox_new (FALSE, 2);
  18.   gtk_widget_show (vbox);

  20.   label_embedder = gtk_label_new ("I'am a label in embedder.");
  21.   gtk_widget_show (label_embedder);

  23.   gtk_box_pack_start (GTK_BOX(vbox), label_embedder, FALSE, FALSE, 5);

  25.   supper = supper_container_new ();
  26.   gtk_widget_show (supper);

  28.   gtk_box_pack_start (GTK_BOX(vbox), supper, TRUE, TRUE, 5);

  30.   gtk_container_add (GTK_CONTAINER (window), vbox);
  31.   
  32.   gtk_widget_show (window);

  34.   embedded_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  35.   label_embedded = gtk_label_new ("I'am a label in embedded.");
  36.   gtk_widget_show (label_embedded);
  37.   gtk_container_add (GTK_CONTAINER (embedded_window), label_embedded);

  39.   gtk_container_add (GTK_CONTAINER (supper), embedded_window);

  41.   gtk_widget_show_all (window);

  43.   gtk_main ();

  45.   return 0;
  46. }
gcc -g -O0 -o test `pkg-config --cflags --libs gtk+-3.0` test.c suppercontainer.c
编译后可测试：

阅读(5649) | 评论(0) | 转发(0) |
0

上一篇：使用xmpp库loudmouth连接google talk服务器

下一篇：没有了

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6