static void
_vte_pango_x_draw_text(struct _vte_draw *draw,
struct _vte_draw_text_request *requests,
gsize n_requests,
GdkColor *color, guchar alpha)
{
Display *display;
GC gc;
struct _vte_pango_x_data *data;
char buf[VTE_UTF8_BPC];
gsize i, length;
GdkColor wcolor;
data = (struct _vte_pango_x_data*) draw->impl_data;
wcolor = *color;
gdk_rgb_find_color(gdk_drawable_get_colormap(draw->widget->window),
&wcolor);
gdk_gc_set_foreground(data->gc, &wcolor);
display = gdk_x11_drawable_get_xdisplay(draw->widget->window);
gc = gdk_x11_gc_get_xgc(data->gc);
for (i = 0; i < n_requests; i++) {
length = g_unichar_to_utf8(requests[i].c, buf);
pango_layout_set_text(data->layout, buf, length);
pango_x_render_layout(display,
data->drawable,
gc,
data->layout,
requests[i].x - data->x_offs,
requests[i].y - data->y_offs);
}
}
static void
gs_theme_engine_clear (GtkWidget *widget)
{
GdkColor color = { 0, 0x0000, 0x0000, 0x0000 };
GdkColormap *colormap;
GtkStateType state;
g_return_if_fail (GS_IS_THEME_ENGINE (widget));
if (! GTK_WIDGET_VISIBLE (widget))
{
return;
}
state = (GtkStateType) 0;
while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg))
{
gtk_widget_modify_bg (widget, state, &color);
state++;
}
colormap = gdk_drawable_get_colormap (widget->window);
gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE);
gdk_window_set_background (widget->window, &color);
gdk_window_clear (widget->window);
gdk_flush ();
}
GpImage *
gp_image_new_from_pixmap ( GdkPixmap* pixmap, GdkRectangle *rect, gboolean has_alpha )
{
GpImage *image;
GdkRectangle r;
g_return_val_if_fail ( GDK_IS_PIXMAP (pixmap), NULL);
if ( rect == NULL )
{
r.x = r.y = 0;
gdk_drawable_get_size ( pixmap, &r.width, &r.height );
}
else
{
r.x = rect->x;
r.y = rect->y;
r.width = rect->width;
r.height= rect->height;
}
image = gp_image_new( r.width, r.height, has_alpha );
g_return_val_if_fail ( image != NULL, NULL);
gdk_pixbuf_get_from_drawable(
image->priv->pixbuf,
pixmap,
gdk_drawable_get_colormap ( pixmap ),
r.x, r.y,
0, 0,
r.width, r.height);
return image;
}
static void pidgin_whiteboard_button_save_press(GtkWidget *widget, gpointer data)
{
PidginWhiteboard *gtkwb = (PidginWhiteboard*)(data);
GdkPixbuf *pixbuf;
GtkWidget *dialog;
int result;
dialog = gtk_file_chooser_dialog_new (_("Save File"),
GTK_WINDOW(gtkwb->window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/* gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), (gboolean)(TRUE)); */
/* if(user_edited_a_new_document) */
{
/* gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), default_folder_for_saving); */
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "whiteboard.jpg");
}
/*
else
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), filename_for_existing_document);
*/
result = gtk_dialog_run(GTK_DIALOG(dialog));
if(result == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
gtk_widget_destroy(dialog);
/* Makes an icon from the whiteboard's canvas 'image' */
pixbuf = gdk_pixbuf_get_from_drawable(NULL,
(GdkDrawable*)(gtkwb->pixmap),
gdk_drawable_get_colormap(gtkwb->pixmap),
0, 0,
0, 0,
gtkwb->width, gtkwb->height);
if(gdk_pixbuf_save(pixbuf, filename, "jpeg", NULL, "quality", "100", NULL))
purple_debug_info("gtkwhiteboard", "File Saved...\n");
else
purple_debug_info("gtkwhiteboard", "File not Saved... Error\n");
g_free(filename);
}
else if(result == GTK_RESPONSE_CANCEL)
{
gtk_widget_destroy(dialog);
purple_debug_info("gtkwhiteboard", "File not Saved... Cancelled\n");
}
}
static void
chart_configure(GtkWidget *widget, GdkEvent *event, void *nil)
{
CHART(widget)->points_in_view = widget->allocation.width;
if (!CHART(widget)->colormap)
CHART(widget)->colormap = gdk_drawable_get_colormap(widget->window);
}
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
GdkWindow *parent_win = gdk_window_lookup((XID)window);
mSocketWidget = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), NULL);
g_signal_connect(mSocketWidget, "unrealize",
G_CALLBACK(socket_unrealize_cb), NULL);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
gpointer user_data = NULL;
gdk_window_get_user_data(parent_win, &user_data);
GtkContainer *container = GTK_CONTAINER(user_data);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// The GtkSocket has a visible window, but the plugin's XEmbed plug will
// cover this window. Normally GtkSockets let the X server paint their
// background and this would happen immediately (before the plug is
// created). Setting the background to None prevents the server from
// painting this window, avoiding flicker.
gdk_window_set_back_pixmap(mSocketWidget->window, NULL, FALSE);
// Resize before we show
SetAllocation();
gtk_widget_show(mSocketWidget);
gdk_flush();
window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));
// Fill out the ws_info structure.
// (The windowless case is done in nsObjectFrame.cpp.)
GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
if(!gdkWindow)
return NS_ERROR_FAILURE;
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
mWsInfo.depth = gdkVisual->depth;
return NS_OK;
}
static VALUE
rg_colormap(VALUE self)
{
VALUE rb_colormap;
rb_colormap = GOBJ2RVAL(gdk_drawable_get_colormap(_SELF(self)));
G_CHILD_ADD(self, rb_colormap);
return rb_colormap;
}
void
gp_image_set_mask ( GpImage *image, GdkBitmap *mask )
{
GdkPixbuf *pixbuf;
GdkPixbuf *m_pixbuf;
guchar *pixels, *m_pixels;
guchar *p, *m_p;
gint w, h;
gint n_channels, rowstride;
g_return_if_fail ( GP_IS_IMAGE (image) );
pixbuf = image->priv->pixbuf;
if(!gdk_pixbuf_get_has_alpha ( pixbuf ) )
{ /*add alpha*/
GdkPixbuf *tmp ;
tmp = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
g_object_unref(pixbuf);
pixbuf = tmp;
}
m_pixbuf = gdk_pixbuf_copy ( pixbuf );
gdk_pixbuf_get_from_drawable ( m_pixbuf,
mask,
gdk_drawable_get_colormap (mask),
0,0,
0,0,
-1,-1);
n_channels = gdk_pixbuf_get_n_channels ( pixbuf );
rowstride = gdk_pixbuf_get_rowstride ( pixbuf );
w = gdk_pixbuf_get_width ( pixbuf );
h = gdk_pixbuf_get_height ( pixbuf );
pixels = gdk_pixbuf_get_pixels ( pixbuf );
m_pixels = gdk_pixbuf_get_pixels ( m_pixbuf );
while (h--)
{
guint i = w;
p = pixels;
m_p = m_pixels;
while (i--)
{
if(m_p[0] == 0)
{
p[0] = 0;
p[1] = 0;
p[2] = 0;
p[3] = 0;
}
p += n_channels;
m_p += n_channels;
}
pixels += rowstride;
m_pixels += rowstride;
}
g_object_unref (m_pixbuf);
}
static void applyConfig(Plugin* p)
{
ENTER;
batt *b = (batt *) p->priv;
/* Update colors */
if (b->backgroundColor &&
gdk_color_parse(b->backgroundColor, &b->background)) {
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->background, FALSE, TRUE);
gdk_gc_set_foreground(b->bg, &b->background);
}
if (b->chargingColor1 && gdk_color_parse(b->chargingColor1, &b->charging1))
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->charging1, FALSE, TRUE);
if (b->chargingColor2 && gdk_color_parse(b->chargingColor2, &b->charging2))
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->charging2, FALSE, TRUE);
if (b->dischargingColor1 &&
gdk_color_parse(b->dischargingColor1, &b->discharging1))
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->discharging1, FALSE, TRUE);
if (b->dischargingColor2 &&
gdk_color_parse(b->dischargingColor2, &b->discharging2))
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->discharging2, FALSE, TRUE);
/* Make sure the border value is acceptable */
b->border = MIN(MAX(0, b->requestedBorder),
(MIN(b->length, b->thickness) - 1) / 2);
/* Resize the widget */
if (b->orientation == ORIENT_HORIZ)
b->width = b->thickness;
else
b->height = b->thickness;
gtk_widget_set_size_request(b->drawingArea, b->width, b->height);
RET();
}
static void setup_imlib_for_drawable(GdkDrawable * d)
{
imlib_context_set_dither(1); /* dither for depths < 24bpp */
imlib_context_set_display(
gdk_x11_drawable_get_xdisplay(d));
imlib_context_set_visual(
gdk_x11_visual_get_xvisual(gdk_drawable_get_visual(d)));
imlib_context_set_colormap(
gdk_x11_colormap_get_xcolormap(gdk_drawable_get_colormap(d)));
imlib_context_set_drawable(
gdk_x11_drawable_get_xid(d));
}
static VALUE
rg_set_colormap(VALUE self, VALUE colormap)
{
VALUE old_colormap;
old_colormap = GOBJ2RVAL(gdk_drawable_get_colormap(_SELF(self)));
G_CHILD_REMOVE(self, old_colormap);
G_CHILD_ADD(self, colormap);
gdk_drawable_set_colormap(_SELF(self), GDK_COLORMAP(RVAL2GOBJ(colormap)));
return self;
}
GdkColor get_color(const char *spec)
{
GdkColormap *cmap;
GdkColor color;
cmap = gdk_drawable_get_colormap(root->window);
if (!gdk_color_parse(spec, &color))
abort();
if (!gdk_colormap_alloc_color(cmap, &color, FALSE, TRUE))
abort();
return color;
}
static void pidgin_whiteboard_set_canvas_as_icon(PidginWhiteboard *gtkwb)
{
GdkPixbuf *pixbuf;
/* Makes an icon from the whiteboard's canvas 'image' */
pixbuf = gdk_pixbuf_get_from_drawable(NULL,
(GdkDrawable*)(gtkwb->pixmap),
gdk_drawable_get_colormap(gtkwb->pixmap),
0, 0,
0, 0,
gtkwb->width, gtkwb->height);
gtk_window_set_icon((GtkWindow*)(gtkwb->window), pixbuf);
}
void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
{
if (m_hasBgCol && m_backgroundColour.Ok())
{
GdkWindow *window = gtk_tree_view_get_bin_window(m_treeview);
if (window)
{
m_backgroundColour.CalcPixel( gdk_drawable_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
gtk_widget_modify_style( GTK_WIDGET(m_treeview), style );
}
static void
_vte_pango_x_fill_rectangle(struct _vte_draw *draw,
gint x, gint y, gint width, gint height,
GdkColor *color, guchar alpha)
{
struct _vte_pango_x_data *data;
GdkColor wcolor;
data = (struct _vte_pango_x_data*) draw->impl_data;
wcolor = *color;
gdk_rgb_find_color(gdk_drawable_get_colormap(draw->widget->window),
&wcolor);
gdk_gc_set_foreground(data->gc, &wcolor);
gdk_draw_rectangle(draw->widget->window, data->gc, TRUE,
x, y, width, height);
}
/**
* gimp_canvas_set_bg_color:
* @canvas: a #GimpCanvas widget
* @color: a color in #GimpRGB format
*
* Sets the background color of the canvas's window. This
* is the color the canvas is set to if it is cleared.
**/
void
gimp_canvas_set_bg_color (GimpCanvas *canvas,
GimpRGB *color)
{
GtkWidget *widget = GTK_WIDGET (canvas);
GdkColormap *colormap;
GdkColor gdk_color;
if (! GTK_WIDGET_REALIZED (widget))
return;
gimp_rgb_get_gdk_color (color, &gdk_color);
colormap = gdk_drawable_get_colormap (widget->window);
g_return_if_fail (colormap != NULL);
gdk_colormap_alloc_color (colormap, &gdk_color, FALSE, TRUE);
gdk_window_set_background (widget->window, &gdk_color);
}
void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
{
#ifdef __WXGTK3__
// don't know if this is even necessary, or how to do it
#else
if (m_hasBgCol && m_backgroundColour.IsOk())
{
GdkWindow *window = gtk_tree_view_get_bin_window(m_treeview);
if (window)
{
m_backgroundColour.CalcPixel( gdk_drawable_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
#endif
GTKApplyStyle(GTK_WIDGET(m_treeview), style);
}
static GdkPixmap *
scale_pixmap (GdkWindow *window, GdkPixmap *pixmap, gdouble scale_x, gdouble scale_y)
{
GdkGC *gc = NULL;
GdkPixmap *new_pixmap;
gint width, height, new_width, new_height;
GdkPixbuf *pixbuf = NULL;
GdkPixbuf *aux_pixbuf = NULL;
if(!pixmap) return NULL;
if(!window) return NULL;
gdk_window_get_size(pixmap, &width, &height);
gc = gdk_gc_new(window);
if(scale_x == 1.0 && scale_y == 1.0){
new_pixmap = gdk_pixmap_new(window, width, height, -1);
gdk_draw_pixmap(new_pixmap,
gc,
pixmap,
0, 0,
0, 0,
width, height);
gdk_gc_unref(gc);
return new_pixmap;
}
new_width = roundint(width * scale_x);
new_height = roundint(height * scale_y);
pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, gdk_drawable_get_colormap(window), 0, 0, 0, 0, width, height);
aux_pixbuf = gdk_pixbuf_scale_simple(pixbuf, new_width, new_height, GDK_INTERP_BILINEAR);
new_pixmap = gdk_pixmap_new(pixmap, new_width, new_height, -1);
gdk_draw_pixbuf(new_pixmap, gc, aux_pixbuf, 0, 0, 0, 0, new_width, new_height, GDK_RGB_DITHER_MAX, 0, 0);
gdk_pixbuf_unref(pixbuf);
gdk_pixbuf_unref(aux_pixbuf);
gdk_gc_unref(gc);
return new_pixmap;
}
static GdkColormap*
get_cmap (GdkPixmap *pixmap)
{
GdkColormap *cmap;
cmap = gdk_drawable_get_colormap (pixmap);
if (cmap)
g_object_ref (G_OBJECT (cmap));
if (cmap == NULL)
{
if (gdk_drawable_get_depth (pixmap) == 1)
{
/* try null cmap */
cmap = NULL;
}
else
{
/* Try system cmap */
GdkScreen *screen = gdk_drawable_get_screen (GDK_DRAWABLE (pixmap));
cmap = gdk_screen_get_system_colormap (screen);
g_object_ref (G_OBJECT (cmap));
}
}
/* Be sure we aren't going to blow up due to visual mismatch */
if (cmap &&
#if GTK_CHECK_VERSION(2,21,0)
(gdk_visual_get_depth (gdk_colormap_get_visual (cmap)) !=
gdk_drawable_get_depth (pixmap))
#else
(gdk_colormap_get_visual (cmap)->depth !=
gdk_drawable_get_depth (pixmap))
#endif
)
{
g_object_unref (G_OBJECT (cmap));
cmap = NULL;
}
return cmap;
}
/***********************************************
* ge_cairo_pixmap_pattern -
*
* Create A Tiled Pixmap Pattern
***********************************************/
CairoPattern*
ge_cairo_pixmap_pattern(GdkPixmap *pixmap)
{
CairoPattern * result = NULL;
GdkPixbuf * pixbuf;
gint width, height;
gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height);
pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (pixmap),
gdk_drawable_get_colormap(GDK_DRAWABLE (pixmap)),
0, 0, 0, 0, width, height);
result = ge_cairo_pixbuf_pattern(pixbuf);
g_object_unref (pixbuf);
return result;
}
static void
_vte_pango_x_start(struct _vte_draw *draw)
{
struct _vte_pango_x_data *data;
Display *display;
GdkDrawable *drawable;
int x_offs, y_offs;
data = (struct _vte_pango_x_data*) draw->impl_data;
display = gdk_x11_drawable_get_xdisplay(draw->widget->window);
if (data->ctx != NULL) {
g_object_unref(data->ctx);
}
data->ctx = pango_x_get_context(display);
if (data->layout != NULL) {
g_object_unref(data->layout);
}
data->layout = pango_layout_new(data->ctx);
if (data->font != NULL) {
pango_layout_set_font_description(data->layout, data->font);
}
if (data->gc != NULL) {
g_object_unref(data->gc);
}
data->gc = gdk_gc_new(draw->widget->window);
gdk_rgb_find_color(gdk_drawable_get_colormap(draw->widget->window),
&data->color);
gdk_window_get_internal_paint_info(draw->widget->window, &drawable,
&x_offs, &y_offs);
data->drawable = gdk_x11_drawable_get_xid(drawable);
data->x_offs = x_offs;
data->y_offs = y_offs;
}
static GdkColormap*
get_cmap (GdkPixmap *pixmap)
{
GdkColormap *cmap;
cmap = gdk_drawable_get_colormap (pixmap);
if (cmap)
g_object_ref (G_OBJECT (cmap));
if (cmap == NULL)
{
if (gdk_drawable_get_depth (pixmap) == 1)
{
meta_verbose ("Using NULL colormap for snapshotting bitmap\n");
cmap = NULL;
}
else
{
meta_verbose ("Using system cmap to snapshot pixmap\n");
cmap = gdk_screen_get_system_colormap (gdk_drawable_get_screen (pixmap));
g_object_ref (G_OBJECT (cmap));
}
}
/* Be sure we aren't going to blow up due to visual mismatch */
if (cmap &&
(gdk_colormap_get_visual (cmap)->depth !=
gdk_drawable_get_depth (pixmap)))
{
cmap = NULL;
meta_verbose ("Switching back to NULL cmap because of depth mismatch\n");
}
return cmap;
}
nsresult nsPluginNativeWindowGtk::CreateXEmbedWindow(bool aEnableXtFocus) {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
GdkDisplay *display = gdk_display_get_default();
GdkWindow *parent_win = gdk_x11_window_lookup_for_display(display, GetWindow());
mSocketWidget = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// enable/disable focus event handlers,
// see plugin_window_filter_func() for details
g_object_set_data(G_OBJECT(mSocketWidget), "enable-xt-focus", (void *)aEnableXtFocus);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), nullptr);
g_signal_connect(mSocketWidget, "unrealize",
G_CALLBACK(socket_unrealize_cb), nullptr);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
gpointer user_data = nullptr;
gdk_window_get_user_data(parent_win, &user_data);
GtkContainer *container = GTK_CONTAINER(user_data);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// The GtkSocket has a visible window, but the plugin's XEmbed plug will
// cover this window. Normally GtkSockets let the X server paint their
// background and this would happen immediately (before the plug is
// created). Setting the background to None prevents the server from
// painting this window, avoiding flicker.
// TODO GTK3
#if (MOZ_WIDGET_GTK == 2)
gdk_window_set_back_pixmap(gtk_widget_get_window(mSocketWidget), nullptr, FALSE);
#endif
// Resize before we show
SetAllocation();
gtk_widget_show(mSocketWidget);
gdk_flush();
SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget)));
// Fill out the ws_info structure.
// (The windowless case is done in nsPluginFrame.cpp.)
GdkWindow *gdkWindow = gdk_x11_window_lookup_for_display(display, GetWindow());
if(!gdkWindow)
return NS_ERROR_FAILURE;
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
#if (MOZ_WIDGET_GTK == 2)
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.depth = gdkVisual->depth;
#else
mWsInfo.colormap = None;
GdkVisual* gdkVisual = gdk_window_get_visual(gdkWindow);
mWsInfo.depth = gdk_visual_get_depth(gdkVisual);
#endif
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
return NS_OK;
}
static PyObject *
PyGdkWindow_GetAttr(PyGdkWindow_Object *self, char *key)
{
GdkWindow *win = PyGdkWindow_Get(self);
gint x, y;
GdkModifierType p_mask;
if (!strcmp(key, "__members__"))
return Py_BuildValue("[sssssssssssss]", "children", "colormap", "depth",
"height", "parent", "pointer", "pointer_state",
"toplevel", "type", "width", "x", "xid", "y");
if (!strcmp(key, "width")) {
gdk_drawable_get_size(win, &x, NULL);
return PyInt_FromLong(x);
}
if (!strcmp(key, "height")) {
gdk_drawable_get_size(win, NULL, &y);
return PyInt_FromLong(y);
}
if (!strcmp(key, "x")) {
gdk_window_get_position(win, &x, NULL);
return PyInt_FromLong(x);
}
if (!strcmp(key, "y")) {
gdk_window_get_position(win, NULL, &y);
return PyInt_FromLong(y);
}
if (!strcmp(key, "colormap"))
return PyGdkColormap_New(gdk_drawable_get_colormap(win));
if (!strcmp(key, "pointer")) {
gdk_window_get_pointer(win, &x, &y, NULL);
return Py_BuildValue("(ii)", x, y);
}
if (!strcmp(key, "pointer_state")) {
gdk_window_get_pointer(win, NULL, NULL, &p_mask);
return PyInt_FromLong(p_mask);
}
if (!strcmp(key, "parent")) {
GdkWindow *par = gdk_window_get_parent(win);
if (par)
return PyGdkWindow_New(par);
Py_INCREF(Py_None);
return Py_None;
}
if (!strcmp(key, "toplevel"))
return PyGdkWindow_New(gdk_window_get_toplevel(win));
if (!strcmp(key, "children")) {
GList *children, *tmp;
PyObject *ret;
children = gdk_window_get_children(win);
if ((ret = PyList_New(0)) == NULL)
return NULL;
for (tmp = children; tmp != NULL; tmp = tmp->next) {
PyObject *win = PyGdkWindow_New(tmp->data);
if (win == NULL) {
Py_DECREF(ret);
return NULL;
}
PyList_Append(ret, win);
Py_DECREF(win);
}
g_list_free(children);
return ret;
}
if (!strcmp(key, "type"))
return PyInt_FromLong(gdk_drawable_get_type(win));
if (!strcmp(key, "depth")) {
gdk_window_get_geometry(win, NULL, NULL, NULL, NULL, &x);
return PyInt_FromLong(x);
}
#ifdef WITH_XSTUFF
if (!strcmp(key, "xid"))
return PyInt_FromLong(GDK_WINDOW_XWINDOW(win));
#endif
return Py_FindMethod(PyGdkWindow_methods, (PyObject *)self, key);
}
void log_window_init(LogWindow *logwin)
{
GtkTextBuffer *buffer;
#if !GTK_CHECK_VERSION(3, 0, 0)
GdkColormap *colormap;
gboolean success[LOG_COLORS];
#endif
GdkColor color[LOG_COLORS];
gint i;
gtkut_convert_int_to_gdk_color(prefs_common.log_msg_color, &color[0]);
gtkut_convert_int_to_gdk_color(prefs_common.log_warn_color, &color[1]);
gtkut_convert_int_to_gdk_color(prefs_common.log_error_color, &color[2]);
gtkut_convert_int_to_gdk_color(prefs_common.log_in_color, &color[3]);
gtkut_convert_int_to_gdk_color(prefs_common.log_out_color, &color[4]);
gtkut_convert_int_to_gdk_color(prefs_common.log_status_ok_color, &color[5]);
gtkut_convert_int_to_gdk_color(prefs_common.log_status_nok_color, &color[6]);
gtkut_convert_int_to_gdk_color(prefs_common.log_status_skip_color, &color[7]);
logwin->msg_color = color[0];
logwin->warn_color = color[1];
logwin->error_color = color[2];
logwin->in_color = color[3];
logwin->out_color = color[4];
logwin->status_ok_color = color[5];
logwin->status_nok_color = color[6];
logwin->status_skip_color = color[7];
#if !GTK_CHECK_VERSION(3, 0, 0)
colormap = gdk_drawable_get_colormap(gtk_widget_get_window(logwin->window));
gdk_colormap_alloc_colors(colormap, color, LOG_COLORS, FALSE, TRUE, success);
for (i = 0; i < LOG_COLORS; i++) {
if (success[i] == FALSE) {
GtkStyle *style;
g_warning("LogWindow: color allocation failed");
style = gtk_widget_get_style(logwin->window);
logwin->msg_color = logwin->warn_color =
logwin->error_color = logwin->in_color =
logwin->out_color = logwin->status_ok_color =
logwin->status_nok_color = logwin->status_skip_color =
style->black;
break;
}
}
#endif
buffer = logwin->buffer;
gtk_text_buffer_create_tag(buffer, "message",
"foreground-gdk", &logwin->msg_color,
NULL);
gtk_text_buffer_create_tag(buffer, "warn",
"foreground-gdk", &logwin->warn_color,
NULL);
logwin->error_tag = gtk_text_buffer_create_tag(buffer, "error",
"foreground-gdk", &logwin->error_color,
NULL);
gtk_text_buffer_create_tag(buffer, "input",
"foreground-gdk", &logwin->in_color,
NULL);
gtk_text_buffer_create_tag(buffer, "output",
"foreground-gdk", &logwin->out_color,
NULL);
gtk_text_buffer_create_tag(buffer, "status_ok",
"foreground-gdk", &logwin->status_ok_color,
NULL);
gtk_text_buffer_create_tag(buffer, "status_nok",
"foreground-gdk", &logwin->status_nok_color,
NULL);
gtk_text_buffer_create_tag(buffer, "status_skip",
"foreground-gdk", &logwin->status_skip_color,
NULL);
}
static GdkPixmap *
create_text_pixmap(GtkWidget *drawing_area, FT_Face face)
{
gint i, pixmap_width, pixmap_height, pos_y, textlen;
GdkPixmap *pixmap = NULL;
const gchar *text;
Display *xdisplay;
Drawable xdrawable;
Visual *xvisual;
Colormap xcolormap;
XftDraw *draw;
XftColor colour;
XGlyphInfo extents;
XftFont *font;
gint *sizes = NULL, n_sizes, alpha_size;
FcCharSet *charset = NULL;
cairo_t *cr;
GdkWindow *window = gtk_widget_get_window (drawing_area);
text = pango_language_get_sample_string(NULL);
if (! check_font_contain_text (face, text))
{
pango_language_get_sample_string (pango_language_from_string ("en_US"));
}
textlen = strlen(text);
/* create the XftDraw */
xdisplay = GDK_PIXMAP_XDISPLAY(window);
#if GTK_CHECK_VERSION(3, 0, 0)
xvisual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));
#else
xvisual = GDK_VISUAL_XVISUAL(gdk_drawable_get_visual(window));
#endif
xcolormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(window));
XftColorAllocName(xdisplay, xvisual, xcolormap, "black", &colour);
/* work out what sizes to render */
if (FT_IS_SCALABLE(face)) {
n_sizes = 8;
sizes = g_new(gint, n_sizes);
sizes[0] = 8;
sizes[1] = 10;
sizes[2] = 12;
sizes[3] = 18;
sizes[4] = 24;
sizes[5] = 36;
sizes[6] = 48;
sizes[7] = 72;
alpha_size = 24;
} else {
/* use fixed sizes */
n_sizes = face->num_fixed_sizes;
sizes = g_new(gint, n_sizes);
alpha_size = 0;
for (i = 0; i < face->num_fixed_sizes; i++) {
sizes[i] = face->available_sizes[i].height;
/* work out which font size to render */
if (face->available_sizes[i].height <= 24)
alpha_size = face->available_sizes[i].height;
}
}
/* calculate size of pixmap to use (with 4 pixels padding) ... */
pixmap_width = 8;
pixmap_height = 8;
font = get_font(xdisplay, face, alpha_size, charset);
charset = FcCharSetCopy (font->charset);
XftTextExtentsUtf8(xdisplay, font,
(guchar *)lowercase_text, strlen(lowercase_text), &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftTextExtentsUtf8(xdisplay, font,
(guchar *)uppercase_text, strlen(uppercase_text), &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftTextExtentsUtf8(xdisplay, font,
(guchar *)punctuation_text, strlen(punctuation_text), &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftFontClose(xdisplay, font);
pixmap_height += 8;
for (i = 0; i < n_sizes; i++) {
font = get_font(xdisplay, face, sizes[i], charset);
if (!font) continue;
XftTextExtentsUtf8(xdisplay, font, (guchar *)text, textlen, &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftFontClose(xdisplay, font);
}
/* create pixmap */
gtk_widget_set_size_request(drawing_area, pixmap_width, pixmap_height);
pixmap = gdk_pixmap_new(window,
pixmap_width, pixmap_height, -1);
if (!pixmap)
goto end;
cr = gdk_cairo_create (pixmap);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_destroy (cr);
xdrawable = GDK_DRAWABLE_XID(pixmap);
draw = XftDrawCreate(xdisplay, xdrawable, xvisual, xcolormap);
/* draw text */
pos_y = 4;
font = get_font(xdisplay, face, alpha_size, charset);
draw_string(xdisplay, draw, font, &colour, lowercase_text, &pos_y);
draw_string(xdisplay, draw, font, &colour, uppercase_text, &pos_y);
draw_string(xdisplay, draw, font, &colour, punctuation_text, &pos_y);
XftFontClose(xdisplay, font);
pos_y += 8;
for (i = 0; i < n_sizes; i++) {
font = get_font(xdisplay, face, sizes[i], charset);
if (!font) continue;
draw_string(xdisplay, draw, font, &colour, text, &pos_y);
XftFontClose(xdisplay, font);
}
g_signal_connect(drawing_area, "expose-event", G_CALLBACK(expose_event),
pixmap);
end:
g_free(sizes);
FcCharSetDestroy (charset);
return pixmap;
}
void GtkViewWidget::repaint() {
GtkPaintContext >kContext = (GtkPaintContext&)view()->context();
Angle angle = rotation();
bool isRotated = (angle == DEGREES90) || (angle == DEGREES270);
int w = isRotated ? myArea->allocation.height : myArea->allocation.width;
int h = isRotated ? myArea->allocation.width : myArea->allocation.height;
gtkContext.updatePixmap(myArea, w, h);
view()->paint();
switch (angle) {
default:
cleanOriginalPixbuf();
cleanRotatedPixbuf();
gdk_draw_pixmap(myArea->window, myArea->style->white_gc, gtkContext.pixmap(),
0, 0, 0, 0, myArea->allocation.width, myArea->allocation.height);
break;
case DEGREES180:
cleanRotatedPixbuf();
if ((myOriginalPixbuf != 0) &&
((gdk_pixbuf_get_width(myOriginalPixbuf) != w) ||
(gdk_pixbuf_get_height(myOriginalPixbuf) != h))) {
cleanOriginalPixbuf();
}
if (myOriginalPixbuf == 0) {
myOriginalPixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, w, h);
myImage = gdk_image_new(GDK_IMAGE_FASTEST, gdk_drawable_get_visual(gtkContext.pixmap()), w, h);
}
gdk_drawable_copy_to_image(gtkContext.pixmap(), myImage, 0, 0, 0, 0, w, h);
gdk_pixbuf_get_from_image(myOriginalPixbuf, myImage, gdk_drawable_get_colormap(gtkContext.pixmap()),
0, 0, 0, 0, w, h);
::rotate180(myOriginalPixbuf);
gdk_draw_pixbuf(myArea->window, myArea->style->white_gc, myOriginalPixbuf,
0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
break;
case DEGREES90:
case DEGREES270:
if ((myOriginalPixbuf != 0) &&
((gdk_pixbuf_get_width(myOriginalPixbuf) != w) ||
(gdk_pixbuf_get_height(myOriginalPixbuf) != h))) {
cleanOriginalPixbuf();
}
if ((myRotatedPixbuf != 0) &&
((gdk_pixbuf_get_width(myRotatedPixbuf) != h) ||
(gdk_pixbuf_get_height(myRotatedPixbuf) != w))) {
cleanRotatedPixbuf();
}
if (myOriginalPixbuf == 0) {
myOriginalPixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, w, h);
myImage = gdk_image_new(GDK_IMAGE_FASTEST, gdk_drawable_get_visual(gtkContext.pixmap()), w, h);
}
if (myRotatedPixbuf == 0) {
myRotatedPixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, h, w);
}
gdk_drawable_copy_to_image(gtkContext.pixmap(), myImage, 0, 0, 0, 0, w, h);
gdk_pixbuf_get_from_image(myOriginalPixbuf, myImage, gdk_drawable_get_colormap(gtkContext.pixmap()),
0, 0, 0, 0, w, h);
::rotate90(myRotatedPixbuf, myOriginalPixbuf, angle == DEGREES90);
gdk_draw_pixbuf(myArea->window, myArea->style->white_gc, myRotatedPixbuf,
0, 0, 0, 0, h, w, GDK_RGB_DITHER_NONE, 0, 0);
break;
}
}
static int
constructor(Plugin *p, char **fp)
{
ENTER;
batt *b;
p->priv = b = g_new0(batt, 1);
p->pwid = gtk_event_box_new();
GTK_WIDGET_SET_FLAGS( p->pwid, GTK_NO_WINDOW );
gtk_container_set_border_width( GTK_CONTAINER(p->pwid), 1 );
b->drawingArea = gtk_drawing_area_new();
gtk_widget_add_events( b->drawingArea, GDK_BUTTON_PRESS_MASK );
gtk_container_add( (GtkContainer*)p->pwid, b->drawingArea );
if ((b->orientation = p->panel->orientation) == ORIENT_HORIZ) {
b->height = b->length = 20;
b->thickness = b->width = 8;
}
else {
b->height = b->thickness = 8;
b->length = b->width = 20;
}
gtk_widget_set_size_request(b->drawingArea, b->width, b->height);
gtk_widget_show(b->drawingArea);
b->bg = gdk_gc_new(p->panel->topgwin->window);
b->gc1 = gdk_gc_new(p->panel->topgwin->window);
b->gc2 = gdk_gc_new(p->panel->topgwin->window);
g_signal_connect (G_OBJECT (b->drawingArea), "button_press_event",
G_CALLBACK(buttonPressEvent), (gpointer) p);
g_signal_connect (G_OBJECT (b->drawingArea),"configure_event",
G_CALLBACK (configureEvent), (gpointer) b);
g_signal_connect (G_OBJECT (b->drawingArea), "expose_event",
G_CALLBACK (exposeEvent), (gpointer) b);
sem_init(&(b->alarmProcessLock), 0, 1);
b->alarmCommand = b->backgroundColor = b->chargingColor1 = b->chargingColor2
= b->dischargingColor1 = b->dischargingColor2 = NULL;
/* Set default values for integers */
b->alarmTime = 5;
b->requestedBorder = 1;
b->numSamples = b->rateSamplesSum = b->wasCharging = 0;
b->rateSamples = (unsigned int *) malloc(sizeof(int) * MAX_SAMPLES);
line s;
s.len = 256;
if (fp) {
/* Apply options */
while (lxpanel_get_line(fp, &s) != LINE_BLOCK_END) {
if (s.type == LINE_NONE) {
ERR( "batt: illegal token %s\n", s.str);
goto error;
}
if (s.type == LINE_VAR) {
if (!g_ascii_strcasecmp(s.t[0], "HideIfNoBattery"))
b->hide_if_no_battery = atoi(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "AlarmCommand"))
b->alarmCommand = g_strdup(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "BackgroundColor"))
b->backgroundColor = g_strdup(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "ChargingColor1"))
b->chargingColor1 = g_strdup(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "ChargingColor2"))
b->chargingColor2 = g_strdup(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "DischargingColor1"))
b->dischargingColor1 = g_strdup(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "DischargingColor2"))
b->dischargingColor2 = g_strdup(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "AlarmTime"))
b->alarmTime = atoi(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "BorderWidth"))
b->requestedBorder = atoi(s.t[1]);
else if (!g_ascii_strcasecmp(s.t[0], "Size")) {
b->thickness = MAX(1, atoi(s.t[1]));
if (b->orientation == ORIENT_HORIZ)
b->width = b->thickness;
else
b->height = b->thickness;
gtk_widget_set_size_request(b->drawingArea, b->width,
b->height);
}
else {
ERR( "batt: unknown var %s\n", s.t[0]);
continue;
}
}
else {
ERR( "batt: illegal in this context %s\n", s.str);
goto error;
}
}
}
/* Make sure the border value is acceptable */
b->border = MIN(MAX(0, b->requestedBorder),
(MIN(b->length, b->thickness) - 1) / 2);
/* Apply more default options */
if (! b->alarmCommand)
b->alarmCommand = g_strdup("xmessage Battery low");
if (! b->backgroundColor)
b->backgroundColor = g_strdup("black");
if (! b->chargingColor1)
b->chargingColor1 = g_strdup("#28f200");
if (! b->chargingColor2)
b->chargingColor2 = g_strdup("#22cc00");
if (! b->dischargingColor1)
b->dischargingColor1 = g_strdup("#ffee00");
if (! b->dischargingColor2)
b->dischargingColor2 = g_strdup("#d9ca00");
gdk_color_parse(b->backgroundColor, &b->background);
gdk_color_parse(b->chargingColor1, &b->charging1);
gdk_color_parse(b->chargingColor2, &b->charging2);
gdk_color_parse(b->dischargingColor1, &b->discharging1);
gdk_color_parse(b->dischargingColor2, &b->discharging2);
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->background, FALSE, TRUE);
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->charging1, FALSE, TRUE);
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->charging2, FALSE, TRUE);
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->discharging1, FALSE, TRUE);
gdk_colormap_alloc_color(gdk_drawable_get_colormap(
p->panel->topgwin->window), &b->discharging2, FALSE, TRUE);
gdk_gc_set_foreground(b->bg, &b->background);
check_batteries( b ); /* get available batteries */
/* Start the update loop */
#if GTK_CHECK_VERSION( 2, 14, 0 )
b->timer = g_timeout_add_seconds( 3, (GSourceFunc) update_timout, (gpointer) b);
#else
b->timer = g_timeout_add( 3000,
(GSourceFunc) update_timout, (gpointer) b);
#endif
RET(TRUE);
error:
destructor( p );
RET(FALSE);
}
void
gp_image_set_diff_pixmap ( GpImage *image, GdkPixmap* pixmap, guint x_offset, guint y_offset )
{
GdkPixbuf *pixbuf;
GdkPixbuf *m_pixbuf;
guchar *pixels, *m_pixels;
guchar *p, *m_p;
gint w, h;
gint n_channels, rowstride;
g_return_if_fail ( GP_IS_IMAGE (image) );
pixbuf = image->priv->pixbuf;
if(!gdk_pixbuf_get_has_alpha ( pixbuf ) )
{ /*add alpha*/
GdkPixbuf *tmp ;
tmp = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
g_object_unref(pixbuf);
pixbuf = tmp;
}
m_pixbuf = gdk_pixbuf_copy ( pixbuf );
w = gdk_pixbuf_get_width ( pixbuf );
h = gdk_pixbuf_get_height ( pixbuf );
gdk_pixbuf_get_from_drawable ( m_pixbuf,
pixmap,
gdk_drawable_get_colormap (pixmap),
x_offset,y_offset,
0,0,
w,h);
n_channels = gdk_pixbuf_get_n_channels ( pixbuf );
rowstride = gdk_pixbuf_get_rowstride ( pixbuf );
pixels = gdk_pixbuf_get_pixels ( pixbuf );
m_pixels = gdk_pixbuf_get_pixels ( m_pixbuf );
while (h--)
{
guint i = w;
p = pixels;
m_p = m_pixels;
while (i--)
{
pixel_union *pu, *m_pu;
pu = (pixel_union *)p;
m_pu = (pixel_union *)m_p;
if(pu->ui32 == m_pu->ui32)
{
p[0] = 0;
p[1] = 0;
p[2] = 0;
p[3] = 0;
}
p += n_channels;
m_p += n_channels;
}
pixels += rowstride;
m_pixels += rowstride;
}
g_object_unref (m_pixbuf);
}
nsresult nsPluginNativeWindowGtk2::CreateXCompositedWindow() {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
mParentWindow = gtk_window_new(GTK_WINDOW_POPUP);
mSocketWidget = gtk_socket_new();
GdkWindow *parent_win = mParentWindow->window;
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// Make sure to handle the plug_removed signal. If we don't the
// socket will automatically be destroyed when the plug is
// removed, which means we're destroying it more than once.
// SYNTAX ERROR.
g_signal_connect(mSocketWidget, "plug_removed",
G_CALLBACK(plug_removed_cb), NULL);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
/*gpointer user_data = NULL;
gdk_window_get_user_data(parent_win, &user_data);
*/
GtkContainer *container = GTK_CONTAINER(mParentWindow);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// Resize before we show
SetAllocation();
gtk_widget_set_size_request (mSocketWidget, width, height);
/* move offscreen */
gtk_window_move (GTK_WINDOW(mParentWindow), width+1000, height+1000);
gtk_widget_show(mSocketWidget);
gtk_widget_show_all(mParentWindow);
/* store away a reference to the socketwidget */
mPlugWindow = (mSocketWidget);
gdk_flush();
window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));
/* This is useful if we still have the plugin window inline
* i.e. firefox vs. fennec */
// gdk_window_set_composited(mSocketWidget->window, TRUE);
if (!mDamage) {
/* we install a general handler instead of one specific to a particular window
* because we don't have a GdkWindow for the plugin window */
gdk_window_add_filter (parent_win, plugin_composite_filter_func, this);
int junk;
if (!XDamageQueryExtension (GDK_DISPLAY (), &xdamage_event_base, &junk))
printf ("This requires the XDamage extension");
mDamage = XDamageCreate(GDK_DISPLAY(), (Drawable)window, XDamageReportNonEmpty);
XCompositeRedirectWindow (GDK_DISPLAY(),
(Drawable)window,
CompositeRedirectManual);
/* this is a hack to avoid having flash causing a crash when it is unloaded.
* libplayback sets up dbus_connection_filters. When flash is unloaded it takes
* libplayback with it, however the connection filters are not removed
* which causes a crash when dbus tries to execute them. dlopening libplayback
* ensures that those functions stay around even after flash is gone. */
static void *libplayback_handle;
if (!libplayback_handle) {
libplayback_handle = dlopen("libplayback-1.so.0", RTLD_NOW);
}
}
// Fill out the ws_info structure.
// (The windowless case is done in nsObjectFrame.cpp.)
GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
mWsInfo.depth = gdkVisual->depth;
return NS_OK;
}
