Ejemplo n.º 1
0
static void
show_cursor (Doppelganger *dg)
{
  int current_pointer;
  XIEventMask mask = { dg->mpx, 0, "" };

#if 0
  /* probably unnecessary */
  XIGetClientPointer (gdk_x11_get_default_xdisplay (),
		      None,
		      &current_pointer);
  
  /* probably unnecessary */
  XISetClientPointer (gdk_x11_get_default_xdisplay (),
		      None,
		      dg->mpx);

  if (XIGrabDevice (gdk_x11_get_default_xdisplay (),
                    dg->mpx,
                    GDK_ROOT_WINDOW(), CurrentTime,
                    gdk_x11_cursor_get_xcursor (dg->cursor),
                    GrabModeAsync, GrabModeAsync,
                    True, &mask) != GrabSuccess)
    {
      g_warning ("Grab failed.");
    }

  /* probably unnecessary */
  XISetClientPointer (gdk_x11_get_default_xdisplay (),
		      None,
		      current_pointer);

#endif
}
Ejemplo n.º 2
0
void
frame_update_shadow (decor_frame_t	    *frame,
		     decor_shadow_info_t    *info,
		     decor_shadow_options_t *opt_active_shadow,
		     decor_shadow_options_t *opt_inactive_shadow)
{
    static decor_shadow_options_t no_shadow = {0.0, 0.0, {0, 0, 0}, 0, 0};
    gwd_decor_frame_ref (frame);

    info->active = TRUE;

    (*frame->update_shadow) (gdk_x11_get_default_xdisplay (),
			     gdk_x11_screen_get_xscreen (gdk_screen_get_default ()),
			     frame, &frame->border_shadow_active,
			     &frame->window_context_active,
			     &frame->max_border_shadow_active,
			     &frame->max_window_context_active,
			     info, opt_active_shadow, &no_shadow);

    info->active = FALSE;

    (*frame->update_shadow) (gdk_x11_get_default_xdisplay (),
                             gdk_x11_screen_get_xscreen (gdk_screen_get_default ()),
                             frame, &frame->border_shadow_inactive,
                             &frame->window_context_inactive,
                             &frame->max_border_shadow_inactive,
                             &frame->max_window_context_inactive,
                             info, opt_inactive_shadow, &no_shadow);

    gwd_decor_frame_unref (frame);
}
Ejemplo n.º 3
0
void
my_wnck_change_state (Screen  *screen,
                      Window   xwindow,
                      gboolean add,
                      Atom     state1,
                      Atom     state2)
{
    XEvent xev;

#define _NET_WM_STATE_REMOVE        0    /* remove/unset property */
#define _NET_WM_STATE_ADD           1    /* add/set property */
#define _NET_WM_STATE_TOGGLE        2    /* toggle property  */

    xev.xclient.type = ClientMessage;
    xev.xclient.serial = 0;
    xev.xclient.send_event = True;
    xev.xclient.display = gdk_x11_get_default_xdisplay ();
    xev.xclient.window = xwindow;
    xev.xclient.message_type = my_wnck_atom_get ("_NET_WM_STATE");
    xev.xclient.format = 32;
    xev.xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
    xev.xclient.data.l[1] = state1;
    xev.xclient.data.l[2] = state2;

    XSendEvent (gdk_x11_get_default_xdisplay (),
                RootWindowOfScreen (screen),
                False,
                SubstructureRedirectMask | SubstructureNotifyMask,
                &xev);
}
Ejemplo n.º 4
0
static int
add_mpx_for_window (char *name)
{
  XIAddMasterInfo add;
  int ndevices;
  XIDeviceInfo *devices, *device;
  int i;
  int result;

  /* add the device */

  add.type = XIAddMaster;
  add.name = name;
  add.send_core = True;
  add.enable = True;

  XIChangeHierarchy (gdk_x11_get_default_xdisplay (),
		     (XIAnyHierarchyChangeInfo*) &add,
		     1);

  /* now see whether it's in the list */

  result = -1;

  devices = XIQueryDevice(gdk_x11_get_default_xdisplay (),
			  XIAllDevices, &ndevices);

  for (i = 0; i < ndevices; i++) {
    device = &devices[i];

    if (g_str_has_prefix (device->name,
			  name))
      {
	switch (device->use)
	  {
	  case XIMasterPointer:
	    result = device->deviceid;
	    break;
	  }
      }
  }

  if (result==-1)
    {
      g_warning ("The doppelganger pointer '%s' could not be created.",
		 name);
    }

  XIFreeDeviceInfo(devices);

  return result;
}
Ejemplo n.º 5
0
GdkWindow* create_wrapper(GdkWindow* parent, Window tray_icon)
{
    gdk_flush();
    GdkWindow* icon = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), tray_icon);
    if (icon == NULL)
        return NULL;
    GdkVisual* visual = gdk_window_get_visual(icon);
    GdkWindow* wrapper = NULL;
    if (gdk_visual_get_depth(visual) == 24) {
        GdkWindowAttr attributes;
        attributes.width = DEFAULT_HEIGHT;
        attributes.height = DEFAULT_HEIGHT;
        attributes.window_type = GDK_WINDOW_CHILD;
        attributes.wclass = GDK_INPUT_OUTPUT;
        attributes.event_mask = GDK_ALL_EVENTS_MASK;
        attributes.visual = visual;
        wrapper = gdk_window_new(parent, &attributes, GDK_WA_VISUAL);
        //TODO: there should set color correspond by dock background color
        /*GdkColor color = {1, 0, 0, 1};*/
        /*gdk_window_set_background_rgba(wrapper, &color);*/

        XReparentWindow(gdk_x11_get_default_xdisplay(),
                tray_icon,
                GDK_WINDOW_XID(wrapper),
                0, 0);
        gdk_window_show(icon);
        g_object_set_data(G_OBJECT(wrapper), "wrapper_child", icon);
        g_object_set_data(G_OBJECT(icon), "wrapper_parent", wrapper);
    } else {
        wrapper = icon;
    }
    return wrapper;
}
Ejemplo n.º 6
0
static void
avatar_image_add_filter (EmpathyAvatarImage *avatar_image)
{
	Display    *display;
	Window     window;
	gint       mask;
	XWindowAttributes attrs;

	if (!running_in_x11 ())
		return;

	mask = PropertyChangeMask;

	window = gdk_x11_get_default_root_xwindow ();
	display = gdk_x11_get_default_xdisplay ();

	gdk_error_trap_push ();

	XGetWindowAttributes (display, window, &attrs);
	mask |= attrs.your_event_mask;

	XSelectInput (display, window, mask);

	gdk_error_trap_pop_ignored ();

	gdk_window_add_filter (NULL, avatar_image_filter_func, avatar_image);
}
static void
add_device_presence_filter (GsdPointingDeviceManager *manager)
{
    Display *display;
    XEventClass class_presence;
    gint xi_presence;

    gint op_code, event, error;

    if (!XQueryExtension(GDK_DISPLAY(),
                         "XInputExtension",
                         &op_code,
                         &event,
                         &error)) {
        return;
    }

    display = gdk_x11_get_default_xdisplay();

    gdk_error_trap_push();
    DevicePresence(display, xi_presence, class_presence);
    XSelectExtensionEvent(display,
                          RootWindow(display, DefaultScreen(display)),
                          &class_presence, 1);
    gdk_flush();
    if (!gdk_error_trap_pop())
        gdk_window_add_filter(NULL, device_presence_filter, manager);
}
Ejemplo n.º 8
0
void background_info_set_background_by_drawable(BackgroundInfo* info,
        guint32 drawable)
{
    gint x, y;
    guint border,depth, width=0, height=0;
    Display* dpy = gdk_x11_get_default_xdisplay();
    gdk_error_trap_push();
    //TODO:
    //we shoul use xatom_name window to set events instead of root window
    //because the monitors changed signal will came before root window rect changed
    //so the Xroot window rect maybe keep old rect in update_bg function and in Display DBus signal "PrimaryChanged"
    Window root;
    XGetGeometry(dpy, drawable, &root, &x, &y, &width, &height, &border,
                 &depth);
    g_debug("[%s] width: %d, height: %d, x: %d y: %d\n", __func__,
            width, height, x, y);
    if (gdk_error_trap_pop()) {
        g_warning("[%s] invalid drawable %d \n", __func__, drawable);
        return;
    }

    g_mutex_lock(&info->m);
    if (info->bg != NULL) {
        cairo_surface_destroy(info->bg);
        info->bg = NULL;
    }
    info->bg = cairo_xlib_surface_create(dpy, drawable,
                                         gdk_x11_visual_get_xvisual(gdk_visual_get_system()), width, height);
    g_mutex_unlock(&info->m);

    if (gtk_widget_get_realized(info->container)) {
        gdk_window_invalidate_rect(gtk_widget_get_window(info->container),
                                   NULL, TRUE);
    }
}
Ejemplo n.º 9
0
static
struct QsDrawX11Context *qsDrawX11Context_create(GtkWidget *w)
{
  struct QsDrawX11Context *x;
  x = g_malloc0(sizeof(*x));
  x->dsp = gdk_x11_get_default_xdisplay();
  QS_ASSERT(x->dsp);
  x->xwin = gdk_x11_window_get_xid(gtk_widget_get_window(w));
  QS_ASSERT(x->xwin);
  x->cmap = DefaultColormap(x->dsp, DefaultScreen(x->dsp));
  QS_ASSERT(x->cmap);
  x->gc = XCreateGC(x->dsp, x->xwin, 0, 0);
  QS_ASSERT(x->gc);
  x->bg.pixel = 0;
  x->bg.red   = 0x0001; /* X11 uses shorts not bytes */
  x->bg.green = 0xFFFF;
  x->bg.blue  = 0xFFFF;
  x->bg.flags = 0;

#ifdef QS_DEBUG
  QS_ASSERT(XAllocColor(x->dsp, x->cmap, &x->bg));
#else
  XAllocColor(x->dsp, x->cmap, &x->bg);
#endif
  
