static gboolean empathy_video_widget_expose_event (GtkWidget *widget, GdkEventExpose *event) { EmpathyVideoWidget *self = EMPATHY_VIDEO_WIDGET (widget); EmpathyVideoWidgetPriv *priv = GET_PRIV (self); if (event != NULL && event->count > 0) return TRUE; if (priv->overlay == NULL) return TRUE; gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay), GDK_WINDOW_XID (widget->window)); gst_x_overlay_expose (GST_X_OVERLAY (priv->overlay)); return TRUE; }
void gdk_x11_window_force_focus (GdkWindow *window, guint32 timestamp) { GdkDisplay *display; g_return_if_fail (GDK_IS_WINDOW (window)); display = GDK_WINDOW_DISPLAY (window); if (GTK_CHECK_VERSION(3,0,0) && !GDK_IS_X11_DISPLAY (display)) return; if (gdk_x11_screen_supports_net_wm_hint (gdk_window_get_screen (window), gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW"))) { if (!timestamp) { GTimeVal t; g_get_current_time (&t); timestamp = t.tv_sec; } XClientMessageEvent xclient; memset (&xclient, 0, sizeof (xclient)); xclient.type = ClientMessage; xclient.window = GDK_WINDOW_XID (window); xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_NET_ACTIVE_WINDOW"); xclient.format = 32; xclient.data.l[0] = 2; /* requestor type; we're a tool */ xclient.data.l[1] = timestamp; xclient.data.l[2] = None; /* currently active window */ xclient.data.l[3] = 0; xclient.data.l[4] = 0; XSendEvent (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XROOTWIN (window), False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent *)&xclient); } }
//----------------------------------------- // based on code contributed by pclouds //----------------------------------------- static GdkFilterReturn gtk_im_context_vn_event_filter (GdkXEvent *xevent, GdkEvent *event, gpointer data) { XPropertyEvent *ev = (XPropertyEvent*)xevent; long v; GdkWindow *gdkroot = gdk_get_default_root_window(); Window root = GDK_WINDOW_XID(gdkroot); if (!ev || ev->type != PropertyNotify || ev->window != root) return GDK_FILTER_CONTINUE; if (ev->atom == AIMCharset) { v = UkGetPropValue(ev->atom, VKC_UTF8); GlobalOpt.charset = SyncToUnikeyCharset(v); UnikeySetOutputCharset(GlobalOpt.charset); /* if (UkMacroLoaded) UkUpdateMacroTable(GlobalOpt.charset); */ return GDK_FILTER_REMOVE; } else if (ev->atom == AIMMethod) { fixSyncToUnikeyMethod(); if (GlobalOpt.enabled) UnikeySetInputMethod(GlobalOpt.inputMethod); return GDK_FILTER_REMOVE; } else if (ev->atom == AIMUsing) { //dont' need this return GDK_FILTER_REMOVE; } else if (ev->atom == AGUIVisible) { UkGUIVisible = UkGetPropValue(AGUIVisible, 0); } return GDK_FILTER_CONTINUE; }
static void ungrab_mmkey (int key_code, GdkWindow *root) { Display *display; gdk_error_trap_push (); display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()); XUngrabKey (display, key_code, 0, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, Mod2Mask, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, Mod5Mask, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, LockMask, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, Mod2Mask | Mod5Mask, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, Mod2Mask | LockMask, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, Mod5Mask | LockMask, GDK_WINDOW_XID (root)); XUngrabKey (display, key_code, Mod2Mask | Mod5Mask | LockMask, GDK_WINDOW_XID (root)); gdk_flush (); if (gdk_error_trap_pop ()) { rb_debug ("Error grabbing key"); } }
//================================================================ int GLB_DrawInit (void *widget) { //================================================================ /// GLB_DrawInit start OpenGL-commandblock GdkWindow *window; if(!GLB_x_id) { window = gtk_widget_get_window (widget); GLB_x_id = GDK_WINDOW_XID(window); // causes expose! printf(" GLB_x_id=%d\n",GLB_x_id); } // GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE); glXMakeCurrent (GLB_display, GLB_x_id, GLB_x_context); return 0; }
static void uninstall_keygrab(void) { GdkDisplay *display = gdk_display_get_default(); int i; for (i = 0; i < gdk_display_get_n_screens (display); i++) { GdkScreen *screen; GdkWindow *root; screen = gdk_display_get_screen (display, i); if (!screen) { continue; } root = gdk_screen_get_root_window (screen); XUngrabKey(GDK_DISPLAY(), AnyKey, AnyModifier, GDK_WINDOW_XID(root)); } }
void GTKVideo::realize_cb(GtkWidget *widget, void *user_data) { GTKVideo *context = static_cast<GTKVideo *>(user_data); GdkWindow *window = gtk_widget_get_window(widget); if (!gdk_window_ensure_native(window)) g_debug("Couldn't create native window needed for GstXOverlay!"); gdk_threads_enter(); gdk_display_sync(context->display_); // gdk_error_trap_pop (); /* Retrieve window handler from GDK */ #if defined(GDK_WINDOWING_WIN32) context->window_handle_ = reinterpret_cast<guintptr>(GDK_WINDOW_HWND(window)); #elif defined(GDK_WINDOWING_QUARTZ) context->window_handle_ = gdk_quartz_window_get_nsview(window); #elif defined(GDK_WINDOWING_X11) context->window_handle_ = GDK_WINDOW_XID(window); #endif gdk_threads_leave(); std::unique_lock<std::mutex> lock(context->wait_window_mutex_); context->wait_window_cond_.notify_all(); }
void gtku_gl_drawing_area_swap_buffers (GtkuGLDrawingArea * self) { GtkWidget * widget = GTK_WIDGET (self); GtkuGLDrawingAreaPrivate * priv = GTKU_GL_DRAWING_AREA_GET_PRIVATE (self); #ifdef USE_VBLANK if (priv->vblank_watch) { /* If we are syncing to vblank, we just set a flag that a * swap is desired. */ priv->swap_requested = 1; return; } #endif /* If we can't monitor vblank, we swap immediately. */ if (!GTK_WIDGET_REALIZED (widget) || !priv->dpy) return; glXSwapBuffers (priv->dpy, GDK_WINDOW_XID (widget->window)); }
Ogre::String getWindowHandleString(GtkWidget *widget) { Ogre::String handle; // GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED); gtk_widget_realize(widget); GdkWindow *parent = gtk_widget_get_parent_window(widget); // gdk_window_show(parent); #if defined(__WIN32__) || defined(_WIN32) handle = Ogre::StringConverter::toString((unsigned long) GDK_WINDOW_HWND(parent)); #else // #elif defined(__WXGTK__) GdkDisplay* display = gdk_drawable_get_display(GDK_DRAWABLE(parent)); Display *xdisplay = GDK_DISPLAY_XDISPLAY(display); XSync(xdisplay, false); GdkScreen* screen = gdk_drawable_get_screen(GDK_DRAWABLE(parent)); Screen *xscreen = GDK_SCREEN_XSCREEN(screen); int screen_number = XScreenNumberOfScreen(xscreen); // XID xid_parent = GDK_WINDOW_XWINDOW(parent); // "parentWindowHandle" // handle = // Ogre::StringConverter::toString(reinterpret_cast<unsigned long>(xdisplay)) + ":" + // Ogre::StringConverter::toString(static_cast<unsigned int>(screen_number)) + ":" + // Ogre::StringConverter::toString(static_cast<unsigned long>(xid_parent)); handle = Ogre::StringConverter::toString(static_cast<unsigned long>(GDK_WINDOW_XID(parent))); #endif // dunno what MacOS needs - you tell me return handle; }
/* The plug window should completely occupy the area of the child, so we won't * get a draw event. But in case we do (the plug unmaps itself, say), this * draw handler draws with real or fake transparency. */ static gboolean na_tray_child_draw (GtkWidget *widget, cairo_t *cr) { NaTrayChild *child = NA_TRAY_CHILD (widget); if (na_tray_child_has_alpha (child)) { /* Clear to transparent */ cairo_set_source_rgba (cr, 0, 0, 0, 0); cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); cairo_paint (cr); } else if (child->parent_relative_bg) { GdkWindow *window; cairo_surface_t *target; GdkRectangle clip_rect; window = gtk_widget_get_window (widget); target = cairo_get_group_target (cr); gdk_cairo_get_clip_rectangle (cr, &clip_rect); /* Clear to parent-relative pixmap * We need to use direct X access here because GDK doesn't know about * the parent relative pixmap. */ cairo_surface_flush (target); XClearArea (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window), clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height, False); cairo_surface_mark_dirty_rectangle (target, clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height); } return FALSE; }
static gboolean on_draw(GtkWidget* w, cairo_t* cr, gpointer data) { g_debug("%s", __func__); if (ctx == 0 || glxwin == 0 || glx_pm == 0) return TRUE; glXMakeContextCurrent(display, glxwin, glxwin, ctx); glViewport (0, 0, g_width, g_height); GdkWindow* gdkwin = gtk_widget_get_window(w); XWindowAttributes gwa; XGetWindowAttributes(display, GDK_WINDOW_XID(gdkwin), &gwa); glViewport(0, 0, gwa.width, gwa.height); glClearColor(1.0, 1.0, 1.0, 1.0); glClear(GL_COLOR_BUFFER_BIT); glEnable(GL_TEXTURE_2D); GLuint texture; glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); glXBindTexImageEXT(display, glx_pm, GLX_FRONT_EXT, NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(-1.0, 1.0, 0.0); glTexCoord2f(1.0, 0.0); glVertex3f( 1.0, 1.0, 0.0); glTexCoord2f(1.0, 1.0); glVertex3f( 1.0, -1.0, 0.0); glTexCoord2f(0.0, 1.0); glVertex3f(-1.0, -1.0, 0.0); glEnd(); if (dbuffered) glXSwapBuffers(display, glxwin); else glFlush(); /*glXMakeCurrent(display, 0, 0);*/ return TRUE; }
/** * unique_backend_get_workspace: * @backend: a #UniqueBackend * * Retrieves the current workspace. * * Return value: a workspace number */ guint unique_backend_get_workspace (UniqueBackend *backend) { GdkDisplay *display; GdkWindow *root_win; #ifdef GDK_WINDOWING_X11 Atom _net_current_desktop, type; int format; unsigned long n_items, bytes_after; unsigned char *data_return = 0; #endif g_return_val_if_fail (UNIQUE_IS_BACKEND (backend), 0); if (backend->workspace != -1) return backend->workspace; display = gdk_screen_get_display (backend->screen); root_win = gdk_screen_get_root_window (backend->screen); #ifdef GDK_WINDOWING_X11 _net_current_desktop = gdk_x11_get_xatom_by_name_for_display (display, "_NET_CURRENT_DESKTOP"); XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (root_win), _net_current_desktop, 0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &n_items, &bytes_after, &data_return); if (type == XA_CARDINAL && format == 32 && n_items > 0) { backend->workspace = (guint) data_return[0]; XFree (data_return); } #endif return backend->workspace; }
/** * gedit_utils_get_window_workspace: Get the workspace the window is on * * This function gets the workspace that the #GtkWindow is visible on, * it returns GEDIT_ALL_WORKSPACES if the window is sticky, or if * the window manager doesn support this function */ guint gedit_utils_get_window_workspace (GtkWindow *gtkwindow) { #ifdef GDK_WINDOWING_X11 GdkWindow *window; GdkDisplay *display; Atom type; gint format; gulong nitems; gulong bytes_after; guint *workspace; gint err, result; guint ret = GEDIT_ALL_WORKSPACES; g_return_val_if_fail (GTK_IS_WINDOW (gtkwindow), 0); g_return_val_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET (gtkwindow)), 0); window = gtk_widget_get_window (GTK_WIDGET (gtkwindow)); display = gdk_drawable_get_display (window); gdk_error_trap_push (); result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window), gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP"), 0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems, &bytes_after, (gpointer) &workspace); err = gdk_error_trap_pop (); if (err != Success || result != Success) return ret; if (type == XA_CARDINAL && format == 32 && nitems > 0) ret = workspace[0]; XFree (workspace); return ret; #else /* FIXME: on mac etc proably there are native APIs * to get the current workspace etc */ return 0; #endif }
static void empathy_video_widget_sync_message_cb (GstBus *bus, GstMessage *message, EmpathyVideoWidget *self) { EmpathyVideoWidgetPriv *priv = GET_PRIV (self); const GstStructure *s; if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) return; if (GST_MESSAGE_SRC (message) != (GstObject *) priv->overlay) return; s = gst_message_get_structure (message); if (gst_structure_has_name (s, "prepare-xwindow-id")) { gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (priv->overlay), GDK_WINDOW_XID (GTK_WIDGET (self)->window)); } }
void qtcWindowStatusBarDBus(GtkWidget *widget, gboolean state) { GtkWindow *topLevel = GTK_WINDOW(gtk_widget_get_toplevel(widget)); unsigned int xid = GDK_WINDOW_XID(gtk_widget_get_window(GTK_WIDGET(topLevel))); char cmd[160]; //sprintf(cmd, "qdbus org.kde.kwin /QtCurve statusBarState %u %s", xid, state ? "true" : "false"); sprintf(cmd, "dbus-send --type=method_call --session --dest=org.kde.kwin /QtCurve org.kde.QtCurve.statusBarState uint32:%u boolean:%s", xid, state ? "true" : "false"); system(cmd); /* char xidS[16], stateS[6]; char *args[]={"qdbus", "org.kde.kwin", "/QtCurve", "statusBarState", xidS, stateS, NULL}; sprintf(xidS, "%u", xid); sprintf(stateS, "%s", state ? "true" : "false"); g_spawn_async("/tmp", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL); */ }
void qtcWindowMenuBarDBus(GtkWidget *widget, int size) { GtkWindow *topLevel = GTK_WINDOW(gtk_widget_get_toplevel(widget)); unsigned int xid = GDK_WINDOW_XID(gtk_widget_get_window(GTK_WIDGET(topLevel))); char cmd[160]; //sprintf(cmd, "qdbus org.kde.kwin /QtCurve menuBarSize %u %d", xid, size); sprintf(cmd, "dbus-send --type=method_call --session --dest=org.kde.kwin /QtCurve org.kde.QtCurve.menuBarSize uint32:%u int32:%d", xid, size); system(cmd); /* char xidS[16], sizeS[16]; char *args[]={"qdbus", "org.kde.kwin", "/QtCurve", "menuBarSize", xidS, sizeS, NULL}; sprintf(xidS, "%u", xid); sprintf(sizeS, "%d", size); g_spawn_async("/tmp", args, NULL, (GSpawnFlags)0, NULL, NULL, NULL, NULL); */ }
static void on_realize (GtkWidget *dialog, gpointer data) { Window xid; xid = (Window) GPOINTER_TO_INT (data); #if GTK_CHECK_VERSION(3, 22, 0) gdk_x11_display_error_trap_push (gtk_widget_get_display (dialog)); #else gdk_error_trap_push (); #endif XSetTransientForHint (gdk_x11_get_default_xdisplay (), GDK_WINDOW_XID (gtk_widget_get_window (dialog)), xid); #if GTK_CHECK_VERSION(3, 22, 0) gdk_x11_display_error_trap_pop_ignored (gtk_widget_get_display (dialog)); #else gdk_error_trap_pop_ignored (); #endif }
/** * @brief * @param ui The GstSwitchUI instance. * @param view * @param handle * @param port * @memberof GstSwitchUI */ static GstAudioVisual * gst_switch_ui_new_audio_visual_unsafe (GstSwitchUI * ui, GtkWidget * view, gulong handle, gint port) { gchar *name = g_strdup_printf ("visual-%d", port); GstAudioVisual *visual; if (view && handle == 0) { GdkWindow *xview = gtk_widget_get_window (view); handle = GDK_WINDOW_XID (xview); } visual = GST_AUDIO_VISUAL (g_object_new (GST_TYPE_AUDIO_VISUAL, "name", name, "port", port, "handle", handle, "active", (ui->audio_port == port), NULL)); g_free (name); if (!gst_worker_start (GST_WORKER (visual))) ERROR ("failed to start audio visual"); return visual; }
void panel_warp_pointer (GdkWindow *gdk_window, int x, int y) { Display *display; Window window; g_return_if_fail (GDK_IS_WINDOW (gdk_window)); display = GDK_WINDOW_XDISPLAY (gdk_window); window = GDK_WINDOW_XID (gdk_window); gdk_error_trap_push (); XWarpPointer (display, None, window, 0, 0, 0, 0, x, y); #if GTK_CHECK_VERSION (3, 0, 0) gdk_error_trap_pop_ignored (); #else gdk_error_trap_pop (); #endif }
static void draw_background (GnomeBGCrossfade *fade) { if (gdk_window_get_window_type (fade->priv->window) == GDK_WINDOW_ROOT) { gdk_error_trap_push (); XClearArea (GDK_WINDOW_XDISPLAY (fade->priv->window), GDK_WINDOW_XID (fade->priv->window), 0, 0, gdk_window_get_width (fade->priv->window), gdk_window_get_height (fade->priv->window), False); send_root_property_change_notification (fade); gdk_flush (); gdk_error_trap_pop (); // ignore errors } else { gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE); gdk_window_process_updates (fade->priv->window, FALSE); } }
//////////////////////////////////////////////////////////// /// 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 }
/** * gedit_utils_get_current_workspace: Get the current workspace * * Get the currently visible workspace for the #GdkScreen. * * If the X11 window property isn't found, 0 (the first workspace) * is returned. */ guint gedit_utils_get_current_workspace (GdkScreen *screen) { #ifdef GDK_WINDOWING_X11 GdkWindow *root_win; GdkDisplay *display; Atom type; gint format; gulong nitems; gulong bytes_after; guint *current_desktop; gint err, result; guint ret = 0; g_return_val_if_fail (GDK_IS_SCREEN (screen), 0); root_win = gdk_screen_get_root_window (screen); display = gdk_screen_get_display (screen); gdk_error_trap_push (); result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (root_win), gdk_x11_get_xatom_by_name_for_display (display, "_NET_CURRENT_DESKTOP"), 0, G_MAXLONG, False, XA_CARDINAL, &type, &format, &nitems, &bytes_after, (gpointer) ¤t_desktop); err = gdk_error_trap_pop (); if (err != Success || result != Success) return ret; if (type == XA_CARDINAL && format == 32 && nitems > 0) ret = current_desktop[0]; XFree (current_desktop); return ret; #else /* FIXME: on mac etc proably there are native APIs * to get the current workspace etc */ return 0; #endif }
static int gs_grab_get_mouse (GSGrab *grab, GdkWindow *window, GdkScreen *screen, gboolean hide_cursor) { GdkGrabStatus status; GdkCursor *cursor; g_return_val_if_fail (window != NULL, FALSE); g_return_val_if_fail (screen != NULL, FALSE); cursor = get_cursor (); gs_debug ("Grabbing mouse widget=%X", (guint32) GDK_WINDOW_XID (window)); status = gdk_pointer_grab (window, TRUE, 0, NULL, (hide_cursor ? cursor : NULL), GDK_CURRENT_TIME); if (status == GDK_GRAB_SUCCESS) { if (grab->priv->mouse_grab_window != NULL) { g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), (gpointer *) &grab->priv->mouse_grab_window); } grab->priv->mouse_grab_window = window; g_object_add_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), (gpointer *) &grab->priv->mouse_grab_window); grab->priv->mouse_grab_screen = screen; grab->priv->mouse_hide_cursor = hide_cursor; } gdk_cursor_unref (cursor); return status; }
// MUST be called from the GTK main thread; calling it in OnRealized will do the right thing. P_INVOKE void bp_video_window_realize (BansheePlayer *player, GdkWindow *window) { g_return_if_fail (IS_BANSHEE_PLAYER (player)); // Code commented out - this requires including gtk/gtk.h for GTK_CHECK_VERSION, which requires too many // buildsystem changes for the benefit of a single debug message in the failure case. // //#if GTK_CHECK_VERSION(2,18,0) // //Explicitly create the native window. GDK_WINDOW_XWINDOW will call this // //function anyway, but this way we can raise a more useful message should it fail. // if (!gdk_window_ensure_native (window)) { // banshee_log (BANSHEE_LOG_TYPE_ERROR, "player-video", "Couldn't create native window needed for GstXOverlay!"); // } //#endif #if defined(GDK_WINDOWING_X11) player->video_window_xid = GDK_WINDOW_XID (window); #elif defined (GDK_WINDOWING_WIN32) player->video_window_xid = GDK_WINDOW_HWND (window); #endif }
static gboolean on_ref_configure(GtkWidget *widget, GdkEvent *event, gpointer user_data) { g_debug("%s", __func__); GdkEventConfigure *gec = (GdkEventConfigure*)event; g_width = gec->width; g_height = gec->height; gtk_window_resize(GTK_WINDOW(top), g_width, g_height); if (!gtk_widget_get_mapped(ref)) return TRUE; if (back_pixmap) { glXDestroyPixmap(display, glx_pm); XFreePixmap(display, back_pixmap); GdkWindow* gdkwin = gtk_widget_get_window(ref); back_pixmap = XCompositeNameWindowPixmap(display, GDK_WINDOW_XID(gdkwin)); glx_pm = glXCreatePixmap(display, bestFbc, back_pixmap, pixmap_attribs); } return TRUE; }
void Player_ControlsGUI::on_playbutton_pressed(){ // The UI changes :) m_playbutton.set_sensitive(false); m_pausebutton.set_sensitive(); m_previousbutton.set_sensitive(); m_nextbutton.set_sensitive(); m_openbutton.set_sensitive(false); m_stopbutton.set_sensitive(); m_playbutton.hide(); m_pausebutton.show(); // then call up the list // and place the uri into the engine //engine.get_File(list.find_item(index)); //then engage the play state media_uri = list.find_item(index); std::cout<< "Test for linked list out put !!!"<<std::endl; std::cout<< media_uri<<std::endl; //engine.get_File("/home/william/Videos/season 1/Hunter X Hunter 2011 Episode 1.flv"); //engine.set_winID(player_window_id); //engine.stopState(); engine.get_File(media_uri); engine.set_winID(GDK_WINDOW_XID(video_area.get_window()->gobj())); set_screen_resize(640,480); //data = engine.report(); engine.playState(); // clear the string after use index++; m_timeout_connection = Glib::signal_timeout().connect( sigc::mem_fun(*this, &Player_ControlsGUI::update), 200); }
gboolean qtcMenuEmitSize(GtkWidget *w, unsigned int size) { if (w) { QTC_DEF_WIDGET_PROPS(props, w); unsigned oldSize = qtcWidgetProps(props)->menuBarSize; if (oldSize != size) { GtkWidget *topLevel = gtk_widget_get_toplevel(w); xcb_window_t wid = GDK_WINDOW_XID(gtk_widget_get_window(GTK_WIDGET(topLevel))); if (size == 0xFFFF) { size = 0; } qtcWidgetProps(props)->menuBarSize = size; qtcX11SetMenubarSize(wid, size); return true; } } return false; }
static void _title_do(Title * title) { unsigned long cnt = 0; Window * window; char * name; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if(_title_get_window_property(title, GDK_WINDOW_XID(title->root), title->atom_active, XA_WINDOW, &cnt, (void*)&window) != 0 || cnt != 1) { gtk_label_set_text(GTK_LABEL(title->widget), ""); return; } name = _do_name(title, *window); XFree(window); gtk_label_set_text(GTK_LABEL(title->widget), (name != NULL) ? name : ""); free(name); }
static gint luaH_window_index(lua_State *L, luapdf_token_t token) { widget_t *w = luaH_checkwidget(L, 1); switch(token) { LUAPDF_WIDGET_BIN_INDEX_COMMON(w) LUAPDF_WIDGET_CONTAINER_INDEX_COMMON(w) /* push widget class methods */ PF_CASE(DESTROY, luaH_widget_destroy) PF_CASE(FOCUS, luaH_widget_focus) PF_CASE(HIDE, luaH_widget_hide) /* push window class methods */ PF_CASE(SET_DEFAULT_SIZE, luaH_window_set_default_size) PF_CASE(SHOW, luaH_window_show) PF_CASE(SET_SCREEN, luaH_window_set_screen) PF_CASE(FULLSCREEN, luaH_window_fullscreen) PF_CASE(UNFULLSCREEN, luaH_window_unfullscreen) PF_CASE(MAXIMIZE, luaH_window_maximize) PF_CASE(UNMAXIMIZE, luaH_window_unmaximize) /* push string methods */ PS_CASE(TITLE, gtk_window_get_title(GTK_WINDOW(w->widget))) /* push boolean properties */ PB_CASE(DECORATED, gtk_window_get_decorated(GTK_WINDOW(w->widget))) case L_TK_XID: lua_pushnumber(L, GDK_WINDOW_XID(GTK_WIDGET(w->widget)->window)); return 1; default: break; } return 0; }
cairo_surface_t * create_native_surface_and_wrap (int w, int h, GtkWidget *parent_style_window) { GdkWindow *window; GdkVisual *visual; cairo_surface_t *surface; Display *display; Pixmap pixmap; if (w <= 0 || h <= 0) abort (); display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()); window = gtk_widget_get_window (parent_style_window); visual = gdk_window_get_visual (window); pixmap = XCreatePixmap (display, GDK_WINDOW_XID (window), w, h, gdk_visual_get_depth (visual)); surface = cairo_xlib_surface_create (display, pixmap, GDK_VISUAL_XVISUAL (visual), w, h); return surface; }