Beispiel #1
0
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);
    }
}
Beispiel #3
0
//-----------------------------------------
// 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");
	}
}
Beispiel #5
0
//================================================================
  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;

}
Beispiel #6
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));
        }
}
Beispiel #7
0
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));
}
Beispiel #9
0
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;
}
Beispiel #10
0
/* 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;
}
Beispiel #11
0
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;
}
Beispiel #12
0
/**
 * 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;
}
Beispiel #13
0
/**
 * 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
}
Beispiel #14
0
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));
    }
}
Beispiel #15
0
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);
    */
}
Beispiel #16
0
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);
    */
}
Beispiel #17
0
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
}
Beispiel #18
0
/**
 * @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;
}
Beispiel #19
0
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);
	}
}
Beispiel #21
0
////////////////////////////////////////////////////////////
/// 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
}
Beispiel #22
0
/**
 * 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) &current_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
}
Beispiel #25
0
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;
}
Beispiel #26
0
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);
  
}
Beispiel #27
0
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;
}
Beispiel #28
0
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);
}
Beispiel #29
0
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;
}
Beispiel #30
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;
}