  return x;
}
Ejemplo n.º 10
0
/*
 * From eggcellrenderkeys.c.
 */
gboolean
tomboy_keybinder_is_modifier (guint keycode)
{
	gint i;
	gint map_size;
	XModifierKeymap *mod_keymap;
	gboolean retval = FALSE;

	mod_keymap = XGetModifierMapping (gdk_x11_get_default_xdisplay ());

	map_size = 8 * mod_keymap->max_keypermod;

	i = 0;
	while (i < map_size) {
		if (keycode == mod_keymap->modifiermap[i]) {
			retval = TRUE;
			break;
		}
		++i;
	}

	XFreeModifiermap (mod_keymap);

	return retval;
}
void
ss_thumbnailer_free (SSThumbnailer *thumbnailer)
{
  Display *display;
  display = gdk_x11_get_default_xdisplay ();

  if (thumbnailer == NULL) {
    return;
  }

  if (thumbnailer->thumbnail_pixmap != NULL) {
    g_object_unref (thumbnailer->thumbnail_pixmap);
    thumbnailer->thumbnail_pixmap = NULL;
  }
  if (thumbnailer->thumbnail_picture != None) {
    XRenderFreePicture (display, thumbnailer->thumbnail_picture);
    thumbnailer->thumbnail_picture = None;
  }
  if (thumbnailer->window_picture != None) {
    XRenderFreePicture (display, thumbnailer->window_picture);
    thumbnailer->window_picture = None;
  }

  g_free (thumbnailer);
}
Ejemplo n.º 12
0
bool wxTopLevelWindowGTK::CanSetTransparent()
{
    // allow to override automatic detection as it's far from perfect
    const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent";
    if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
    {
        return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
    }

#ifdef __WXGTK3__
    return gtk_widget_is_composited(m_widget) != 0;
#else
#if GTK_CHECK_VERSION(2,10,0)
    if (!gtk_check_version(2,10,0))
    {
        return gtk_widget_is_composited(m_widget) != 0;
    }
    else
#endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
    {
        return false;
    }
#endif // !__WXGTK3__

#if 0 // Don't be optimistic here for the sake of wxAUI
    int opcode, event, error;
    // Check for the existence of a RGBA visual instead?
    return XQueryExtension(gdk_x11_get_default_xdisplay (),
                           "Composite", &opcode, &event, &error);
#endif
}
Ejemplo n.º 13
0
void
gtk_gl_swap_buffers (GtkWidget *widget)
{
        Display *display = gdk_x11_get_default_xdisplay ();
        Window window = gdk_x11_window_get_xid (gtk_widget_get_window (widget));
        glXSwapBuffers (display, window);
}
// This code can only run after thumbnailer's drawing_area has been realized,
// and after the main loop has run so that wnck_window is initialized.
static void
initialize_thumbnailer_pictures (SSThumbnailer *thumbnailer)
{
  Display *display;
  GdkScreen *screen;
  XRenderPictFormat *format;
  XRenderPictureAttributes pa;

  display = gdk_x11_get_default_xdisplay ();
  screen = gtk_widget_get_screen (thumbnailer->drawing_area);
  format = XRenderFindVisualFormat (display, DefaultVisual (
      display, gdk_screen_get_number (screen)));

  thumbnailer->thumbnail_pixmap = gdk_pixmap_new (
      thumbnailer->drawing_area->window, THUMBNAIL_SIZE, THUMBNAIL_SIZE, -1);

  thumbnailer->thumbnail_picture = XRenderCreatePicture (display,
      GDK_DRAWABLE_XID (thumbnailer->thumbnail_pixmap), format, 0, NULL);

  pa.subwindow_mode = IncludeInferiors;
  thumbnailer->window_picture = XRenderCreatePicture (display,
      wnck_window_get_xid (thumbnailer->wnck_window),
      format, CPSubwindowMode, &pa);
  XRenderSetPictureFilter (display, thumbnailer->window_picture,
      "good", NULL, 0);
}
Ejemplo n.º 15
0
void
gtk_gl_enable (GtkWidget *widget)
{
        GdkScreen *screen;
        GdkVisual *visual;
        Display *xdisplay;
        XVisualInfo *xvi;
        gint xscreen;
        GtkGLContext *gtkgc;
	gint attributes[] ={GLX_RGBA,
                            GLX_RED_SIZE, 8,
                            GLX_GREEN_SIZE, 8,
                            GLX_BLUE_SIZE, 8,
                            GLX_DEPTH_SIZE,24,
                            GLX_DOUBLEBUFFER,
                            None};
        
        gtk_widget_set_app_paintable (widget, TRUE);
        gtk_widget_set_double_buffered (widget, FALSE);

        gtkgc = g_slice_new0 (GtkGLContext);
        
        xdisplay = gdk_x11_get_default_xdisplay ();
        xscreen = gdk_x11_get_default_screen ();
        
        g_return_if_fail (NULL != (xvi = glXChooseVisual (xdisplay, xscreen, attributes)));
        screen = gtk_widget_get_screen (widget);
        g_return_if_fail (NULL != (visual = gdk_x11_screen_lookup_visual (screen, xvi->visualid)));
        gtk_widget_set_visual (widget, visual);
        
        gtkgc->widget  = widget;
        g_return_if_fail (NULL != (gtkgc->context = glXCreateContext (xdisplay, xvi, NULL, GL_TRUE)));
        
        gtk_glx_context_list = g_slist_prepend (gtk_glx_context_list, gtkgc);
}
Ejemplo n.º 16
0
Atom
my_wnck_atom_get (const char *atom_name)
{
    Atom retval;

    g_return_val_if_fail (atom_name != NULL, None);

    if (!atom_hash)
    {
        atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
        reverse_atom_hash = g_hash_table_new (NULL, NULL);
    }

    retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name));
    if (!retval)
    {
        retval = XInternAtom (gdk_x11_get_default_xdisplay (), atom_name, FALSE);

        if (retval != None)
        {
            char *name_copy;

            name_copy = g_strdup (atom_name);

            g_hash_table_insert (atom_hash,
                                 name_copy,
                                 GUINT_TO_POINTER (retval));
            g_hash_table_insert (reverse_atom_hash,
                                 GUINT_TO_POINTER (retval),
                                 name_copy);
        }
    }

    return retval;
}
static GdkFilterReturn
device_presence_filter (GdkXEvent *xevent,
                        GdkEvent  *event,
                        gpointer   data)
{
    XEvent *xev = (XEvent *)xevent;
    XEventClass class_presence;
    int xi_presence;
    GpdsXInput *xinput;
    GsdPointingDeviceManager *manager = GSD_POINTING_DEVICE_MANAGER(data);

    xinput = gsd_pointing_device_manager_get_xinput(manager);
    if (!xinput)
        return GDK_FILTER_CONTINUE;

    DevicePresence(gdk_x11_get_default_xdisplay(), xi_presence, class_presence);

    if (xev->type == xi_presence) {
        XDevicePresenceNotifyEvent *notify_event = (XDevicePresenceNotifyEvent *)xev;
        if (notify_event->devchange == DeviceEnabled ||
            notify_event->devchange == DeviceRemoved) {
            set_disable_while_other_device_exists(manager,
                                                  xinput,
                                                  gconf_client_get_default());
        }
    }
    g_object_unref(xinput);

    return GDK_FILTER_CONTINUE;
}
Ejemplo n.º 18
0
static void
cem_gl_area_configure(GtkWidget *area, gpointer data)
{
  GLint attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};

  CemGLAreaPrivate *priv;

  gtk_widget_set_double_buffered(area, FALSE);

  priv = cem_gl_area_get_instance_private(area);

  priv->drawing_window = gtk_widget_get_window(GTK_WIDGET(area));

  priv->x_window = gdk_x11_window_get_xid(GDK_WINDOW(priv->drawing_window));

  priv->x_display = gdk_x11_get_default_xdisplay();

  priv->x_visual = glXChooseVisual(priv->x_display, 0, attributes);

  priv->x_context = glXCreateContext(priv->x_display, priv->x_visual, NULL, GL_TRUE);

  XGetWindowAttributes(priv->x_display, priv->x_window, &priv->x_attributes);

  glXMakeCurrent(priv->x_display, priv->x_window, priv->x_context);

  XMapWindow(priv->x_display, priv->x_window);

  glViewport(0, 0, priv->x_attributes.width, priv->x_attributes.height);

  glOrtho(-10, 10, -10, 10, -10, 10);

  glScalef(5.0, 5.0, 5.0);
}
CD_APPLET_ON_CLICK_END


