Tristan Van Berkom wrote:
> David E. Konerding wrote:
>
>> Hi folks,
>>
>> I previously posted a question about containers; specifically, i want to
>> have a layout container in which drawing
>> done to the parent window "shows through" layout where nothing is placed
>> on the layout. Here's an example of what's not working for me.
>> The diagonal line is obscured by the inner_layout Layout container,
>> although I am setting the back_pixmap for the Layout's window and
>> bin_window to NULL, which is supposed to do what I want. Anybody have
>> any suggestions?
>>
>>
>
> You dont need to mess with gdk_window_set_back_pixmap(), it
> should be irrelevent in this context (it sets the X server with
> a default background for your GdkWindow)
>
Yes, and it's the default background being painted which is the
problem. My read of the documentation
is that if you set a NULL back_pixmap, the window doesn't get painted
with anything and the original contents of the "underlying"
parent window shows through. Right now, X is automatically painting a
single color to the region, whatever color
I set using gtk_widget_set_background.
> You should simply try doing:
> GTK_WIDGET_SET_FLAGS (layout, GTK_NO_WINDOW)
> on your layout *before* it gets realized.
>
I tried this (inserting this line directly after gtk_layout_new). It
doesn't work. How could it? The realize handler for gtk_layout_realize
always makes a child window and a child bin_window regardless of that
flag setting.
More importantly, a GtkFrame works just fine; if you place a GtkFrame
onto a Layout that has line drawing on it,
the line drawing does show through, even through the GtkFrame has a
window! I've attached an example of code demonstrating just
that. From my perspective, the only difference in a GtkFrame and
GtkLayout is that the GtkFrame has the border and can contain only a
single child.
> Remember that GTK_NO_WINDOW widgets draw to there
> parent windows, so when you do gdk_draw_line, you should
> not ignore widget->allocation.[xy] :)
>
Yes, and if I'm going to make a Layout be a GTK_NO_WINDOW, then I would
just write my own NO_WINDOW container, but
then obviously whenever I place children widgets in the layout I have to
adjust it for the allocation as you said. That much I've
already got working. I just wanted to find a much simpler solution.
#include <stdio.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
static gboolean layout_expose(GtkWidget *widget, GdkEventExpose *event) {
printf("expose, %d, %d\n", event->area.width, event->area.height);
GtkLayout *layout = GTK_LAYOUT(widget);
gdk_draw_line (layout->bin_window,
widget->style->black_gc,
0, 0,
widget->allocation.width, widget->allocation.height);
}
static gboolean inner_layout_realize(GtkWidget *widget, GdkEventExpose
*event) {
printf("realize\n");
GtkLayout *layout = GTK_LAYOUT(widget);
/* an attempt to make a 'see-through inner layout' which doesn't work */
#if 0
gdk_window_set_back_pixmap(widget->window, NULL, FALSE);
gdk_window_set_back_pixmap(layout->bin_window, NULL, FALSE);
#endif
}
int main( int argc,
char *argv[] ) {
/* GtkWidget is the storage type for widgets */
GtkWidget *window, *layout, *inner_layout, *label, *inner_frame,
*frame_label;
GdkColor color;
/* Initialise GTK */
gtk_init (&argc, &argv);
/* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Frame Example");
/* Here we connect the "destroy" event to a signal handler */
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_set_size_request (window, 500, 500);
/* Create a layout */
layout = gtk_layout_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), layout);
gtk_widget_set_size_request (layout, 500, 500);
gtk_widget_show (layout);
/* Create an inner layout */
inner_layout = gtk_layout_new (NULL, NULL);
/* one attempt to make a 'see-through' inner layout; does not work */
GTK_WIDGET_SET_FLAGS (inner_layout, GTK_NO_WINDOW);
gtk_layout_put (GTK_LAYOUT (layout), inner_layout, 100, 100);
gtk_widget_set_size_request (inner_layout, 200, 200);
gtk_widget_show (inner_layout);
/* Create a label in inner layout */
label = gtk_label_new ("Test");
gtk_layout_put (GTK_LAYOUT (inner_layout), label, 30, 30);
gtk_widget_show (label);
/* Create an frame */
inner_frame = gtk_frame_new ("Test");
gtk_layout_put (GTK_LAYOUT (layout), inner_frame, 400, 400);
gtk_widget_show (inner_frame);
/* Create a label in inner frame */
frame_label = gtk_label_new ("Test2");
gtk_container_add (GTK_CONTAINER (inner_frame), frame_label);
gtk_widget_show (frame_label);
g_signal_connect (G_OBJECT (layout), "expose_event",
G_CALLBACK (layout_expose), NULL);
g_signal_connect (G_OBJECT (inner_layout), "realize",
G_CALLBACK (inner_layout_realize), NULL);
/* Create a layout inside the layout */
/* Display the window */
gtk_widget_show (window);
/* Enter the event loop */
gtk_main ();
return 0;
}
Dave
_______________________________________________
gtk-list@xxxxxxxxx
http://mail.gnome.org/mailman/listinfo/gtk-list
