static gboolean InitGroupLeader(Window *groupLeader, Window *rootWindow) { Window myGroupLeader; Window myRootWindow; XSetWindowAttributes attr; GdkDisplay *gdkDisplay; GdkWindow *gdkLeader; attr.override_redirect = True; ASSERT(groupLeader); ASSERT(rootWindow); gdkDisplay = gdk_display_get_default(); gdkLeader = gdk_display_get_default_group(gdkDisplay); myGroupLeader = GDK_WINDOW_XWINDOW(gdkLeader); myRootWindow = GDK_ROOT_WINDOW(); ASSERT(myGroupLeader); ASSERT(myRootWindow); /* XXX: With g_set_prgname() being called, this can probably go away. */ XStoreName(GDK_DISPLAY(), myGroupLeader, VMUSER_TITLE); /* * Sanity check: Set the override redirect property on our group leader * window (not default), then re-parent it to the root window (default). * This makes sure that (a) a window manager can't re-parent our window, * and (b) that we remain a top-level window. */ XChangeWindowAttributes(GDK_DISPLAY(), myGroupLeader, CWOverrideRedirect, &attr); XReparentWindow(GDK_DISPLAY(), myGroupLeader, myRootWindow, 10, 10); XSync(GDK_DISPLAY(), FALSE); *groupLeader = myGroupLeader; *rootWindow = myRootWindow; return TRUE; }
/* If we are faking transparency with a window-relative background, force a * redraw of the icon. This should be called if the background changes or if * the child is shifted with respect to the background. */ void na_tray_child_force_redraw (NaTrayChild *child) { GtkWidget *widget = GTK_WIDGET (child); if (GTK_WIDGET_MAPPED (child) && child->parent_relative_bg) { #if 1 /* Sending an ExposeEvent might cause redraw problems if the * icon is expecting the server to clear-to-background before * the redraw. It should be ok for GtkStatusIcon or EggTrayIcon. */ Display *xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)); XEvent xev; xev.xexpose.type = Expose; xev.xexpose.window = GDK_WINDOW_XWINDOW (GTK_SOCKET (child)->plug_window); xev.xexpose.x = 0; xev.xexpose.y = 0; xev.xexpose.width = widget->allocation.width; xev.xexpose.height = widget->allocation.height; xev.xexpose.count = 0; gdk_error_trap_push (); XSendEvent (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)), xev.xexpose.window, False, ExposureMask, &xev); /* We have to sync to reliably catch errors from the XSendEvent(), * since that is asynchronous. */ XSync (xdisplay, False); gdk_error_trap_pop (); #else /* Hiding and showing is the safe way to do it, but can result in more * flickering. */ gdk_window_hide (widget->window); gdk_window_show (widget->window); #endif } }
FloatRect screenAvailableRect(Widget* widget) { if (!widget) return FloatRect(); #if PLATFORM(X11) GtkWidget* container = GTK_WIDGET(widget->root()->hostWindow()->platformPageClient()); if (!container) return FloatRect(); if (!gtk_widget_get_realized(container)) return screenRect(widget); GdkDrawable* rootWindow = GDK_DRAWABLE(gtk_widget_get_root_window(container)); GdkDisplay* display = gdk_drawable_get_display(rootWindow); Atom xproperty = gdk_x11_get_xatom_by_name_for_display(display, "_NET_WORKAREA"); Atom retType; int retFormat; long *workAreaPos = NULL; unsigned long retNItems; unsigned long retAfter; int xRes = XGetWindowProperty(GDK_DISPLAY_XDISPLAY(display), GDK_WINDOW_XWINDOW(rootWindow), xproperty, 0, 4, FALSE, XA_CARDINAL, &retType, &retFormat, &retNItems, &retAfter, (guchar**)&workAreaPos); FloatRect rect; if (xRes == Success && workAreaPos != NULL && retType == XA_CARDINAL && retNItems == 4 && retFormat == 32) { rect = FloatRect(workAreaPos[0], workAreaPos[1], workAreaPos[2], workAreaPos[3]); // rect contains the available space in the whole screen not just in the monitor // containing the widget, so we intersect it with the monitor rectangle. rect.intersect(screenRect(widget)); } else rect = screenRect(widget); if (workAreaPos) XFree(workAreaPos); return rect; #else return screenRect(widget); #endif }
/* OGLCanvas::OGLCanvas * OGLCanvas class constructor, SFML implementation *******************************************************************/ OGLCanvas::OGLCanvas(wxWindow* parent, int id, bool handle_timer) : wxControl(parent, id, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE|wxWANTS_CHARS), timer(this) { init_done = false; last_time = theApp->runTimer(); if (handle_timer) timer.Start(100); // Code taken from SFML wxWidgets integration example sf::WindowHandle handle; #ifdef __WXGTK__ // GTK implementation requires to go deeper to find the // low-level X11 identifier of the widget gtk_widget_realize(m_wxwindow); gtk_widget_set_double_buffered(m_wxwindow, false); GdkWindow* Win = gtk_widget_get_window(m_wxwindow); XFlush(GDK_WINDOW_XDISPLAY(Win)); //sf::RenderWindow::Create(GDK_WINDOW_XWINDOW(Win)); handle = GDK_WINDOW_XWINDOW(Win); #else handle = GetHandle(); #endif #if SFML_VERSION_MAJOR < 2 sf::RenderWindow::Create(handle); #else // Context settings sf::ContextSettings settings; settings.depthBits = 32; settings.stencilBits = 8; sf::RenderWindow::create(handle, settings); #endif // Bind events Bind(wxEVT_PAINT, &OGLCanvas::onPaint, this); Bind(wxEVT_ERASE_BACKGROUND, &OGLCanvas::onEraseBackground, this); //Bind(wxEVT_IDLE, &OGLCanvas::onIdle, this); if (handle_timer) Bind(wxEVT_TIMER, &OGLCanvas::onTimer, this); }
static void drawPixmap(PluginInstance *This) { if (nullPluginGdkPixmap) { int pixmap_with, pixmap_height, dest_x, dest_y; gdk_drawable_get_size((GdkWindow *)nullPluginGdkPixmap, &pixmap_with, &pixmap_height); dest_x = This->width/2 - pixmap_with/2; dest_y = This->height/2 - pixmap_height/2; if (dest_x >= 0 && dest_y >= 0) { #ifdef MOZ_X11 GC gc; gc = XCreateGC(This->display, This->window, 0, NULL); XCopyArea(This->display, GDK_WINDOW_XWINDOW(nullPluginGdkPixmap) , This->window, gc, 0, 0, pixmap_with, pixmap_height, dest_x, dest_y); XFreeGC(This->display, gc); #endif } } }
void b4_handler(GtkWidget *widget) { JVMP_DrawingSurfaceInfo w; if (!jvmp_context) return; jint containerWindowID = (jint) GDK_WINDOW_XWINDOW(topLevel->window); w.window = (JPluginWindow *)containerWindowID; #ifdef XP_UNIX gdk_flush(); #endif w.x = 0; w.y = 0; w.width = topLevel->allocation.width; w.height = topLevel->allocation.height; if ((jvmp_context->JVMP_RegisterWindow)(ctx, &w, &g_wid) != JNI_TRUE) { jvmp_context->JVMP_GetLastErrorString(ctx, g_errbuf); fprintf(stderr, "Can\'t register window: %s\n", g_errbuf); return; }; fprintf(stderr, "Registed our GTK window with ID %d\n", (int)g_wid); }
static void gtk_sdl_surface_attach(GtkSDL *sdl) { gchar SDL_windowhack[32]; /* puts ("before sdl surface attach"); */ /* Attach the SDL_Surface */ /* puts ("attaching the surface"); */ sprintf(SDL_windowhack, "SDL_WINDOWID=%ld", GDK_WINDOW_XWINDOW( GTK_WIDGET(sdl)->window ) ); /* puts(SDL_windowhack); */ putenv(SDL_windowhack); SDL_QuitSubSystem(SDL_INIT_VIDEO); /* puts ("before creating new surface"); */ if ( SDL_InitSubSystem ( SDL_INIT_VIDEO ) < 0) { fprintf (stderr, "unable to init SDL: %s", SDL_GetError() ); return; } /* puts ("after creating new surface"); */ if (sdl->flags &= (SDL_OPENGLBLIT | SDL_DOUBLEBUF)) { SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); } if (sdl->surface) { /* puts ("TODO: deallocate previus surface"); */ SDL_FreeSurface(sdl->surface); } sdl->surface = SDL_SetVideoMode(sdl->width, sdl->height, sdl->bpp, sdl->flags); if (!sdl->surface) { fprintf (stderr, "Unable to set the video mode: %s", SDL_GetError() ); return; } /* puts ("after sdl surface attach"); */ }
//////////////////////////////////////////////////////////// /// Construct the wxSFMLCanvas //////////////////////////////////////////////////////////// wxSFMLCanvas::wxSFMLCanvas(wxWindow *Parent, wxWindowID Id, const wxPoint &Position, const wxSize &Size, long Style) : wxControl(Parent, Id, Position, Size, Style) { #ifdef __WXGTK__ // GTK implementation requires to go deeper to find the low-level X11 // identifier of the widget gtk_widget_realize(m_wxwindow); gtk_widget_set_double_buffered(m_wxwindow, false); GtkWidget *privHandle = m_wxwindow; wxPizza *pizza = WX_PIZZA(privHandle); GtkWidget *widget = GTK_WIDGET(pizza); // Get the internal gtk window... #if GTK_CHECK_VERSION(3, 0, 0) GdkWindow *win = gtk_widget_get_window(widget); #else GdkWindow *win = widget->window; #endif XFlush(GDK_WINDOW_XDISPLAY(win)); //...and pass it to the sf::RenderWindow. #if GTK_CHECK_VERSION(3, 0, 0) sf::RenderWindow::create(GDK_WINDOW_XID(win)); #else sf::RenderWindow::create(GDK_WINDOW_XWINDOW(win)); #endif #else // Tested under Windows XP only (should work with X11 and other Windows // versions - no idea about MacOS) sf::RenderWindow::create(static_cast<sf::WindowHandle>(GetHandle())); #endif }
static GstBusSyncReply acam_webcam_bus_sync_handler (GstBus *bus, GstMessage *message, acam_webcam_device_s *acam_webcam_device) { GstXOverlay *overlay; if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return GST_BUS_PASS; if (!gst_structure_has_name (message->structure, "prepare-xwindow-id")) return GST_BUS_PASS; overlay = GST_X_OVERLAY (GST_MESSAGE_SRC (message)); if (g_object_class_find_property (G_OBJECT_GET_CLASS (overlay), "force-aspect-ratio")) g_object_set (G_OBJECT (overlay), "force-aspect-ratio", TRUE, NULL); gst_x_overlay_set_xwindow_id (overlay, GDK_WINDOW_XWINDOW (gtk_widget_get_window (acam_webcam_device->video_screen))); gst_message_unref (message); return GST_BUS_DROP; }
void gdk_property_delete (GdkWindow *window, GdkAtom property) { g_return_if_fail (!window || GDK_IS_WINDOW (window)); if (!window) { GdkScreen *screen = gdk_screen_get_default (); window = gdk_screen_get_root_window (screen); GDK_NOTE (MULTIHEAD, g_message ("gdk_property_delete(): window is NULL\n")); } if (GDK_WINDOW_DESTROYED (window)) return; XDeleteProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XWINDOW (window), gdk_x11_atom_to_xatom_for_display (GDK_WINDOW_DISPLAY (window), property)); }
void startDaemon(int daemonPort, bool fullscreen, bool drawIntoRoot, bool disableVideo, bool disableAudio, bool vdpau, signed long xid) { if(vdpau) { LOG(INFO) << "Trying to use VDPAU"; factory.getServerTemplates().videoConvert="vdpauvideopostprocess"; factory.getServerTemplates().videoSink="vdpausink name=vpsink"; } else if(xid == -1) { if(!disableVideo) { if(!checkXvExtension()) factory.getServerTemplates().videoSink="ximagesink name=vpsink"; if(!drawIntoRoot) { GtkWidget* gtkWin = makeGtkWindow(fullscreen); xid = GDK_WINDOW_XWINDOW(gtkWin->window); } else { Display* dis = XOpenDisplay(NULL); xid = RootWindow(dis,0); } } } CapsServer server(daemonPort); while (true) { LOG(INFO) << "Waiting for incoming connection"; ClientInfo ci = server.accept(disableVideo, disableAudio); LOG(INFO) << "Accepted connection: " << ci.peerAddress; if (pipeline != NULL && pipeline->isRunning()) { pipeline->stop(); delete pipeline; } pipeline = factory.createServerPipeline(daemonPort, ci); if(!disableVideo && !vdpau) pipeline->setXwindowID(xid); pipeline->play(false); } }
static bool wxXGetWindowProperty(GdkWindow* window, Atom& type, int& format, gulong& nitems, guchar*& data) { bool success = false; #if GTK_CHECK_VERSION(2, 2, 0) if (gtk_check_version(2, 2, 0) == NULL) { gulong bytes_after; success = XGetWindowProperty( GDK_DISPLAY_XDISPLAY(gdk_drawable_get_display(window)), GDK_WINDOW_XWINDOW(window), gdk_x11_get_xatom_by_name_for_display( gdk_drawable_get_display(window), "_NET_FRAME_EXTENTS"), 0, // left, right, top, bottom, CARDINAL[4]/32 G_MAXLONG, // size of long false, // do not delete property XA_CARDINAL, // 32 bit &type, &format, &nitems, &bytes_after, &data ) == Success; } #endif return success; }
static void egg_tray_manager_set_orientation_property (EggTrayManager *manager) { #ifdef GDK_WINDOWING_X11 gulong data[1]; if (!manager->invisible || !manager->invisible->window) return; g_assert (manager->orientation_atom != None); data[0] = manager->orientation == GTK_ORIENTATION_HORIZONTAL ? SYSTEM_TRAY_ORIENTATION_HORZ : SYSTEM_TRAY_ORIENTATION_VERT; XChangeProperty (GDK_WINDOW_XDISPLAY (manager->invisible->window), GDK_WINDOW_XWINDOW (manager->invisible->window), manager->orientation_atom, XA_CARDINAL, 32, PropModeReplace, (guchar *) &data, 1); #endif }
static void set_desktop_window_id (CajaDesktopWindow *window, GdkWindow *gdkwindow) { /* Tuck the desktop windows xid in the root to indicate we own the desktop. */ Window window_xid; GdkWindow *root_window; root_window = gdk_screen_get_root_window ( gtk_window_get_screen (GTK_WINDOW (window))); #if GTK_CHECK_VERSION (3, 0, 0) window_xid = GDK_WINDOW_XID (gdkwindow); #else window_xid = GDK_WINDOW_XWINDOW (gdkwindow); #endif gdk_property_change (root_window, gdk_atom_intern ("CAJA_DESKTOP_WINDOW_ID", FALSE), gdk_x11_xatom_to_atom (XA_WINDOW), 32, GDK_PROP_MODE_REPLACE, (guchar *) &window_xid, 1); }
gboolean init_composite (void) { Display *display; display = gdk_x11_get_default_xdisplay (); // First, check the Composite extension, then the Render extension. int error_base; int event_base; int version_major; int version_minor; if (!XCompositeQueryExtension (display, &event_base, &error_base)) { return FALSE; } // We need at least version 0.2, for XCompositeNameWindowPixmap. XCompositeQueryVersion (display, &version_major, &version_minor); if (version_major <= 0 && version_minor < 2) { return FALSE; } if (!XRenderQueryExtension (display, &event_base, &error_base)) { return FALSE; } // We need at least version 0.6, for XRenderSetPictureTransform. XRenderQueryVersion (display, &version_major, &version_minor); if (version_major <= 0 && version_minor < 6) { return FALSE; } XCompositeRedirectSubwindows (display, GDK_WINDOW_XWINDOW (gdk_get_default_root_window ()), CompositeRedirectAutomatic); return TRUE; }
/* **************** basic renderer management **************** */ void pn_init (void) { int i; #ifdef FULLSCREEN_HACK char SDL_windowhack[32]; GdkScreen *screen; #endif pn_sound_data = g_new0 (struct pn_sound_data, 1); pn_image_data = g_new0 (struct pn_image_data, 1); #ifdef FULLSCREEN_HACK screen = gdk_screen_get_default(); sprintf(SDL_windowhack,"SDL_WINDOWID=%d", GDK_WINDOW_XWINDOW(gdk_screen_get_root_window(screen))); putenv(SDL_windowhack); #endif if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_NOPARACHUTE) < 0) pn_fatal_error ("Unable to initialize SDL: %s", SDL_GetError ()); #ifndef FULLSCREEN_HACK resize_video (640, 360); #else resize_video (1280, 1024); #endif SDL_WM_SetCaption ("Paranormal Visualization Studio", PACKAGE); for(i=0; i<360; i++) { sin_val[i] = sin(i*(M_PI/180.0)); cos_val[i] = cos(i*(M_PI/180.0)); } }
void OGLCanvas::createSFML() { #ifdef USE_SFML_RENDERWINDOW // Code taken from SFML wxWidgets integration example sf::WindowHandle handle; #ifdef __WXGTK__ // GTK implementation requires to go deeper to find the // low-level X11 identifier of the widget gtk_widget_realize(m_wxwindow); gtk_widget_set_double_buffered(m_wxwindow, false); GdkWindow* Win = gtk_widget_get_window(m_wxwindow); XFlush(GDK_WINDOW_XDISPLAY(Win)); // sf::RenderWindow::Create(GDK_WINDOW_XWINDOW(Win)); handle = GDK_WINDOW_XWINDOW(Win); #else handle = GetHandle(); #endif // Context settings sf::ContextSettings settings; settings.depthBits = 24; settings.stencilBits = 8; sf::RenderWindow::create(handle, settings); #endif }
void wxGLCanvas::SwapBuffers() { GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window; glXSwapBuffers( GDK_DISPLAY(), GDK_WINDOW_XWINDOW( window ) ); }
Window wxGLCanvas::GetXWindow() const { GdkWindow *window = m_wxwindow->window; return window ? GDK_WINDOW_XWINDOW(window) : 0; }
Window wxGLCanvas::GetXWindow() const { GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window; return window ? GDK_WINDOW_XWINDOW(window) : 0; }
int main (int argc, char **argv) { static const GOptionEntry options[] = { { "also-trigger-on-caps-lock", 'c', 0, G_OPTION_ARG_NONE, &also_trigger_on_caps_lock, "Make the Caps Lock key also switch windows (as well as the Super key)", NULL }, { "only-trigger-on-caps-lock", 'C', 0, G_OPTION_ARG_NONE, &only_trigger_on_caps_lock, "Make only the Caps Lock key switch windows (instead of the Super key)", NULL }, { "version", 'v', 0, G_OPTION_ARG_NONE, &show_version_and_exit, "Show the version number and exit", NULL }, #ifdef HAVE_XCOMPOSITE { "show-window-thumbnails", 't', 0, G_OPTION_ARG_NONE, &show_window_thumbnails, "EXPERIMENTAL - Show window thumbnails (instead of icons)", NULL }, #endif { NULL } }; GdkWindow *root; GOptionContext *context; GError *error; gtk_init (&argc, &argv); context = g_option_context_new (""); error = NULL; g_option_context_add_main_entries (context, options, NULL); g_option_context_parse (context, &argc, &argv, &error); if (error) { g_printerr ("%s\n", error->message); g_error_free (error); exit (ABNORMAL_EXIT_CODE_UNKNOWN_COMMAND_LINE_OPTION); } if (show_version_and_exit) { // VERSION comes from the Makefile generated by autogen.sh and configure.in. printf ("SuperSwitcher version %s\n", VERSION); return 0; } #ifdef HAVE_DBUS_GLIB // Note that this may exit(...) if another instance is already running. init_superswitcher_dbus (); #endif #ifdef HAVE_XCOMPOSITE if (show_window_thumbnails) { show_window_thumbnails = init_composite (); } #endif root = gdk_get_default_root_window (); x_root_window = GDK_WINDOW_XWINDOW (root); gdk_window_add_filter (root, filter_func, NULL); if (!only_trigger_on_caps_lock) { grab (XK_Super_L); grab (XK_Super_R); } if (also_trigger_on_caps_lock || only_trigger_on_caps_lock) { disable_caps_lock_default_behavior (); grab (XK_Caps_Lock); } screen = ss_screen_new (wnck_screen_get_default (), GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), x_root_window); gtk_main (); #ifdef HAVE_XCOMPOSITE if (show_window_thumbnails) { uninit_composite (); } #endif return 0; }
gint nsFreeTypeXImage::DrawString(nsRenderingContextGTK* aContext, nsDrawingSurfaceGTK* aSurface, nscoord aX, nscoord aY, const PRUnichar* aString, PRUint32 aLength) { #if DEBUG_SHOW_GLYPH_BOX PRUint32 x, y; // grey shows image size // red shows character cells // green box shows text ink #endif if (aLength < 1) { return 0; } // get the face/size from the FreeType cache FT_Face face = getFTFace(); NS_ASSERTION(face, "failed to get face/size"); if (!face) return 0; nsresult rslt; PRInt32 leftBearing, rightBearing, ascent, descent, width; rslt = doGetBoundingMetrics(aString, aLength, &leftBearing, &rightBearing, &ascent, &descent, &width); if (NS_FAILED(rslt)) return 0; // make sure we bring down enough background for blending rightBearing = PR_MAX(rightBearing, width+1); // offset in the ximage to the x origin PRInt32 x_origin = PR_MAX(0, -leftBearing); // offset in the ximage to the x origin PRInt32 y_origin = ascent; PRInt32 x_pos = x_origin; int image_width = x_origin + rightBearing; int image_height = y_origin + PR_MAX(descent, 0); if ((image_width<=0) || (image_height<=0)) { // if we do not have any pixels then no point in trying to draw // eg: the space char has 0 height NS_ASSERTION(width>=0, "Negative width"); return width; } Display *dpy = GDK_DISPLAY(); Drawable win = GDK_WINDOW_XWINDOW(aSurface->GetDrawable()); GC gc = GDK_GC_XGC(aContext->GetGC()); XGCValues values; if (!XGetGCValues(dpy, gc, GCForeground, &values)) { NS_ERROR("failed to get foreground pixel"); return 0; } nscolor color = nsX11AlphaBlend::PixelToNSColor(values.foreground); #if DEBUG_SHOW_GLYPH_BOX // show X/Y origin XDrawLine(dpy, win, DefaultGC(dpy, 0), aX-2, aY, aX+2, aY); XDrawLine(dpy, win, DefaultGC(dpy, 0), aX, aY-2, aX, aY+2); // show width XDrawLine(dpy, win, DefaultGC(dpy, 0), aX-x_origin, aY-y_origin-2, aX+rightBearing, aY-y_origin-2); #endif // // Get the background // XImage *sub_image = nsX11AlphaBlend::GetBackground(dpy, DefaultScreen(dpy), win, aX-x_origin, aY-y_origin, image_width, image_height); if (sub_image==nsnull) { #ifdef DEBUG int screen = DefaultScreen(dpy); // complain if the requested area is not completely off screen int win_width = DisplayWidth(dpy, screen); int win_height = DisplayHeight(dpy, screen); if (((int)(aX-leftBearing+image_width) > 0) // not hidden to left && ((int)(aX-leftBearing) < win_width) // not hidden to right && ((int)(aY-ascent+image_height) > 0)// not hidden to top && ((int)(aY-ascent) < win_height)) // not hidden to bottom { NS_ASSERTION(sub_image, "failed to get the image"); } #endif return 0; } #if DEBUG_SHOW_GLYPH_BOX DEBUG_AADRAWBOX(sub_image,0,0,image_width,image_height,0,0,0,255/4); nscolor black NS_RGB(0,255,0); blendPixel blendPixelFunc = nsX11AlphaBlend::GetBlendPixel(); // x origin for (x=0; x<(unsigned int)image_height; x++) if (x%4==0) (*blendPixelFunc)(sub_image, x_origin, x, black, 255/2); // y origin for (y=0; y<(unsigned int)image_width; y++) if (y%4==0) (*blendPixelFunc)(sub_image, y, ascent-1, black, 255/2); #endif FTC_Image_Cache icache; mFt2->GetImageCache(&icache); if (!icache) return 0; // // Get aa glyphs and blend with background // blendGlyph blendGlyph = nsX11AlphaBlend::GetBlendGlyph(); PRUint32 i, extraSurrogateLength; for (i=0; i<aLength; i+=1+extraSurrogateLength) { FT_UInt glyph_index; FT_Glyph glyph; nsresult rv; FT_BBox glyph_bbox; FT_ULong code_point = aString[i]; extraSurrogateLength = 0; if(i<aLength-1 && IS_HIGH_SURROGATE(code_point) && IS_LOW_SURROGATE(aString[i+1])) { // if surrogate, make UCS4 code point from high aString[i] surrogate and // low surrogate aString[i+1] code_point = SURROGATE_TO_UCS4(code_point, aString[i+1]); // skip aString[i+1], it is already used as low surrogate extraSurrogateLength = 1; } mFt2->GetCharIndex(face, code_point, &glyph_index); if (glyph_index) { rv = mFt2->ImageCacheLookup(icache, &mImageDesc, glyph_index, &glyph); } if ((glyph_index) && (NS_SUCCEEDED(rv))) { mFt2->GlyphGetCBox(glyph, ft_glyph_bbox_pixels, &glyph_bbox); } else { // draw an empty box for the missing glyphs GetFallbackGlyphMetrics(&glyph_bbox, face); int x, y, w = glyph_bbox.xMax, h = glyph_bbox.yMax; for (x=1; x<w; x++) { XPutPixel(sub_image, x_pos+x, ascent-1, values.foreground); XPutPixel(sub_image, x_pos+x, ascent-h, values.foreground); } for (y=1; y<h; y++) { XPutPixel(sub_image, x_pos+1, ascent-y, values.foreground); XPutPixel(sub_image, x_pos+w-1, ascent-y, values.foreground); x = (y*(w-2))/h; XPutPixel(sub_image, x_pos+x+1, ascent-y, values.foreground); } x_pos += w + 1; continue; } FT_BitmapGlyph slot = (FT_BitmapGlyph)glyph; nsAntiAliasedGlyph aaglyph(glyph_bbox.xMax-glyph_bbox.xMin, glyph_bbox.yMax-glyph_bbox.yMin, 0); PRUint8 buf[IMAGE_BUFFER_SIZE]; // try to use the stack for data if (!aaglyph.WrapFreeType(&glyph_bbox, slot, buf, IMAGE_BUFFER_SIZE)) { NS_ERROR("failed to wrap freetype image"); XDestroyImage(sub_image); return 0; } // // blend the aa-glyph onto the background // NS_ASSERTION(ascent>=glyph_bbox.yMax,"glyph too tall"); NS_ASSERTION(x_pos>=-aaglyph.GetLBearing(),"glyph extends too far to left"); #if DEBUG_SHOW_GLYPH_BOX // draw box around part of glyph that extends to the left // of the main area (negative LBearing) if (aaglyph.GetLBearing() < 0) { DEBUG_AADRAWBOX(sub_image, x_pos + aaglyph.GetLBearing(), ascent-glyph_bbox.yMax, -aaglyph.GetLBearing(), glyph_bbox.yMax, 255,0,0, 255/4); } // draw box around main glyph area DEBUG_AADRAWBOX(sub_image, x_pos, ascent-glyph_bbox.yMax, aaglyph.GetAdvance(), glyph_bbox.yMax, 0,255,0, 255/4); // draw box around part of glyph that extends to the right // of the main area (negative LBearing) if (aaglyph.GetRBearing() > (int)aaglyph.GetAdvance()) { DEBUG_AADRAWBOX(sub_image, x_pos + aaglyph.GetAdvance(), ascent-glyph_bbox.yMax, aaglyph.GetRBearing()-aaglyph.GetAdvance(), glyph_bbox.yMax, 0,0,255, 255/4); } #endif (*blendGlyph)(sub_image, &aaglyph, sLinearWeightTable, color, x_pos + aaglyph.GetLBearing(), ascent-glyph_bbox.yMax); x_pos += aaglyph.GetAdvance(); } // // Send it to the display // XPutImage(dpy, win, gc, sub_image, 0, 0, aX-x_origin , aY-ascent, image_width, image_height); XDestroyImage(sub_image); return width; }
static void _xim_init_IMdkit () { #if 0 XIMStyle ims_styles_overspot [] = { XIMPreeditPosition | XIMStatusNothing, XIMPreeditNothing | XIMStatusNothing, XIMPreeditPosition | XIMStatusCallbacks, XIMPreeditNothing | XIMStatusCallbacks, 0 }; #endif XIMStyle ims_styles_onspot [] = { XIMPreeditPosition | XIMStatusNothing, XIMPreeditCallbacks | XIMStatusNothing, XIMPreeditNothing | XIMStatusNothing, XIMPreeditPosition | XIMStatusCallbacks, XIMPreeditCallbacks | XIMStatusCallbacks, XIMPreeditNothing | XIMStatusCallbacks, 0 }; XIMEncoding ims_encodings[] = { "COMPOUND_TEXT", 0 }; GdkWindowAttr window_attr = { .title = "ibus-xim", .event_mask = GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, .wclass = GDK_INPUT_OUTPUT, .window_type = GDK_WINDOW_TOPLEVEL, .override_redirect = 1, }; XIMStyles styles; XIMEncodings encodings; GdkWindow *win; win = gdk_window_new (NULL, &window_attr, GDK_WA_TITLE); styles.count_styles = sizeof (ims_styles_onspot)/sizeof (XIMStyle) - 1; styles.supported_styles = ims_styles_onspot; encodings.count_encodings = sizeof (ims_encodings)/sizeof (XIMEncoding) - 1; encodings.supported_encodings = ims_encodings; _xims = IMOpenIM(GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), IMModifiers, "Xi18n", IMServerWindow, GDK_WINDOW_XWINDOW(win), IMServerName, _server_name != NULL ? _server_name : "ibus", IMLocale, _locale != NULL ? _locale : LOCALES_STRING, IMServerTransport, "X/", IMInputStyles, &styles, IMEncodingList, &encodings, IMProtocolHandler, ims_protocol_handler, IMFilterEventMask, KeyPressMask | KeyReleaseMask, NULL); _init_ibus (); if (!ibus_bus_is_connected (_bus)) { g_warning ("Can not connect to ibus daemon"); exit (EXIT_FAILURE); } } static void _atexit_cb () { if (_bus && ibus_bus_is_connected (_bus)) { ibus_bus_exit(_bus, False); } } static void _sighandler (int sig) { exit(EXIT_FAILURE); }
void panel_start_gui(panel *p) { ENTER; //gtk_rc_parse_string(transparent_rc); p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0); gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE); gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "trayer"); gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel"); gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_CENTER); g_signal_connect ( G_OBJECT(p->topgwin) , "delete-event" , G_CALLBACK(panel_delete_event) , p); g_signal_connect ( G_OBJECT(p->topgwin) , "destroy-event", G_CALLBACK(panel_destroy_event), p); g_signal_connect ( G_OBJECT (p->topgwin), "size-request" , G_CALLBACK(panel_size_req) , p); g_signal_connect ( G_OBJECT (p->topgwin), "size-allocate", G_CALLBACK(panel_size_alloc), p); if (p->transparent) { g_signal_connect (G_OBJECT (p->topgwin), "configure-event", G_CALLBACK(panel_configure_event), p); g_signal_connect (G_OBJECT (p->topgwin), "style-set", G_CALLBACK( panel_style_set), p); } if (p->on_primary) { GdkDisplay *display = gdk_display_get_default (); GdkScreen *screen = gdk_display_get_screen(display, 0); g_signal_connect ( screen, "monitors-changed", G_CALLBACK(panel_monitors_changed), (gpointer)p ); p->monitor = gdk_screen_get_primary_monitor(screen); } gtk_widget_realize(p->topgwin); gdk_window_set_decorations(p->topgwin->window, 0); gtk_widget_set_app_paintable(p->topgwin, TRUE); p->lbox = p->my_box_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0); gtk_container_add(GTK_CONTAINER(p->topgwin), p->lbox); gtk_widget_show(p->lbox); if (p->allign == ALLIGN_RIGHT) { GtkWidget * expander = p->my_box_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(p->lbox), expander, TRUE, TRUE, 0); gtk_widget_show(expander); } p->box = p->my_box_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(p->box), 1); gtk_box_pack_start(GTK_BOX(p->lbox), p->box, FALSE, TRUE, padding); gtk_widget_show(p->box); // get properties on topgwin p->topGdkWindow = gtk_widget_get_window(p->topgwin); p->topxwin = GDK_WINDOW_XWINDOW(GTK_WIDGET(p->topgwin)->window); bg_init(gdk_helper_display()); /* make our window unfocusable */ gdk_window_set_accept_focus(p->topGdkWindow,False); if (p->setdocktype) { gdk_window_set_type_hint(p->topGdkWindow,GDK_WINDOW_TYPE_HINT_DOCK); } Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0); /************************/ /* Window Mapping Point */ gtk_widget_show_all(p->topgwin); Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0); gdk_window_stick ( p->topGdkWindow); gdk_window_set_skip_pager_hint ( p->topGdkWindow, True ); gdk_window_set_skip_taskbar_hint ( p->topGdkWindow, True ); XSelectInput (gdk_helper_display(), GDK_ROOT_WINDOW(), PropertyChangeMask); XSelectInput (gdk_helper_display(), p->topxwin, PropertyChangeMask | FocusChangeMask | StructureNotifyMask); gdk_window_add_filter(gdk_get_default_root_window (), (GdkFilterFunc)panel_wm_events, p); calculate_position(p, distance,distancefrom); gdk_window_move_resize(p->topgwin->window, p->ax, p->ay, p->aw, p->ah); if (p->setstrut) panel_set_wm_strut(p); if (p->lower) XLowerWindow(gdk_helper_display(), p->topxwin); RET(); }
GtkWidget* gtk_xtbin_new (GtkWidget *parent_widget, String *f) { GtkXtBin *xtbin; gpointer user_data; GdkScreen *screen; GdkVisual* visual; Colormap colormap; GdkWindow* parent_window = gtk_widget_get_window(parent_widget); assert(parent_window != NULL); xtbin = g_object_new (GTK_TYPE_XTBIN, NULL); if (!xtbin) return (GtkWidget*)NULL; if (f) fallback = f; /* Initialize the Xt toolkit */ xtbin->parent_window = parent_window; screen = gtk_widget_get_screen(parent_widget); visual = gdk_screen_get_system_visual(screen); colormap = XCreateColormap(GDK_DISPLAY_XDISPLAY(gdk_screen_get_display(screen)), GDK_WINDOW_XWINDOW(gdk_screen_get_root_window(screen)), GDK_VISUAL_XVISUAL(visual), AllocNone); xt_client_init(&(xtbin->xtclient), GDK_VISUAL_XVISUAL(visual), colormap, gdk_visual_get_depth(visual)); if (!xtbin->xtclient.xtdisplay) { /* If XtOpenDisplay failed, we can't go any further. * Bail out. */ #ifdef DEBUG_XTBIN printf("gtk_xtbin_init: XtOpenDisplay() returned NULL.\n"); #endif g_free (xtbin); return (GtkWidget *)NULL; } /* If this is the first running widget, hook this display into the mainloop */ if (0 == num_widgets) { int cnumber; /* * hook Xt event loop into the glib event loop. */ /* the assumption is that gtk_init has already been called */ GSource* gs = g_source_new(&xt_event_funcs, sizeof(GSource)); if (!gs) { return NULL; } g_source_set_priority(gs, GDK_PRIORITY_EVENTS); g_source_set_can_recurse(gs, TRUE); tag = g_source_attach(gs, (GMainContext*)NULL); #ifdef VMS cnumber = XConnectionNumber(xtdisplay); #else cnumber = ConnectionNumber(xtdisplay); #endif xt_event_poll_fd.fd = cnumber; xt_event_poll_fd.events = G_IO_IN; xt_event_poll_fd.revents = 0; /* hmm... is this correct? */ g_main_context_add_poll ((GMainContext*)NULL, &xt_event_poll_fd, G_PRIORITY_LOW); /* add a timer so that we can poll and process Xt timers */ xt_polling_timer_id = g_timeout_add(25, (GSourceFunc)xt_event_polling_timer_callback, xtdisplay); } /* Bump up our usage count */ num_widgets++; /* Build the hierachy */ xtbin->xtdisplay = xtbin->xtclient.xtdisplay; gtk_widget_set_parent_window(GTK_WIDGET(xtbin), parent_window); gdk_window_get_user_data(xtbin->parent_window, &user_data); if (user_data) gtk_container_add(GTK_CONTAINER(user_data), GTK_WIDGET(xtbin)); return GTK_WIDGET (xtbin); }
GdkFilterReturn event_filter_func (GdkXEvent *gdkxevent, GdkEvent *event, gpointer data) { GdkDisplay *gdkdisplay; XEvent *xevent = gdkxevent; gulong xid = 0; Window select = 0; gdkdisplay = gdk_display_get_default (); switch (xevent->type) { case CreateNotify: { if (!wnck_window_get (xevent->xcreatewindow.window)) { GdkWindow *toplevel = create_foreign_window (xevent->xcreatewindow.window); if (toplevel) { gdk_window_set_events (toplevel, gdk_window_get_events (toplevel) | GDK_PROPERTY_CHANGE_MASK); /* check if the window is a switcher and update accordingly */ if (get_window_prop (xevent->xcreatewindow.window, select_window_atom, &select)) update_switcher_window (xevent->xcreatewindow.window, select); } } } break; case ButtonPress: case ButtonRelease: xid = (gulong) g_hash_table_lookup (frame_table, GINT_TO_POINTER (xevent->xbutton.window)); break; case EnterNotify: case LeaveNotify: xid = (gulong) g_hash_table_lookup (frame_table, GINT_TO_POINTER (xevent->xcrossing.window)); break; case MotionNotify: xid = (gulong) g_hash_table_lookup (frame_table, GINT_TO_POINTER (xevent->xmotion.window)); break; case PropertyNotify: if (xevent->xproperty.atom == frame_input_window_atom) { WnckWindow *win; xid = xevent->xproperty.window; win = wnck_window_get (xid); if (win) { Window frame; if (!get_window_prop (xid, select_window_atom, &select)) { if (get_window_prop (xid, frame_input_window_atom, &frame)) add_frame_window (win, frame, FALSE); else remove_frame_window (win); } } } if (xevent->xproperty.atom == frame_output_window_atom) { WnckWindow *win; xid = xevent->xproperty.window; win = wnck_window_get (xid); if (win) { Window frame; if (!get_window_prop (xid, select_window_atom, &select)) { if (get_window_prop (xid, frame_output_window_atom, &frame)) add_frame_window (win, frame, TRUE); else remove_frame_window (win); } } } else if (xevent->xproperty.atom == compiz_shadow_info_atom || xevent->xproperty.atom == compiz_shadow_color_atom) { GdkScreen *g_screen = gdk_display_get_default_screen (gdkdisplay); Window root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (g_screen)); WnckScreen *screen; screen = wnck_screen_get_for_root (root); if (screen) { if (gwd_process_decor_shadow_property_update ()) decorations_changed (screen); } } else if (xevent->xproperty.atom == mwm_hints_atom) { WnckWindow *win; xid = xevent->xproperty.window; win = wnck_window_get (xid); if (win) { decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); gboolean decorated = FALSE; /* Only decorations that are actually bound to windows can be decorated * ignore cases where a broken application which shouldn't be decorated * sets the decoration hint */ if (get_mwm_prop (xid) & (MWM_DECOR_ALL | MWM_DECOR_TITLE) && d->win) decorated = TRUE; if (decorated != d->decorated) { d->decorated = decorated; if (decorated) { d->context = NULL; d->width = d->height = 0; d->frame = gwd_get_decor_frame (get_frame_type (win)); update_window_decoration_state (win); update_window_decoration_actions (win); update_window_decoration_icon (win); request_update_window_decoration_size (win); update_event_windows (win); } else { remove_frame_window (win); } } } } else if (xevent->xproperty.atom == select_window_atom) { Window select; if (get_window_prop (xevent->xproperty.window, select_window_atom, &select)) update_switcher_window (xevent->xproperty.window, select); } break; case DestroyNotify: g_hash_table_remove (frame_table, GINT_TO_POINTER (xevent->xproperty.window)); break; case ClientMessage: if (xevent->xclient.message_type == toolkit_action_atom) { long action; action = xevent->xclient.data.l[0]; if (action == toolkit_action_window_menu_atom) { WnckWindow *win; win = wnck_window_get (xevent->xclient.window); if (win) { action_menu_map (win, xevent->xclient.data.l[2], xevent->xclient.data.l[1]); } } else if (action == toolkit_action_force_quit_dialog_atom) { WnckWindow *win; win = wnck_window_get (xevent->xclient.window); if (win) { if (xevent->xclient.data.l[2]) show_force_quit_dialog (win, xevent->xclient.data.l[1]); else hide_force_quit_dialog (win); } } } else if (xevent->xclient.message_type == decor_request_atom) { WnckWindow *win = wnck_window_get (xevent->xclient.window); if (win) update_window_decoration_size (win); } default: break; } if (xid) { WnckWindow *win; win = wnck_window_get (xid); if (win) { decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); if (d->decorated) { gint i, j; event_callback cb = NULL; Window w = xevent->xany.window; for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) if (d->event_windows[i][j].window == w) cb = d->event_windows[i][j].callback; if (!cb) { for (i = 0; i < BUTTON_NUM; ++i) if (d->button_windows[i].window == w) cb = d->button_windows[i].callback; } if (cb) { decor_event gtkwd_event; decor_event_type gtkwd_type; gtkwd_event.window = w; switch (xevent->type) { case ButtonPress: case ButtonRelease: if (xevent->type == ButtonPress) gtkwd_type = GButtonPress; else gtkwd_type = GButtonRelease; gtkwd_event.button = xevent->xbutton.button; gtkwd_event.x = xevent->xbutton.x; gtkwd_event.y = xevent->xbutton.y; gtkwd_event.x_root = xevent->xbutton.x_root; gtkwd_event.y_root = xevent->xbutton.y_root; gtkwd_event.time = xevent->xbutton.time; break; case EnterNotify: case LeaveNotify: if (xevent->type == EnterNotify) gtkwd_type = GEnterNotify; else gtkwd_type = GLeaveNotify; gtkwd_event.x = xevent->xcrossing.x; gtkwd_event.y = xevent->xcrossing.y; gtkwd_event.x_root = xevent->xcrossing.x_root; gtkwd_event.y_root = xevent->xcrossing.y_root; gtkwd_event.time = xevent->xcrossing.time; break; default: cb = NULL; break; } if (cb) (*cb) (win, >kwd_event, gtkwd_type); } } } } return GDK_FILTER_CONTINUE; }
void wxOgre::createOgreRenderWindow() { // See if an Ogre::Root already exists mRoot = Ogre::Root::getSingletonPtr(); mRenderWindow = mRoot->initialise(false); // -------------------- // Create a new parameters list according to compiled OS Ogre::NameValuePairList params; Ogre::String handle; #ifdef __WXMSW__ handle = Ogre::StringConverter::toString((size_t)((HWND)GetHandle())); params["externalWindowHandle"] = handle; #elif defined(__WXGTK__) SetBackgroundStyle(wxBG_STYLE_CUSTOM); GtkWidget* privHandle = GetHandle(); // prevents flickering gtk_widget_set_double_buffered(privHandle, FALSE); // this doesn't work w. Ogre 1.6.1 maybe this will fix it? gtk_widget_realize(privHandle); // grab the window object GdkWindow* gdkWin = GTK_PIZZA(privHandle)->bin_window; Display* display = GDK_WINDOW_XDISPLAY(gdkWin); Window wid = GDK_WINDOW_XWINDOW(gdkWin); XSync(display,wid); std::stringstream str; // display str << (unsigned long)display << ':'; // screen (returns "display.screen") std::string screenStr = DisplayString(display); std::string::size_type dotPos = screenStr.find("."); screenStr = screenStr.substr(dotPos+1, screenStr.size()); str << screenStr << ':'; // XID str << wid << ':'; // retrieve XVisualInfo int attrlist[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, None }; XVisualInfo* vi = glXChooseVisual(display, DefaultScreen(display), attrlist); str << (unsigned long)vi; handle = str.str(); #else #error Not supported on this platform. #endif // Get wx control window size int width; int height; GetSize(&width, &height); // Create the render window mRenderWindow = Ogre::Root::getSingleton().createRenderWindow("OgreRenderWindow", width, height, false, ¶ms); // line is required, otherwise the screen does not update mRenderWindow->setActive(true); // -------------------- // Create the SceneManager, in this case a generic one mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "ExampleSMInstance"); mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f)); // -------------------- // Create the camera mCamera = mSceneMgr->createCamera("EntityCamera"); // Set up the SceneNodes to control the camera mCameraNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); mCameraNode->attachObject(mCamera); mCamera->setNearClipDistance(0.1); // Set the viewport mViewPort = mRenderWindow->addViewport(mCamera); // Set the background to match the wxWindow background color mViewPort->setBackgroundColour(Ogre::ColourValue(212.0f/255.0f, 208.0f/255.0f, 200.0f/255.0f, 1.0f)); //mLightNode = mCameraNode->createChildSceneNode(); mXLight = mSceneMgr->createLight("XLight"); mXLight->setType(Ogre::Light::LT_DIRECTIONAL); mXLight->setDiffuseColour(1.0f, 1.0f,1.0f); mXLight->setDirection(-1.0f, 0.0f, 0.0f); mYLight = mSceneMgr->createLight("YLight"); mYLight->setType(Ogre::Light::LT_DIRECTIONAL); mYLight->setDiffuseColour(1.0f, 1.0f,1.0f); mYLight->setDirection(0.0f, -1.0f, 0.0f); mZLight = mSceneMgr->createLight("ZLight"); mZLight->setType(Ogre::Light::LT_DIRECTIONAL); mZLight->setDiffuseColour(1.0f, 1.0f,1.0f); mZLight->setDirection(0.0f, 0.0f, -1.0f); }
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); }
static gboolean na_tray_manager_manage_screen_x11 (NaTrayManager *manager, GdkScreen *screen) { GdkDisplay *display; Screen *xscreen; GtkWidget *invisible; char *selection_atom_name; guint32 timestamp; g_return_val_if_fail (NA_IS_TRAY_MANAGER (manager), FALSE); g_return_val_if_fail (manager->screen == NULL, FALSE); /* If there's already a manager running on the screen * we can't create another one. */ #if 0 if (na_tray_manager_check_running_screen_x11 (screen)) return FALSE; #endif manager->screen = screen; display = gdk_screen_get_display (screen); xscreen = GDK_SCREEN_XSCREEN (screen); invisible = gtk_invisible_new_for_screen (screen); gtk_widget_realize (invisible); gtk_widget_add_events (invisible, GDK_PROPERTY_CHANGE_MASK | GDK_STRUCTURE_MASK); selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d", gdk_screen_get_number (screen)); manager->selection_atom = gdk_atom_intern (selection_atom_name, FALSE); g_free (selection_atom_name); manager->invisible = invisible; g_object_ref (G_OBJECT (manager->invisible)); na_tray_manager_set_orientation_property (manager); na_tray_manager_set_visual_property (manager); timestamp = gdk_x11_get_server_time (invisible->window); /* Check if we could set the selection owner successfully */ if (gdk_selection_owner_set_for_display (display, invisible->window, manager->selection_atom, timestamp, TRUE)) { XClientMessageEvent xev; GdkAtom opcode_atom; GdkAtom message_data_atom; xev.type = ClientMessage; xev.window = RootWindowOfScreen (xscreen); xev.message_type = gdk_x11_get_xatom_by_name_for_display (display, "MANAGER"); xev.format = 32; xev.data.l[0] = timestamp; xev.data.l[1] = gdk_x11_atom_to_xatom_for_display (display, manager->selection_atom); xev.data.l[2] = GDK_WINDOW_XWINDOW (invisible->window); xev.data.l[3] = 0; /* manager specific data */ xev.data.l[4] = 0; /* manager specific data */ XSendEvent (GDK_DISPLAY_XDISPLAY (display), RootWindowOfScreen (xscreen), False, StructureNotifyMask, (XEvent *)&xev); opcode_atom = gdk_atom_intern ("_NET_SYSTEM_TRAY_OPCODE", FALSE); manager->opcode_atom = gdk_x11_atom_to_xatom_for_display (display, opcode_atom); message_data_atom = gdk_atom_intern ("_NET_SYSTEM_TRAY_MESSAGE_DATA", FALSE); /* Add a window filter */ #if 0 /* This is for when we lose the selection of _NET_SYSTEM_TRAY_Sx */ g_signal_connect (invisible, "selection-clear-event", G_CALLBACK (na_tray_manager_selection_clear_event), manager); #endif /* This is for SYSTEM_TRAY_REQUEST_DOCK and SelectionClear */ gdk_window_add_filter (invisible->window, na_tray_manager_window_filter, manager); /* This is for SYSTEM_TRAY_BEGIN_MESSAGE and SYSTEM_TRAY_CANCEL_MESSAGE */ gdk_display_add_client_message_filter (display, opcode_atom, na_tray_manager_handle_client_message_opcode, manager); /* This is for _NET_SYSTEM_TRAY_MESSAGE_DATA */ gdk_display_add_client_message_filter (display, message_data_atom, na_tray_manager_handle_client_message_message_data, manager); return TRUE; } else { gtk_widget_destroy (invisible); g_object_unref (invisible); manager->invisible = NULL; manager->screen = NULL; return FALSE; } }
void panel_start_gui(panel *p) { Atom state[3]; XWMHints wmhints; guint32 val; ENTER; // main toplevel window p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0); gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE); gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel"); gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel"); gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE); gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE); g_signal_connect(G_OBJECT(p->topgwin), "delete-event", G_CALLBACK(panel_delete_event), p); g_signal_connect(G_OBJECT(p->topgwin), "destroy-event", G_CALLBACK(panel_destroy_event), p); g_signal_connect (G_OBJECT (p->topgwin), "size-request", (GCallback) panel_size_req, p); g_signal_connect (G_OBJECT (p->topgwin), "size-allocate", (GCallback) panel_size_alloc, p); g_signal_connect (G_OBJECT (p->topgwin), "configure-event", (GCallback) panel_configure_event, p); g_signal_connect (G_OBJECT (p->topgwin), "realize", (GCallback) panel_realize, p); g_signal_connect (G_OBJECT (p->topgwin), "style-set", (GCallback) panel_style_set, p); gtk_widget_realize(p->topgwin); //gdk_window_set_decorations(p->topgwin->window, 0); gtk_widget_set_app_paintable(p->topgwin, TRUE); // background box all over toplevel p->bbox = gtk_bgbox_new(); gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox); gtk_widget_show(p->bbox); gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0); if (p->transparent) { p->bg = fb_bg_get_for_display(); gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha); } // main layout manager as a single child of background widget box p->lbox = p->my_box_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0); gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox); gtk_widget_show(p->lbox); if (p->round_corners) make_round_corners(p); p->box = p->my_box_new(FALSE, p->spacing); gtk_container_set_border_width(GTK_CONTAINER(p->box), 0); gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE, 0); gtk_widget_show(p->box); p->topxwin = GDK_WINDOW_XWINDOW(GTK_WIDGET(p->topgwin)->window); DBG("topxwin = %x\n", p->topxwin); /* the settings that should be done before window is mapped */ wmhints.flags = InputHint; wmhints.input = 0; XSetWMHints (GDK_DISPLAY(), p->topxwin, &wmhints); #define WIN_HINTS_SKIP_FOCUS (1<<0) /* "alt-tab" skips this win */ val = WIN_HINTS_SKIP_FOCUS; XChangeProperty(GDK_DISPLAY(), p->topxwin, XInternAtom(GDK_DISPLAY(), "_WIN_HINTS", False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &val, 1); if (p->setdocktype) { state[0] = a_NET_WM_WINDOW_TYPE_DOCK; XChangeProperty(GDK_DISPLAY(), p->topxwin, a_NET_WM_WINDOW_TYPE, XA_ATOM, 32, PropModeReplace, (unsigned char *) state, 1); } /* window mapping point */ gtk_widget_show_all(p->topgwin); /* the settings that should be done after window is mapped */ /* send it to running wm */ Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0); /* and assign it ourself just for case when wm is not running */ val = 0xFFFFFFFF; XChangeProperty(GDK_DISPLAY(), p->topxwin, a_NET_WM_DESKTOP, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &val, 1); state[0] = a_NET_WM_STATE_SKIP_PAGER; state[1] = a_NET_WM_STATE_SKIP_TASKBAR; state[2] = a_NET_WM_STATE_STICKY; XChangeProperty(GDK_DISPLAY(), p->topxwin, a_NET_WM_STATE, XA_ATOM, 32, PropModeReplace, (unsigned char *) state, 3); XSelectInput (GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask); gdk_window_add_filter(gdk_get_default_root_window (), (GdkFilterFunc)panel_event_filter, p); calculate_position(p); gdk_window_move_resize(p->topgwin->window, p->ax, p->ay, p->aw, p->ah); if (p->setstrut) panel_set_wm_strut(p); RET(); }