//\___________ Define here the entries you want to add to the menu when the user right-clicks on your icon or on its subdock or your desklet. The icon and the container that were clicked are available through the macros CD_APPLET_CLICKED_ICON and CD_APPLET_CLICKED_CONTAINER. CD_APPLET_CLICKED_ICON may be NULL if the user clicked in the container but out of icons. The menu where you can add your entries is available throught the macro CD_APPLET_MY_MENU; you can add sub-menu to it if you want.
#ifdef HAVE_X11
#ifdef HAVE_XRANDR
static void _on_select_resolution (GtkMenuItem *menu_item, gpointer data)  /// TODO: put that in the core...
{
	CD_APPLET_ENTER;
	int 				    iNumRes = GPOINTER_TO_INT (data);
	Display                 *dpy;
	Window                  root;
	XRRScreenConfiguration  *conf;
	short                   *rates;
	int                     num_rates;
	dpy = gdk_x11_get_default_xdisplay ();
	root = RootWindow(dpy, 0);
	
	conf = XRRGetScreenInfo(dpy, root);
	CD_APPLET_LEAVE_IF_FAIL (conf != NULL);
	//g_return_if_fail (conf != NULL);
	
	rates = XRRRates(dpy, 0, iNumRes, &num_rates);
	CD_APPLET_LEAVE_IF_FAIL (num_rates > 0);
	//g_return_if_fail (num_rates > 0);
	cd_debug ("available rates : from %d to %d Hz", rates[0], rates[num_rates-1]);
	
	XRRSetScreenConfigAndRate(dpy, conf, root, iNumRes, RR_Rotate_0, rates[num_rates-1], CurrentTime);
	XRRFreeScreenConfigInfo (conf);
	
	// restore original conf :  XRRSetScreenConfigAndRate(dpy, conf, root, original_size_id, original_rotation, original_rate, CurrentTime);
	CD_APPLET_LEAVE();
}
Ejemplo n.º 20
0
static gboolean
key_event( GtkWidget *input, GdkEventKey *event )
{
  XKeyEvent xevent;

  switch( event->type )
  {
    case GDK_KEY_PRESS:
      xevent.type = KeyPress;
      break;

    case GDK_KEY_RELEASE:
      xevent.type = KeyRelease;
      break;

    default:
      return FALSE;
  }

  xevent.display = gdk_x11_get_default_xdisplay();
  xevent.keycode = event->hardware_keycode;
  xevent.state = event->state;
  xevent.time = event->time;
  xevent.root = gdk_x11_get_default_root_xwindow();

  window_list_foreach_selected( wl, window_list_foreach_callback, &xevent );

  return TRUE;
}
Ejemplo n.º 21
0
void CFont::CloseXftFont( XftFont* font )
{
	if( font )
	{
		Display *display = gdk_x11_get_default_xdisplay();
		XftFontClose(display, font );
	}
}
Ejemplo n.º 22
0
/**
 * Initialises appropriate X extensions.
 */
static void
initialise_extensions (void)
{
  int major = 2, minor = 0;
  if (XIQueryVersion(gdk_x11_get_default_xdisplay (), &major, &minor) == BadRequest) {
    g_error("XI2 not available. Server supports %d.%d\n", major, minor);
  }
}
gboolean
uninit_composite (void)
{
  XCompositeUnredirectSubwindows (gdk_x11_get_default_xdisplay (),
      GDK_WINDOW_XWINDOW (gdk_get_default_root_window ()),
      CompositeRedirectAutomatic);
  return TRUE;
}
Ejemplo n.º 24
0
int c_center(lua_State *lua)
{
	int top = lua_gettop(lua);

	int workspace_width, workspace_height, window_width, window_height;
	int xoffset, yoffset;
	WnckScreen *screen;
	WnckWorkspace *workspace;

	if (top != 0) {
		luaL_error(lua, "center: %s", no_indata_expected_error);
		return 0;
	}

	WnckWindow *window = get_current_window();

	if (!window) {
		lua_pushboolean(lua, FALSE);
		return 1;
	}

	wnck_window_get_geometry(window, NULL, NULL, &window_width, &window_height);

	screen = wnck_window_get_screen(window);

	workspace = wnck_screen_get_active_workspace(screen);

	if (workspace == NULL) {
		workspace = wnck_screen_get_workspace(screen,0);
	}

	if (workspace == NULL) {
		g_printerr(_("Could not get workspace"));
		lua_pushboolean(lua, FALSE);
		return 1;
	}

	workspace_width = wnck_workspace_get_width(workspace);
	workspace_height = wnck_workspace_get_height(workspace);

	xoffset = (workspace_width - window_width) / 2;
	yoffset = (workspace_height - window_height) / 2;

	devilspie2_error_trap_push();
	XMoveWindow (gdk_x11_get_default_xdisplay(),
	             wnck_window_get_xid(window),
	             xoffset, yoffset);

	if (devilspie2_error_trap_pop()) {
		g_printerr("center: %s", failed_string);
		lua_pushboolean(lua, FALSE);
		return 1;
	}

	lua_pushboolean(lua, TRUE);

	return 1;
}
Ejemplo n.º 25
0
void
gtk_gl_make_current (GtkWidget *widget)
{
        Display *display = gdk_x11_get_default_xdisplay ();
        Window window = gdk_x11_window_get_xid (gtk_widget_get_window (widget));
        GSList *node = gtk_glx_get_context (widget);
        GtkGLContext *gtkgc = node->data;
        g_return_if_fail (True == glXMakeCurrent (display, window, gtkgc->context));
}
Ejemplo n.º 26
0
void qsWin_destroy(struct QsWin *win)
{
  QS_ASSERT(win);
  QS_ASSERT(win->win);
  QS_ASSERT(win->da);
  QS_ASSERT(qsApp);


  while(win->drawSyncs)
  {
#ifdef QS_DEBUG
    void *ds;
    ds = win->drawSyncs->data;
#endif
    qsController_destroy((struct QsController*) win->drawSyncs->data);
    /* this should have changed the list */
    QS_ASSERT(!win->drawSyncs || win->drawSyncs->data != ds);
  }

  if(win->hashTable)
    g_hash_table_destroy(win->hashTable);

  if(win->gc)
    XFreeGC(gdk_x11_get_default_xdisplay(), win->gc);
  if(win->pixmap && win->pixmap != (intptr_t) 1)
    XFreePixmap(win->dsp, win->pixmap);
  if(win->fadeSurface)
    g_free(win->fadeSurface);
  if(win->points)
    g_free(win->points);
  if(win->unitsXLabel)
    g_free(win->unitsXLabel);
  if(win->unitsYLabel)
    g_free(win->unitsYLabel);


  while(win->traces)
  {
#ifdef QS_DEBUG
    void *trace;
    trace = win->traces->data;
#endif
    qsTrace_destroy((struct QsTrace *) win->traces->data);
    /* this should have changed the list */
    QS_ASSERT(!win->traces || win->traces->data != trace);
  }

  qsApp->wins = g_slist_remove(qsApp->wins, win);
  gtk_widget_destroy(win->win);

  _qsWidget_destroy(win->adjsWidget);

  // Call the base destroy if we are not calling
  // it already.
  _qsAdjusterList_checkBaseDestroy(win);
}
Ejemplo n.º 27
0
//================================================================
  void*  GLB_Create () {
//================================================================
/// GLB_Create            create opengl-window (used by GUI_gl__)
 
  GtkWidget   *area;
  int         xscreen, i1;
  GdkScreen   *screen;
  GdkVisual   *visual;
  Window      root;
  XVisualInfo *xvisual;
  Colormap    xcolormap;
  int         attributes[] = {
                GLX_RGBA,
                GLX_RED_SIZE, 1,
                GLX_GREEN_SIZE, 1,
                GLX_BLUE_SIZE, 1,
                GLX_DOUBLEBUFFER, True,
                GLX_DEPTH_SIZE, 24,
                None };

  GLB_x_id = 0;   // reset

  area = gtk_drawing_area_new ();
  gtk_widget_set_double_buffered (area, FALSE);

  GLB_display = gdk_x11_get_default_xdisplay ();
  xscreen = DefaultScreen (GLB_display);
  screen = gdk_screen_get_default ();
    // printf(" screenNr = %d\n",gdk_screen_get_number(screen));

  xvisual = glXChooseVisual (GLB_display, xscreen, attributes);
    // printf(" xvisualid=%d\n",xvisual->visualid);

  visual = gdk_x11_screen_lookup_visual (screen, xvisual->visualid);

  root = RootWindow (GLB_display, xscreen);
  xcolormap = XCreateColormap (GLB_display, root, xvisual->visual, AllocNone);

  glXGetConfig (GLB_display, xvisual, GLX_RED_SIZE, &i1);
    printf(" GLX_RED_SIZE=%d\n",i1);
  glXGetConfig (GLB_display, xvisual, GLX_DEPTH_SIZE, &i1);
    printf(" GLX_DEPTH_SIZE=%d\n",i1);

// Gtk2 only:
  //colormap = gdk_x11_colormap_foreign_new (visual, xcolormap);
  //gtk_widget_set_colormap (area, colormap);

  GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE);
  // free (xvisual);

  glXWaitX();
  glXWaitGL();

  return area;

}
Ejemplo n.º 28
0
void safe_window_move_resize(GdkWindow* wrapper, int x, int y, int w, int h)
{
    XSelectInput(gdk_x11_get_default_xdisplay(), GDK_WINDOW_XID(wrapper), ExposureMask | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask);
    gdk_window_move_resize(wrapper, x, y, w, h);
    GdkWindow* icon = g_object_get_data(G_OBJECT(wrapper), "wrapper_child");
    if (icon) {
        gdk_window_resize(icon, w, h);
    }
    gdk_window_set_events(wrapper, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_VISIBILITY_NOTIFY_MASK);
}
Ejemplo n.º 29
0
void
doppelganger_show (Doppelganger *dg)
{
#if 0
  XChangeActivePointerGrab (gdk_x11_get_default_xdisplay (),
			    0,
			    gdk_x11_cursor_get_xcursor (dg->cursor),
			    CurrentTime);
#endif
}
Ejemplo n.º 30
0
/**
 * gdk_gl_query_extension:
 *
 * Indicates whether the window system supports the OpenGL extension
 * (GLX, WGL, etc.).
 *
 * Return value: TRUE if OpenGL is supported, FALSE otherwise.
 **/
gboolean
gdk_gl_query_extension (void)
{
#ifdef GDKGLEXT_MULTIHEAD_SUPPORT
  return glXQueryExtension (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
                            NULL, NULL);
#else  /* GDKGLEXT_MULTIHEAD_SUPPORT */
  return glXQueryExtension (gdk_x11_get_default_xdisplay (),
                            NULL, NULL);
#endif /* GDKGLEXT_MULTIHEAD_SUPPORT */
}