Ejemplo n.º 1
0
/* Copied from nautilus */
static gchar *
get_direct_save_filename (GdkDragContext *context)
{
	guchar *prop_text;
	gint prop_len;

	if (!gdk_property_get (gdk_drag_context_get_source_window  (context), gdk_atom_intern ("XdndDirectSave0", FALSE),
			       gdk_atom_intern ("text/plain", FALSE), 0, 1024, FALSE, NULL, NULL,
			       &prop_len, &prop_text) && prop_text != NULL) {
		return NULL;
	}

	/* Zero-terminate the string */
	prop_text = g_realloc (prop_text, prop_len + 1);
	prop_text[prop_len] = '\0';

	/* Verify that the file name provided by the source is valid */
	if (*prop_text == '\0' ||
	    strchr ((const gchar *) prop_text, G_DIR_SEPARATOR) != NULL) {
		gedit_debug_message (DEBUG_UTILS, "Invalid filename provided by XDS drag site");
		g_free (prop_text);
		return NULL;
	}

	return (gchar *)prop_text;
}
Ejemplo n.º 2
0
gint 
gtksharp_get_gdk_net_current_desktop (void)
{
	GdkAtom actual_property_type;
	int actual_format;
	int actual_length;
	long *data = NULL;
	gint current_desktop;

	if (!gdk_property_get (
			gdk_screen_get_root_window (gdk_screen_get_default ()),
			gdk_atom_intern ("_NET_CURRENT_DESKTOP", FALSE),
			gdk_atom_intern ("CARDINAL", FALSE),
			0,
			G_MAXLONG,
			FALSE,
			&actual_property_type,
			&actual_format,
			&actual_length,
			(guchar **) &data)) {
		gchar *actual_property_type_name;
		g_critical ("Unable to get _NET_CURRENT_DESKTOP");
		actual_property_type_name = gdk_atom_name (actual_property_type);
		if (actual_property_type_name) {
			g_message ("actual_property_type: %s", actual_property_type_name);
			g_free (actual_property_type_name);
		}
		return -1;
	}

	current_desktop = (gint) data[0];
	g_free (data);

	return current_desktop;
}
Ejemplo n.º 3
0
gint
tomboy_window_get_workspace (GtkWindow *window)
{
#ifndef GDK_WINDOWING_X11
	return -1;
#else
	GdkWindow *gdkwin = gtk_widget_get_window(GTK_WIDGET (window));
	GdkAtom wm_desktop = gdk_atom_intern ("_NET_WM_DESKTOP", FALSE);
	GdkAtom out_type;
	gint out_format, out_length;
	gulong *out_val;
	int workspace;

	if (!gdk_property_get (gdkwin,
			       wm_desktop,
			       _GDK_MAKE_ATOM (XA_CARDINAL),
			       0, G_MAXLONG,
			       FALSE,
			       &out_type,
			       &out_format,
			       &out_length,
			       (guchar **) &out_val))
		return -1;

	workspace = *out_val;
	g_free (out_val);

	return workspace;
#endif
}
Ejemplo n.º 4
0
static PyObject *
PyGdkWindow_PropertyGet(PyGdkWindow_Object *self, PyObject *args)
{
    PyObject *py_property, py_type = NULL;
    gint pdelete = FALSE;

    GdkAtom atype, property, type;
    gint aformat, alength;
    guchar *data;

    if (!PyArg_ParseTuple(args, "O|Oi:GdkWindow.property_get", &py_property,
			  &py_type, &pdelete)) {
	return NULL;
    }

    property = pygdk_atom_from_pyobject(py_property);
    if (Pyerr_Occurred())
	return NULL;

    type = pygdk_atom_from_pyobject(py_type);
    if (Pyerr_Occurred())
	return NULL;
	
    if (gdk_property_get(self->obj, property, type, 0, G_MAXLONG,
			 pdelete, &atype, &aformat, &alength, &data)) {
	/* success */
	PyObject *pdata = NULL;
	gint i;
	guint16 *data16;
	guint32 *data32;
	switch (aformat) {
	case 8:
	    if ((pdata = PyString_FromStringAndSize(data, alength)) == NULL)
	        return NULL;
	    break;
	case 16:
	    data16 = (guint16 *)data;
	    if ((pdata = PyTuple_New(alength)) == NULL)
	        return NULL;
	    for (i = 0; i < alength; i++)
		PyTuple_SetItem(pdata, i, PyInt_FromLong(data16[i]));
	    break;
	case 32:
	    data32 = (guint32 *)data;
	    if ((pdata = PyTuple_New(alength)) == NULL)
	        return NULL;
	    for (i = 0; i < alength; i++)
		PyTuple_SetItem(pdata, i, PyInt_FromLong(data32[i]));
	    break;
	default:
	    g_warning("got a property format != 8, 16 or 32");
	    g_assert_not_reached();
	}
	g_free(data);
	return Py_BuildValue("(NiN)", PyGdkAtom_New(atype), aformat, pdata);
    } else {
	Py_INCREF(Py_None);
	return Py_None;
    }
}
Ejemplo n.º 5
0
Archivo: ml_gdk.c Proyecto: CRogers/obc
CAMLprim value ml_gdk_property_get (value window, value property,
                           value length, value pdelete)
{
#if defined(_WIN32) || defined(__CYGWIN__) || defined(HAS_GTKQUARTZ)
  return Val_unit; /* not supported */
#else
    GdkAtom atype;
    int aformat, alength;
    guchar *data;
    int nitems;
    int ok = gdk_property_get (GdkWindow_val(window), GdkAtom_val(property),
                               AnyPropertyType, 0,
                               Long_val(length), Bool_val(pdelete),
                               &atype, &aformat, &alength, &data);
    if (ok) {
        CAMLparam0();
        CAMLlocal3(mltype, mldata, pair);
        switch (aformat) {
        case 16: nitems = alength / sizeof(short); break;
        case 32: nitems = alength / sizeof(long); break;
        default: nitems = alength;
        }
        mldata = copy_xdata (aformat, data, nitems);
        mltype = Val_GdkAtom (atype);
        pair = alloc_small(2,0);
        Field(pair,0) = mltype;
        Field(pair,1) = mldata;
        CAMLreturn(ml_some (pair));
    }
    return Val_unit;
#endif
}
Ejemplo n.º 6
0
static char *
get_direct_save_filename (GdkDragContext *context)
{
	guchar *prop_text;
	gint prop_len;

	if (!gdk_property_get (gdk_drag_context_get_source_window (context), gdk_atom_intern (NEMO_ICON_DND_XDNDDIRECTSAVE_TYPE, FALSE),
			       gdk_atom_intern ("text/plain", FALSE), 0, 1024, FALSE, NULL, NULL,
			       &prop_len, &prop_text)) {
		return NULL;
	}

	/* Zero-terminate the string */
	prop_text = g_realloc (prop_text, prop_len + 1);
	prop_text[prop_len] = '\0';
	
	/* Verify that the file name provided by the source is valid */
	if (*prop_text == '\0' ||
	    strchr ((const gchar *) prop_text, G_DIR_SEPARATOR) != NULL) {
		DEBUG ("Invalid filename provided by XDS drag site");
		g_free (prop_text);
		return NULL;
	}
	
	return prop_text;
}
static gboolean get_desktop_window (Window *window)
{
	Window *desktop_window;
	GdkWindow *root_window;
	GdkAtom type_returned;
	int format_returned;
	int length_returned;

	root_window = gdk_screen_get_root_window (
				gdk_screen_get_default ());

	if (gdk_property_get (root_window,
			      gdk_atom_intern ("CAJA_DESKTOP_WINDOW_ID", FALSE),
			      gdk_x11_xatom_to_atom (XA_WINDOW),
			      0, 4, FALSE,
			      &type_returned,
			      &format_returned,
			      &length_returned,
			      (guchar**) &desktop_window)) {
		*window = *desktop_window;
		g_free (desktop_window);
		return TRUE;
	}
	else {
		*window = 0;
		return FALSE;
	}
}
Ejemplo n.º 8
0
guint 
gtksharp_get_gdk_net_active_window (void)
{
	GdkAtom actual_property_type;
	int actual_format;
	int actual_length;
	long *data = NULL;
	guint windowID = 0;

	if (!gdk_property_get (
			gdk_screen_get_root_window (gdk_screen_get_default ()),
			gdk_atom_intern ("_NET_ACTIVE_WINDOW", FALSE),		
			gdk_atom_intern ("WINDOW", FALSE),			
			0,							
			G_MAXLONG,						
			FALSE,							
			&actual_property_type,					
			&actual_format,						
			&actual_length,						
			(guchar **) &data)) {					
		gchar *actualPropertyTypeName;
		g_critical ("Unable to get _NET_ACTIVE_WINDOW");
		actualPropertyTypeName = gdk_atom_name (actual_property_type);
		if (actualPropertyTypeName) {
			g_message ("actual_property_type: %s", actualPropertyTypeName);
			g_free(actualPropertyTypeName);
		}
		return -1;
	}

	windowID = (gint) data [0];
	g_free (data);

	return windowID;
}
Ejemplo n.º 9
0
static gboolean
gth_file_list_drag_drop (GtkWidget      *widget,
			 GdkDragContext *context,
			 gint            x,
			 gint            y,
			 guint           time,
			 gpointer        user_data)
{
	GthBrowser *browser = user_data;
	int         filename_len;
	char       *filename;

	g_signal_stop_emission_by_name (widget, "drag-drop");

	if (gdk_property_get (gdk_drag_context_get_source_window (context),
			      XDND_ACTION_DIRECT_SAVE_ATOM,
			      TEXT_PLAIN_ATOM,
			      0,
			      1024,
			      FALSE,
			      NULL,
			      NULL,
			      &filename_len,
			      (guchar **) &filename)
	    && GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser)))
	{
		GFile *file;
		char  *uri;

		filename = g_realloc (filename, filename_len + 1);
		filename[filename_len] = '\0';

		file = _g_file_append_path (gth_browser_get_location (browser), filename);
		uri = g_file_get_uri (file);
		gdk_property_change (gdk_drag_context_get_source_window (context),
				     XDND_ACTION_DIRECT_SAVE_ATOM,
				     TEXT_PLAIN_ATOM,
				     8,
				     GDK_PROP_MODE_REPLACE,
				     (const guchar *) uri,
				     strlen (uri));

		g_free (uri);
		g_object_unref (file);
		g_free (filename);

		gtk_drag_get_data (widget,
		                   context,
		                   XDND_ACTION_DIRECT_SAVE_ATOM,
		                   time);
	}
	else
		gtk_drag_get_data (widget,
				   context,
				   URI_LIST_ATOM,
				   time);

	return TRUE;
}
Ejemplo n.º 10
0
void
tomboy_window_move_to_current_workspace (GtkWindow *window)
{
#ifndef GDK_WINDOWING_X11
	return;
#else
	GdkWindow *gdkwin = gtk_widget_get_window(GTK_WIDGET (window));
	GdkWindow *rootwin = 
		gdk_screen_get_root_window (gdk_window_get_screen (gdkwin));

	GdkAtom current_desktop = 
		gdk_atom_intern ("_NET_CURRENT_DESKTOP", FALSE);
	GdkAtom wm_desktop = gdk_atom_intern ("_NET_WM_DESKTOP", FALSE);
	GdkAtom out_type;
	gint out_format, out_length;
	gulong *out_val;
	int workspace;
	XEvent xev;

	if (!gdk_property_get (rootwin,
			       current_desktop,
			       _GDK_MAKE_ATOM (XA_CARDINAL),
			       0, G_MAXLONG,
			       FALSE,
			       &out_type,
			       &out_format,
			       &out_length,
			       (guchar **) &out_val))
		return;

	workspace = *out_val;
	g_free (out_val);

	TRACE (g_print ("Setting _NET_WM_DESKTOP to: %d\n", workspace));

	xev.xclient.type = ClientMessage;
	xev.xclient.serial = 0;
	xev.xclient.send_event = True;
	xev.xclient.display = GDK_WINDOW_XDISPLAY (gdkwin);
	xev.xclient.window = GDK_WINDOW_XID (gdkwin);
	xev.xclient.message_type = 
		gdk_x11_atom_to_xatom_for_display(
			gdk_window_get_display (gdkwin),
			wm_desktop);
	xev.xclient.format = 32;
	xev.xclient.data.l[0] = workspace;
	xev.xclient.data.l[1] = 0;
	xev.xclient.data.l[2] = 0;

	XSendEvent (GDK_WINDOW_XDISPLAY (rootwin),
		    GDK_WINDOW_XID (rootwin),
		    False,
		    SubstructureRedirectMask | SubstructureNotifyMask,
		    &xev);
#endif
}
Ejemplo n.º 11
0
GList * 
gtksharp_get_gdk_net_workarea (void)
{
	GdkAtom actual_property_type;
	int actual_format;
	int actual_length;
	long *data = NULL;	
	int i = 0;
	GList *list = NULL;

	if (!gdk_property_get (
			gdk_screen_get_root_window (gdk_screen_get_default ()),	
			gdk_atom_intern ("_NET_WORKAREA", FALSE),		
			gdk_atom_intern ("CARDINAL", FALSE),			
			0,							
			G_MAXLONG,						
			FALSE,							
			&actual_property_type,					
			&actual_format,						
			&actual_length,						
			(guchar **) &data)) {					
		gchar *actualPropertyTypeName;
		g_critical ("Unable to get _NET_WORKAREA");
		actualPropertyTypeName = gdk_atom_name (actual_property_type);
		if (actualPropertyTypeName) {
			g_message ("actual_property_type: %s", actualPropertyTypeName);
			g_free(actualPropertyTypeName);
		}
		return FALSE;
	}

	for (i = 0; i < actual_length / sizeof (long); i += 4) {
		GdkRectangle *rectangle = g_malloc(sizeof (GdkRectangle));
		rectangle->x		= (int) data [i];
		rectangle->y		= (int) data [i + 1];
		rectangle->width	= (int) data [i + 2];
		rectangle->height	= (int) data [i + 3];
		list = g_list_append (list, rectangle);
	}


	if (data != NULL)
		g_free(data);

	return list;
}
Ejemplo n.º 12
0
char* matenu_settings_get_by_atom (MatenuSettings* self, GdkAtom atom) {
	char* result = NULL;
	char* context;
	GdkAtom actual_type;
	GdkAtom type;
	gint actual_format = 0;
	gint actual_length = 0;
	char* _tmp1_;
	char* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	context = NULL;
	type = gdk_atom_intern ("STRING", FALSE);
	gdk_property_get (self->priv->_window, atom, type, (gulong) 0, (gulong) G_MAXLONG, FALSE, &actual_type, &actual_format, &actual_length, &_tmp0_);
	context = (_tmp1_ = _tmp0_, _g_free0 (context), _tmp1_);
	result = context;
	return result;
}
Ejemplo n.º 13
0
guint * 
gtksharp_get_gdk_net_client_list (int *count)
{
	GdkAtom actual_property_type;
	int actual_format;
	int actual_length;
	long *data = NULL;
	guint * list = NULL;
	int i;

	if (!gdk_property_get (
			gdk_screen_get_root_window (gdk_screen_get_default ()),
			gdk_atom_intern ("_NET_CLIENT_LIST", FALSE),
			gdk_atom_intern ("WINDOW", FALSE),
			0,
			G_MAXLONG,
			FALSE,
			&actual_property_type,
			&actual_format,
			&actual_length,
			(guchar **) &data)) {
		gchar *actual_property_type_name;
		g_critical ("Unable to get _NET_CLIENT_LIST");
		actual_property_type_name = gdk_atom_name (actual_property_type);
		if (actual_property_type_name) {
			g_message ("actual_property_type: %s", actual_property_type_name);
			g_free (actual_property_type_name);
		}
		return NULL;
	}

	*count = actual_length / sizeof (long);
	list = g_malloc (*count * sizeof (guint));
	/* Put all of the windows into a GList to return */
	for (i = 0; i < *count; i ++) {
		list [i] = data [i];
		g_message ("WinID: %d", list [i]);
	}

	g_free (data);
	return list;
}
Ejemplo n.º 14
0
static int
get_initial_workspace (void)
{
  int ret = -1;
  GdkWindow *window;
  guchar *data = NULL;
  GdkAtom atom;
  GdkAtom cardinal_atom;

  window = gdk_get_default_root_window();

  atom = gdk_atom_intern_static_string ("_NET_CURRENT_DESKTOP");
  cardinal_atom = gdk_atom_intern_static_string ("CARDINAL");

  if (gdk_property_get (window, atom, cardinal_atom, 0, 8, FALSE, NULL, NULL, NULL, &data)) {
	  ret = *(int *)data;
	  g_free (data);
  }
  return ret;
}
Ejemplo n.º 15
0
static GtkWindowState
getWindowState (GtkWidget *window)
{
	GdkWindow *gdkWindow = window->window;
	GdkAtom actualType;
	gint actualFormat, actualLength;
	glong *data;
	GtkWindowState state = WITHDRAWN_STATE;

	if (window == NULL)
		return WITHDRAWN_STATE;

	if (gdk_property_get (gdkWindow, WM_STATE, WM_STATE, 0, 1, FALSE, &actualType, &actualFormat, &actualLength, (guchar **)&data))
	{
		state = (GtkWindowState)*data;
		g_free (data);
	}

	return state;
}
Ejemplo n.º 16
0
GList*
gdk_get_net_supported () {
	GdkAtom actual_property_type;
	int actual_format;
	int actual_length;
	long *data = NULL;
	GList *list = NULL;
	unsigned short i;

	if (!gdk_property_get(gdk_screen_get_root_window(gdk_screen_get_default()),
	                      gdk_atom_intern("_NET_SUPPORTED", FALSE),
	                      gdk_atom_intern("ATOM", FALSE),
	                      0,
	                      G_MAXLONG,
	                      FALSE,
	                      &actual_property_type,
	                      &actual_format,
	                      &actual_length,
	                      (guchar**)&data)) {
		gchar *actual_property_type_name;
		LOG_ERR("unable to get _NET_SUPPORTED");
		actual_property_type_name = gdk_atom_name(actual_property_type);
		if (actual_property_type_name) {
			LOG_INFO("actual_property_type: %s", actual_property_type_name);
			g_free(actual_property_type_name);
		}

		return NULL;
	}

	/* Put all of the GdkAtoms into a GList to return */
	for (i = 0; i < actual_length / sizeof(long); i++) {
		list = g_list_append(list, (GdkAtom)data[i]);
	}

	g_free(data);

	return list;
}
Ejemplo n.º 17
0
/* The following three functions taken from bugzilla
 * (http://bugzilla.gnome.org/attachment.cgi?id=49362&action=view)
 * Author: Christian Neumair
 * Copyright: 2005 Free Software Foundation, Inc
 * License: GPL */
static char *
xds_get_atom_value (GdkDragContext *context)
{
	GdkWindow *source_window;
	char *ret;
	gint len;

	g_return_val_if_fail (context != NULL, NULL);

	source_window = gdk_drag_context_get_source_window (context);
	g_return_val_if_fail (source_window != NULL, NULL);

	if (gdk_property_get (source_window,
	                      XDS_ATOM, TEXT_ATOM,
	                      0, MAX_XDS_ATOM_VAL_LEN,
	                      FALSE, NULL, NULL, &len,
	                      (unsigned char **) &ret)) {
		ret[len]='\0';
		return ret;
	}

	return NULL;
}
gchar *xfce_background_get_current_image()
{
	GdkAtom atom;
	gint fmt;
	gint len;
	/*guchar buf[2049];*/
	guchar *buf;
	buf = NULL;
	if (gdk_property_get(
		gdk_screen_get_root_window(
gdk_display_get_default_screen(gdk_display_get_default())		
		),
		gdk_atom_intern("XFDESKTOP_IMAGE_FILE_0", FALSE),
		gdk_x11_xatom_to_atom(XA_STRING), 
		0, 2048, 0, 
		&atom, &fmt, &len, 
		&buf) && fmt == 8) 
	{
		buf[len] = 0;
		return buf;
	}
	return NULL;
}
Ejemplo n.º 19
0
// Get the display ICC profile of the monitor associated with the widget.
// For X display, uses the ICC profile specifications version 0.2 from
// http://burtonini.com/blog/computers/xicc
// Based on code from Gimp's modules/cdisplay_lcms.c
void dt_ctl_set_display_profile()
{
  if(!dt_control_running()) return;
  // make sure that no one gets a broken profile
  // FIXME: benchmark if the try is really needed when moving/resizing the window. Maybe we can just lock it and block
  if(pthread_rwlock_trywrlock(&darktable.control->xprofile_lock))
    return; // we are already updating the profile. Or someone is reading right now. Too bad we can't distinguish that. Whatever ...

  GtkWidget *widget = dt_ui_center(darktable.gui->ui);
  guint8 *buffer = NULL;
  gint buffer_size = 0;
  gchar *profile_source = NULL;

#if defined GDK_WINDOWING_X11

  // we will use the xatom no matter what configured when compiled without colord
  gboolean use_xatom = TRUE;
#if defined USE_COLORDGTK
  gboolean use_colord = TRUE;
  gchar *display_profile_source = dt_conf_get_string("ui_last/display_profile_source");
  if(display_profile_source)
  {
    if(!strcmp(display_profile_source, "xatom"))
      use_colord = FALSE;
    else if(!strcmp(display_profile_source, "colord"))
      use_xatom = FALSE;
    g_free(display_profile_source);
  }
#endif

  /* let's have a look at the xatom, just in case ... */
  if(use_xatom)
  {
    GdkScreen *screen = gtk_widget_get_screen(widget);
    if ( screen==NULL )
      screen = gdk_screen_get_default();
    int monitor = gdk_screen_get_monitor_at_window (screen, gtk_widget_get_window(widget));
    char *atom_name;
    if (monitor > 0)
      atom_name = g_strdup_printf("_ICC_PROFILE_%d", monitor);
    else
      atom_name = g_strdup("_ICC_PROFILE");

    profile_source = g_strdup_printf("xatom %s", atom_name);

    GdkAtom type = GDK_NONE;
    gint format = 0;
    gdk_property_get(gdk_screen_get_root_window(screen),
                    gdk_atom_intern(atom_name, FALSE), GDK_NONE,
                    0, 64 * 1024 * 1024, FALSE,
                    &type, &format, &buffer_size, &buffer);
    g_free(atom_name);
  }

#ifdef USE_COLORDGTK
  /* also try to get the profile from colord. this will set the value asynchronously! */
  if(use_colord)
  {
    CdWindow *window = cd_window_new();
    GtkWidget *center_widget = dt_ui_center(darktable.gui->ui);
    cd_window_get_profile(window, center_widget, NULL, dt_ctl_get_display_profile_colord_callback, NULL);
  }
#endif

#elif defined GDK_WINDOWING_QUARTZ
  GdkScreen *screen = gtk_widget_get_screen(widget);
  if ( screen==NULL )
    screen = gdk_screen_get_default();
  int monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(widget));

  CGDirectDisplayID ids[monitor + 1];
  uint32_t total_ids;
  CMProfileRef prof = NULL;
  if(CGGetOnlineDisplayList(monitor + 1, &ids[0], &total_ids) == kCGErrorSuccess && total_ids == monitor + 1)
    CMGetProfileByAVID(ids[monitor], &prof);
  if ( prof!=NULL )
  {
    CFDataRef data;
    data = CMProfileCopyICCData(NULL, prof);
    CMCloseProfile(prof);

    UInt8 *tmp_buffer = (UInt8 *) g_malloc(CFDataGetLength(data));
    CFDataGetBytes(data, CFRangeMake(0, CFDataGetLength(data)), tmp_buffer);

    buffer = (guint8 *) tmp_buffer;
    buffer_size = CFDataGetLength(data);

    CFRelease(data);
  }
  profile_source = g_strdup("osx color profile api");
#elif defined G_OS_WIN32
  (void)widget;
  HDC hdc = GetDC (NULL);
  if ( hdc!=NULL )
  {
    DWORD len = 0;
    GetICMProfile (hdc, &len, NULL);
    gchar *path = g_new (gchar, len);

    if (GetICMProfile (hdc, &len, path))
    {
      gsize size;
      g_file_get_contents(path, (gchar**)&buffer, &size, NULL);
      buffer_size = size;
    }
    g_free (path);
    ReleaseDC (NULL, hdc);
  }
  profile_source = g_strdup("windows color profile api");
#endif

  int profile_changed = buffer_size > 0 &&
                        (darktable.control->xprofile_size != buffer_size || memcmp(darktable.control->xprofile_data, buffer, buffer_size) != 0);
  if(profile_changed)
  {
    cmsHPROFILE profile = NULL;
    char name[512];
    // thanks to ufraw for this!
    g_free(darktable.control->xprofile_data);
    darktable.control->xprofile_data = buffer;
    darktable.control->xprofile_size = buffer_size;
    profile = cmsOpenProfileFromMem(buffer, buffer_size);
    if(profile)
    {
      dt_colorspaces_get_profile_name(profile, "en", "US", name, sizeof(name));
      cmsCloseProfile(profile);
    }
    dt_print(DT_DEBUG_CONTROL, "[color profile] we got a new screen profile `%s' from the %s (size: %d)\n", *name?name:"(unknown)", profile_source, buffer_size);
  }
  pthread_rwlock_unlock(&darktable.control->xprofile_lock);
  if(profile_changed)
    dt_control_signal_raise(darktable.signals, DT_SIGNAL_CONTROL_PROFILE_CHANGED);
  g_free(profile_source);
}
Ejemplo n.º 20
0
void
nsCairoScreen::Init ()
{
#ifdef MOZ_ENABLE_GTK2
    mAvailRect = mRect = nsRect(0, 0, gdk_screen_width(), gdk_screen_height());
    // We need to account for the taskbar, etc in the available rect.
    // See http://freedesktop.org/Standards/wm-spec/index.html#id2767771

    // XXX It doesn't change that often, but we should probably
    // listen for changes to _NET_WORKAREA.
    // XXX do we care about _NET_WM_STRUT_PARTIAL?  That will
    // add much more complexity to the code here (our screen
    // could have a non-rectangular shape), but should
    // lead to greater accuracy.

#if GTK_CHECK_VERSION(2,2,0)
    GdkWindow *root_window = gdk_get_default_root_window();
#else
    GdkWindow *root_window = GDK_ROOT_PARENT();
#endif // GTK_CHECK_VERSION(2,2,0)

    long *workareas;
    GdkAtom type_returned;
    int format_returned;
    int length_returned;

#if GTK_CHECK_VERSION(2,0,0)
    GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
#else
    GdkAtom cardinal_atom = (GdkAtom) XA_CARDINAL;
#endif

    gdk_error_trap_push();

    // gdk_property_get uses (length + 3) / 4, hence G_MAXLONG - 3 here.
    if (!gdk_property_get(root_window,
                          gdk_atom_intern ("_NET_WORKAREA", FALSE),
                          cardinal_atom,
                          0, G_MAXLONG - 3, FALSE,
                          &type_returned,
                          &format_returned,
                          &length_returned,
                          (guchar **) &workareas)) {
        // This window manager doesn't support the freedesktop standard.
        // Nothing we can do about it, so assume full screen size.
        return;
    }

    // Flush the X queue to catch errors now.
    gdk_flush();

    if (!gdk_error_trap_pop() &&
        type_returned == cardinal_atom &&
        length_returned && (length_returned % 4) == 0 &&
        format_returned == 32) {
        int num_items = length_returned / sizeof(long);

        for (int i = 0; i < num_items; i += 4) {
            nsRect workarea(workareas[i],     workareas[i + 1],
                            workareas[i + 2], workareas[i + 3]);
            if (!mRect.Contains(workarea)) {
                NS_WARNING("Invalid bounds");
                continue;
            }

            mAvailRect.IntersectRect(mAvailRect, workarea);
        }
    }

#elif MOZ_ENABLE_XLIB
    mScreenNum = 0;
    mRect.x = mAvailRect.x = 0;
    mRect.y = mAvailRect.y = 0;
    mRect.width = mAvailRect.width = 1600;
    mRect.height = mAvailRect.height = 1200;
#endif
}
Ejemplo n.º 21
0
static cmsHPROFILE
cdisplay_lcms_get_display_profile (CdisplayLcms *lcms)
{
  GimpColorConfig *config;
  cmsHPROFILE      profile = NULL;

  config = gimp_color_display_get_config (GIMP_COLOR_DISPLAY (lcms));

#if defined GDK_WINDOWING_X11
  if (config->display_profile_from_gdk)
    {
      GdkScreen *screen;
      GdkAtom    type    = GDK_NONE;
      gint       format  = 0;
      gint       nitems  = 0;
      gint       monitor = 0;
      gchar     *atom_name;
      guchar    *data    = NULL;

      screen = cdisplay_lcms_get_screen (lcms, &monitor);

      if (monitor > 0)
        atom_name = g_strdup_printf ("_ICC_PROFILE_%d", monitor);
      else
        atom_name = g_strdup ("_ICC_PROFILE");

      if (gdk_property_get (gdk_screen_get_root_window (screen),
                            gdk_atom_intern (atom_name, FALSE),
                            GDK_NONE,
                            0, 64 * 1024 * 1024, FALSE,
                            &type, &format, &nitems, &data) && nitems > 0)
        {
          profile = cmsOpenProfileFromMem (data, nitems);
          g_free (data);
        }

      g_free (atom_name);
    }

#elif defined GDK_WINDOWING_QUARTZ
  if (config->display_profile_from_gdk)
    {
      CMProfileRef  prof    = NULL;
      gint          monitor = 0;

      cdisplay_lcms_get_screen (lcms, &monitor);

      CMGetProfileByAVID (monitor, &prof);

      if (prof)
        {
          CFDataRef data;

          data = CMProfileCopyICCData (NULL, prof);
          CMCloseProfile (prof);

          if (data)
            {
              UInt8 *buffer = g_malloc (CFDataGetLength (data));

              /* We cannot use CFDataGetBytesPtr(), because that returns
               * a const pointer where cmsOpenProfileFromMem wants a
               * non-const pointer.
               */
              CFDataGetBytes (data, CFRangeMake (0, CFDataGetLength (data)),
                              buffer);

              profile = cmsOpenProfileFromMem (buffer, CFDataGetLength (data));

              g_free (buffer);
              CFRelease (data);
            }
        }
    }

#elif defined G_OS_WIN32
  if (config->display_profile_from_gdk)
    {
      HDC hdc = GetDC (NULL);

      if (hdc)
        {
          gchar *path;
          gint32 len = 0;

          GetICMProfile (hdc, &len, NULL);
          path = g_new (gchar, len);

          if (GetICMProfile (hdc, &len, path))
            profile = cmsOpenProfileFromFile (path, "r");

          g_free (path);
          ReleaseDC (NULL, hdc);
        }
    }
#endif

  if (! profile && config->display_profile)
    profile = cmsOpenProfileFromFile (config->display_profile, "r");

  return profile;
}
Ejemplo n.º 22
0
void
nsScreenGtk :: Init (GdkWindow *aRootWindow)
{
  // We listen for configure events on the root window to pick up
  // changes to this rect.  We could listen for "size_changed" signals
  // on the default screen to do this, except that doesn't work with
  // versions of GDK predating the GdkScreen object.  See bug 256646.
  mAvailRect = mRect = nsIntRect(0, 0, gdk_screen_width(), gdk_screen_height());

#ifdef MOZ_X11
  // We need to account for the taskbar, etc in the available rect.
  // See http://freedesktop.org/Standards/wm-spec/index.html#id2767771

  // XXX do we care about _NET_WM_STRUT_PARTIAL?  That will
  // add much more complexity to the code here (our screen
  // could have a non-rectangular shape), but should
  // lead to greater accuracy.

  long *workareas;
  GdkAtom type_returned;
  int format_returned;
  int length_returned;

#if GTK_CHECK_VERSION(2,0,0)
  GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
#else
  GdkAtom cardinal_atom = (GdkAtom) XA_CARDINAL;
#endif

  gdk_error_trap_push();

  // gdk_property_get uses (length + 3) / 4, hence G_MAXLONG - 3 here.
  if (!gdk_property_get(aRootWindow,
                        gdk_atom_intern ("_NET_WORKAREA", FALSE),
                        cardinal_atom,
                        0, G_MAXLONG - 3, FALSE,
                        &type_returned,
                        &format_returned,
                        &length_returned,
                        (guchar **) &workareas)) {
    // This window manager doesn't support the freedesktop standard.
    // Nothing we can do about it, so assume full screen size.
    return;
  }

  // Flush the X queue to catch errors now.
  gdk_flush();

  if (!gdk_error_trap_pop() &&
      type_returned == cardinal_atom &&
      length_returned && (length_returned % 4) == 0 &&
      format_returned == 32) {
    int num_items = length_returned / sizeof(long);

    for (int i = 0; i < num_items; i += 4) {
      nsIntRect workarea(workareas[i],     workareas[i + 1],
                         workareas[i + 2], workareas[i + 3]);
      if (!mRect.Contains(workarea)) {
        // Note that we hit this when processing screen size changes,
        // since we'll get the configure event before the toolbars have
        // been moved.  We'll end up cleaning this up when we get the
        // change notification to the _NET_WORKAREA property.  However,
        // we still want to listen to both, so we'll handle changes
        // properly for desktop environments that don't set the
        // _NET_WORKAREA property.
        NS_WARNING("Invalid bounds");
        continue;
      }

      mAvailRect.IntersectRect(mAvailRect, workarea);
    }
  }
  g_free (workareas);
#endif
}
Ejemplo n.º 23
0
gboolean fm_dnd_dest_drag_drop(FmDndDest* dd, GdkDragContext *drag_context,
                               GdkAtom target, guint time)
{
    gboolean ret = FALSE;
    GtkWidget* dest_widget = dd->widget;
    int i;
    for(i = 0; i < G_N_ELEMENTS(fm_default_dnd_dest_targets); ++i)
    {
        if(gdk_atom_intern_static_string(fm_default_dnd_dest_targets[i].target) == target)
        {
            ret = TRUE;
            break;
        }
    }
    if(ret) /* we support this kind of target */
    {
        if(i == FM_DND_DEST_TARGET_XDS) /* if this is XDS */
        {
            guchar *data = NULL;
            gint len = 0;
            GdkAtom text_atom = gdk_atom_intern_static_string("text/plain");
            /* get filename from the source window */
            if(gdk_property_get(drag_context->source_window, xds_target_atom, text_atom,
                                0, 1024, FALSE, NULL, NULL,
                                &len, &data) && data)
            {
                FmFileInfo* dest = fm_dnd_dest_get_dest_file(dd);
                if( dest && fm_file_info_is_dir(dest) )
                {
                    FmPath* path = fm_path_new_child(dest->path, data);
                    char* uri = fm_path_to_uri(path);
                    /* setup the property */
                    gdk_property_change(GDK_DRAWABLE(drag_context->source_window), xds_target_atom,
                                       text_atom, 8, GDK_PROP_MODE_REPLACE, (const guchar *)uri,
                                       strlen(uri) + 1);
                    fm_path_unref(path);
                    g_free(uri);
                }
            }
            else
            {
                fm_show_error(gtk_widget_get_toplevel(dest_widget),
                              _("XDirectSave failed."));
                gdk_property_change(GDK_DRAWABLE(drag_context->source_window), xds_target_atom,
                                   text_atom, 8, GDK_PROP_MODE_REPLACE, (const guchar *)"", 0);
            }
            g_free(data);
            gtk_drag_get_data(dest_widget, drag_context, target, time);
            /* we should call gtk_drag_finish later in data-received callback. */
            return TRUE;
        }

        /* see if the drag files are cached */
        if(dd->src_files)
        {
            /* emit files-dropped signal */
            g_signal_emit(dd, signals[FILES_DROPPED], 0, drag_context->action, dd->info_type, dd->src_files, &ret);
        }
        else /* we don't have the data */
        {
            if(dd->waiting_data) /* if we're still waiting for the data */
            {
                /* FIXME: how to handle this? */
                ret = FALSE;
            }
            else
                ret = FALSE;
        }
        gtk_drag_finish(drag_context, ret, FALSE, time);
    }
    return ret;
}
Ejemplo n.º 24
0
/**
 * gimp_monitor_get_color_profile:
 * @monitor: a #GdkMonitor
 *
 * This function returns the #GimpColorProfile of @monitor
 * or %NULL if there is no profile configured.
 *
 * Since: 3.0
 *
 * Return value: the monitor's #GimpColorProfile, or %NULL.
 **/
GimpColorProfile *
gimp_monitor_get_color_profile (GdkMonitor *monitor)
{
  GdkDisplay       *display;
  GdkScreen        *screen;
  GimpColorProfile *profile = NULL;

  g_return_val_if_fail (GDK_IS_MONITOR (monitor), NULL);

  display = gdk_monitor_get_display (monitor);

#if defined GDK_WINDOWING_X11
  {
    GdkAtom  type    = GDK_NONE;
    gint     format  = 0;
    gint     nitems  = 0;
    gint     number;
    gchar   *atom_name;
    guchar  *data    = NULL;

    number = monitor_number (monitor);

    if (number > 0)
      atom_name = g_strdup_printf ("_ICC_PROFILE_%d", number);
    else
      atom_name = g_strdup ("_ICC_PROFILE");

    screen = gdk_display_get_default_screen (display);

    if (gdk_property_get (gdk_screen_get_root_window (screen),
                          gdk_atom_intern (atom_name, FALSE),
                          GDK_NONE,
                          0, 64 * 1024 * 1024, FALSE,
                          &type, &format, &nitems, &data) && nitems > 0)
      {
        profile = gimp_color_profile_new_from_icc_profile (data, nitems,
                                                           NULL);
        g_free (data);
      }

    g_free (atom_name);
  }
#elif defined GDK_WINDOWING_QUARTZ
  {
    CGColorSpaceRef space = NULL;

    space = CGDisplayCopyColorSpace (monitor_number (monitor));

    if (space)
      {
        CFDataRef data;

        data = CGColorSpaceCopyICCData (space);

        if (data)
          {
            UInt8 *buffer = g_malloc (CFDataGetLength (data));

            /* We cannot use CFDataGetBytesPtr(), because that returns
             * a const pointer where cmsOpenProfileFromMem wants a
             * non-const pointer.
             */
            CFDataGetBytes (data, CFRangeMake (0, CFDataGetLength (data)),
                            buffer);

            profile = gimp_color_profile_new_from_icc_profile (buffer,
                                                               CFDataGetLength (data),
                                                               NULL);

            g_free (buffer);
            CFRelease (data);
          }

        CFRelease (space);
      }
  }
#elif defined G_OS_WIN32
  {
    HDC hdc = GetDC (NULL);

    if (hdc)
      {
        gchar  *path;
        gint32  len = 0;

        GetICMProfile (hdc, (LPDWORD) &len, NULL);
        path = g_new (gchar, len);

        if (GetICMProfile (hdc, (LPDWORD) &len, path))
          {
            GFile *file = g_file_new_for_path (path);

            profile = gimp_color_profile_new_from_file (file, NULL);
            g_object_unref (file);
          }

        g_free (path);
        ReleaseDC (NULL, hdc);
      }
  }
#endif

  return profile;
}
Ejemplo n.º 25
0
static gboolean handle_real_button_press_event (GtkWidget* base, GdkEventButton* event) {
	Handle * self;
	gboolean result = FALSE;
	GdkEventButton _tmp0_;
	guint _tmp1_;
	gint _tmp2_;
	gint _tmp3_;
	GdkRectangle _tmp4_ = {0};
	GdkRectangle _tmp5_;
	gint x = 0;
	gint y = 0;
	GtkWidget* _tmp115_ = NULL;
	GtkWindow* _tmp116_;
	GtkWindow* toplevel;
	GtkWindow* _tmp117_;
	gint _tmp118_ = 0;
	gint _tmp119_ = 0;
	GdkEventButton _tmp120_;
	gdouble _tmp121_;
	gint _tmp122_;
	GdkEventButton _tmp123_;
	gdouble _tmp124_;
	gint _tmp125_;
	self = (Handle*) base;
	g_return_val_if_fail (event != NULL, FALSE);
	_tmp0_ = *event;
	_tmp1_ = _tmp0_.button;
	if (_tmp1_ != ((guint) 1)) {
		result = FALSE;
		return result;
	}
	_tmp2_ = G_MAXINT;
	_tmp3_ = G_MAXINT;
	memset (&_tmp4_, 0, sizeof (GdkRectangle));
	_tmp4_.x = 0;
	_tmp4_.y = 0;
	_tmp4_.width = _tmp2_;
	_tmp4_.height = _tmp3_;
	self->priv->m_workarea = _tmp4_;
	_tmp5_ = self->priv->m_workarea;
	{
		gboolean _tmp6_;
		_tmp6_ = TRUE;
		while (TRUE) {
			gboolean _tmp7_;
			GdkWindow* _tmp8_ = NULL;
			GdkWindow* _tmp9_;
			GdkWindow* root;
			GdkAtom _tmp10_ = 0U;
			GdkAtom property;
			GdkAtom _tmp11_ = 0U;
			GdkAtom type;
			GdkAtom actual_type = 0U;
			gint format = 0;
			guchar* data = NULL;
			gint data_length1 = 0;
			gint _data_size_ = 0;
			gboolean _result_ = FALSE;
			GdkWindow* _tmp12_;
			GdkAtom _tmp13_;
			GdkAtom _tmp14_;
			glong _tmp15_;
			GdkAtom _tmp16_ = 0U;
			gint _tmp17_ = 0;
			guint8* _tmp18_ = NULL;
			gint _tmp19_ = 0;
			gboolean _tmp20_ = FALSE;
			gboolean _tmp21_ = FALSE;
			gboolean _tmp22_ = FALSE;
			gboolean _tmp23_ = FALSE;
			gboolean _tmp24_;
			gboolean _tmp27_;
			gboolean _tmp29_;
			gboolean _tmp31_;
			guchar* _tmp32_;
			gint _tmp32__length1;
			guchar _tmp33_;
			guchar* _tmp34_;
			gint _tmp34__length1;
			guchar _tmp35_;
			guchar* _tmp36_;
			gint _tmp36__length1;
			guchar _tmp37_;
			guchar* _tmp38_;
			gint _tmp38__length1;
			guchar _tmp39_;
			gint index;
			GdkAtom _tmp40_ = 0U;
			GdkAtom _tmp41_ = 0U;
			GdkWindow* _tmp42_;
			GdkAtom _tmp43_;
			GdkAtom _tmp44_;
			glong _tmp45_;
			GdkAtom _tmp46_ = 0U;
			gint _tmp47_ = 0;
			guint8* _tmp48_ = NULL;
			gint _tmp49_ = 0;
			gboolean _tmp50_ = FALSE;
			gboolean _tmp51_ = FALSE;
			gboolean _tmp52_ = FALSE;
			gboolean _tmp53_ = FALSE;
			gboolean _tmp54_;
			gboolean _tmp57_;
			gboolean _tmp59_;
			gboolean _tmp62_;
			gint _tmp63_;
			gint i;
			guchar* _tmp64_;
			gint _tmp64__length1;
			gint _tmp65_;
			guchar _tmp66_;
			guchar* _tmp67_;
			gint _tmp67__length1;
			gint _tmp68_;
			guchar _tmp69_;
			guchar* _tmp70_;
			gint _tmp70__length1;
			gint _tmp71_;
			guchar _tmp72_;
			guchar* _tmp73_;
			gint _tmp73__length1;
			gint _tmp74_;
			guchar _tmp75_;
			gint _tmp76_;
			guchar* _tmp77_;
			gint _tmp77__length1;
			gint _tmp78_;
			guchar _tmp79_;
			guchar* _tmp80_;
			gint _tmp80__length1;
			gint _tmp81_;
			guchar _tmp82_;
			guchar* _tmp83_;
			gint _tmp83__length1;
			gint _tmp84_;
			guchar _tmp85_;
			guchar* _tmp86_;
			gint _tmp86__length1;
			gint _tmp87_;
			guchar _tmp88_;
			gint _tmp89_;
			guchar* _tmp90_;
			gint _tmp90__length1;
			gint _tmp91_;
			guchar _tmp92_;
			guchar* _tmp93_;
			gint _tmp93__length1;
			gint _tmp94_;
			guchar _tmp95_;
			guchar* _tmp96_;
			gint _tmp96__length1;
			gint _tmp97_;
			guchar _tmp98_;
			guchar* _tmp99_;
			gint _tmp99__length1;
			gint _tmp100_;
			guchar _tmp101_;
			gint _tmp102_;
			guchar* _tmp103_;
			gint _tmp103__length1;
			gint _tmp104_;
			guchar _tmp105_;
			guchar* _tmp106_;
			gint _tmp106__length1;
			gint _tmp107_;
			guchar _tmp108_;
			guchar* _tmp109_;
			gint _tmp109__length1;
			gint _tmp110_;
			guchar _tmp111_;
			guchar* _tmp112_;
			gint _tmp112__length1;
			gint _tmp113_;
			guchar _tmp114_;
			_tmp7_ = _tmp6_;
			if (!_tmp7_) {
				if (!FALSE) {
					break;
				}
			}
			_tmp6_ = FALSE;
			_tmp8_ = gdk_get_default_root_window ();
			_tmp9_ = _g_object_ref0 (_tmp8_);
			root = _tmp9_;
			_tmp10_ = gdk_atom_intern ("_NET_CURRENT_DESKTOP", FALSE);
			property = _tmp10_;
			_tmp11_ = gdk_atom_intern ("CARDINAL", FALSE);
			type = _tmp11_;
			_tmp12_ = root;
			_tmp13_ = property;
			_tmp14_ = type;
			_tmp15_ = G_MAXLONG;
			_tmp20_ = gdk_property_get (_tmp12_, _tmp13_, _tmp14_, (gulong) 0, (gulong) _tmp15_, 0, &_tmp16_, &_tmp17_, &_tmp19_, &_tmp18_);
			actual_type = _tmp16_;
			format = _tmp17_;
			data = (g_free (data), NULL);
			data = _tmp18_;
			data_length1 = _tmp19_;
			_data_size_ = data_length1;
			_result_ = _tmp20_;
			_tmp24_ = _result_;
			if (!_tmp24_) {
				_tmp23_ = TRUE;
			} else {
				GdkAtom _tmp25_;
				GdkAtom _tmp26_;
				_tmp25_ = actual_type;
				_tmp26_ = type;
				_tmp23_ = _tmp25_ != _tmp26_;
			}
			_tmp27_ = _tmp23_;
			if (_tmp27_) {
				_tmp22_ = TRUE;
			} else {
				gint _tmp28_;
				_tmp28_ = format;
				_tmp22_ = _tmp28_ != 32;
			}
			_tmp29_ = _tmp22_;
			if (_tmp29_) {
				_tmp21_ = TRUE;
			} else {
				guchar* _tmp30_;
				gint _tmp30__length1;
				_tmp30_ = data;
				_tmp30__length1 = data_length1;
				_tmp21_ = _tmp30__length1 != 4;
			}
			_tmp31_ = _tmp21_;
			if (_tmp31_) {
				data = (g_free (data), NULL);
				_g_object_unref0 (root);
				break;
			}
			_tmp32_ = data;
			_tmp32__length1 = data_length1;
			_tmp33_ = _tmp32_[0];
			_tmp34_ = data;
			_tmp34__length1 = data_length1;
			_tmp35_ = _tmp34_[1];
			_tmp36_ = data;
			_tmp36__length1 = data_length1;
			_tmp37_ = _tmp36_[2];
			_tmp38_ = data;
			_tmp38__length1 = data_length1;
			_tmp39_ = _tmp38_[3];
			index = (gint) (((_tmp33_ | (_tmp35_ << 8)) | (_tmp37_ << 16)) | (_tmp39_ << 24));
			_tmp40_ = gdk_atom_intern ("_NET_WORKAREA", FALSE);
			property = _tmp40_;
			_tmp41_ = gdk_atom_intern ("CARDINAL", FALSE);
			type = _tmp41_;
			_tmp42_ = root;
			_tmp43_ = property;
			_tmp44_ = type;
			_tmp45_ = G_MAXLONG;
			_tmp50_ = gdk_property_get (_tmp42_, _tmp43_, _tmp44_, (gulong) 0, (gulong) _tmp45_, 0, &_tmp46_, &_tmp47_, &_tmp49_, &_tmp48_);
			actual_type = _tmp46_;
			format = _tmp47_;
			data = (g_free (data), NULL);
			data = _tmp48_;
			data_length1 = _tmp49_;
			_data_size_ = data_length1;
			_result_ = _tmp50_;
			_tmp54_ = _result_;
			if (!_tmp54_) {
				_tmp53_ = TRUE;
			} else {
				GdkAtom _tmp55_;
				GdkAtom _tmp56_;
				_tmp55_ = actual_type;
				_tmp56_ = type;
				_tmp53_ = _tmp55_ != _tmp56_;
			}
			_tmp57_ = _tmp53_;
			if (_tmp57_) {
				_tmp52_ = TRUE;
			} else {
				gint _tmp58_;
				_tmp58_ = format;
				_tmp52_ = _tmp58_ != 32;
			}
			_tmp59_ = _tmp52_;
			if (_tmp59_) {
				_tmp51_ = TRUE;
			} else {
				guchar* _tmp60_;
				gint _tmp60__length1;
				gint _tmp61_;
				_tmp60_ = data;
				_tmp60__length1 = data_length1;
				_tmp61_ = index;
				_tmp51_ = _tmp60__length1 < ((_tmp61_ + 1) * 16);
			}
			_tmp62_ = _tmp51_;
			if (_tmp62_) {
				data = (g_free (data), NULL);
				_g_object_unref0 (root);
				break;
			}
			_tmp63_ = index;
			i = (_tmp63_ * 4) * 4;
			_tmp64_ = data;
			_tmp64__length1 = data_length1;
			_tmp65_ = i;
			_tmp66_ = _tmp64_[_tmp65_];
			_tmp67_ = data;
			_tmp67__length1 = data_length1;
			_tmp68_ = i;
			_tmp69_ = _tmp67_[_tmp68_ + 1];
			_tmp70_ = data;
			_tmp70__length1 = data_length1;
			_tmp71_ = i;
			_tmp72_ = _tmp70_[_tmp71_ + 2];
			_tmp73_ = data;
			_tmp73__length1 = data_length1;
			_tmp74_ = i;
			_tmp75_ = _tmp73_[_tmp74_ + 3];
			self->priv->m_workarea.x = (gint) (((_tmp66_ | (_tmp69_ << 8)) | (_tmp72_ << 16)) | (_tmp75_ << 24));
			_tmp76_ = i;
			i = _tmp76_ + 4;
			_tmp77_ = data;
			_tmp77__length1 = data_length1;
			_tmp78_ = i;
			_tmp79_ = _tmp77_[_tmp78_];
			_tmp80_ = data;
			_tmp80__length1 = data_length1;
			_tmp81_ = i;
			_tmp82_ = _tmp80_[_tmp81_ + 1];
			_tmp83_ = data;
			_tmp83__length1 = data_length1;
			_tmp84_ = i;
			_tmp85_ = _tmp83_[_tmp84_ + 2];
			_tmp86_ = data;
			_tmp86__length1 = data_length1;
			_tmp87_ = i;
			_tmp88_ = _tmp86_[_tmp87_ + 3];
			self->priv->m_workarea.y = (gint) (((_tmp79_ | (_tmp82_ << 8)) | (_tmp85_ << 16)) | (_tmp88_ << 24));
			_tmp89_ = i;
			i = _tmp89_ + 4;
			_tmp90_ = data;
			_tmp90__length1 = data_length1;
			_tmp91_ = i;
			_tmp92_ = _tmp90_[_tmp91_];
			_tmp93_ = data;
			_tmp93__length1 = data_length1;
			_tmp94_ = i;
			_tmp95_ = _tmp93_[_tmp94_ + 1];
			_tmp96_ = data;
			_tmp96__length1 = data_length1;
			_tmp97_ = i;
			_tmp98_ = _tmp96_[_tmp97_ + 2];
			_tmp99_ = data;
			_tmp99__length1 = data_length1;
			_tmp100_ = i;
			_tmp101_ = _tmp99_[_tmp100_ + 3];
			self->priv->m_workarea.width = (gint) (((_tmp92_ | (_tmp95_ << 8)) | (_tmp98_ << 16)) | (_tmp101_ << 24));
			_tmp102_ = i;
			i = _tmp102_ + 4;
			_tmp103_ = data;
			_tmp103__length1 = data_length1;
			_tmp104_ = i;
			_tmp105_ = _tmp103_[_tmp104_];
			_tmp106_ = data;
			_tmp106__length1 = data_length1;
			_tmp107_ = i;
			_tmp108_ = _tmp106_[_tmp107_ + 1];
			_tmp109_ = data;
			_tmp109__length1 = data_length1;
			_tmp110_ = i;
			_tmp111_ = _tmp109_[_tmp110_ + 2];
			_tmp112_ = data;
			_tmp112__length1 = data_length1;
			_tmp113_ = i;
			_tmp114_ = _tmp112_[_tmp113_ + 3];
			self->priv->m_workarea.height = (gint) (((_tmp105_ | (_tmp108_ << 8)) | (_tmp111_ << 16)) | (_tmp114_ << 24));
			data = (g_free (data), NULL);
			_g_object_unref0 (root);
		}
	}
	self->priv->m_move_begined = TRUE;
	_tmp115_ = gtk_widget_get_toplevel ((GtkWidget*) self);
	_tmp116_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp115_, GTK_TYPE_WINDOW, GtkWindow));
	toplevel = _tmp116_;
	_tmp117_ = toplevel;
	gtk_window_get_position (_tmp117_, &_tmp118_, &_tmp119_);
	x = _tmp118_;
	y = _tmp119_;
	_tmp120_ = *event;
	_tmp121_ = _tmp120_.x_root;
	_tmp122_ = x;
	self->priv->m_press_pos.x = ((gint) _tmp121_) - _tmp122_;
	_tmp123_ = *event;
	_tmp124_ = _tmp123_.y_root;
	_tmp125_ = y;
	self->priv->m_press_pos.y = ((gint) _tmp124_) - _tmp125_;
	g_signal_emit_by_name (self, "move-begin");
	result = TRUE;
	_g_object_unref0 (toplevel);
	return result;
}
Ejemplo n.º 26
0
GimpColorProfile *
gimp_widget_get_color_profile (GtkWidget *widget)
{
    GimpColorProfile *profile = NULL;
    GdkScreen        *screen;
    gint              monitor;

    g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);

    if (widget)
    {
        screen  = gtk_widget_get_screen (widget);
        monitor = gimp_widget_get_monitor (widget);
    }
    else
    {
        screen  = gdk_screen_get_default ();
        monitor = 0;
    }

#if defined GDK_WINDOWING_X11
    {
        GdkAtom  type    = GDK_NONE;
        gint     format  = 0;
        gint     nitems  = 0;
        gchar   *atom_name;
        guchar  *data    = NULL;

        if (monitor > 0)
            atom_name = g_strdup_printf ("_ICC_PROFILE_%d", monitor);
        else
            atom_name = g_strdup ("_ICC_PROFILE");

        if (gdk_property_get (gdk_screen_get_root_window (screen),
                              gdk_atom_intern (atom_name, FALSE),
                              GDK_NONE,
                              0, 64 * 1024 * 1024, FALSE,
                              &type, &format, &nitems, &data) && nitems > 0)
        {
            profile = gimp_color_profile_new_from_icc_profile (data, nitems,
                      NULL);
            g_free (data);
        }

        g_free (atom_name);
    }
#elif defined GDK_WINDOWING_QUARTZ
    {
        CMProfileRef prof = NULL;

        CMGetProfileByAVID (monitor, &prof);

        if (prof)
        {
            CFDataRef data;

            data = CMProfileCopyICCData (NULL, prof);
            CMCloseProfile (prof);

            if (data)
            {
                UInt8 *buffer = g_malloc (CFDataGetLength (data));

                /* We cannot use CFDataGetBytesPtr(), because that returns
                 * a const pointer where cmsOpenProfileFromMem wants a
                 * non-const pointer.
                 */
                CFDataGetBytes (data, CFRangeMake (0, CFDataGetLength (data)),
                                buffer);

                profile = gimp_color_profile_new_from_icc_profile (data,
                          CFDataGetLength (data),
                          NULL);

                g_free (buffer);
                CFRelease (data);
            }
        }
    }
#elif defined G_OS_WIN32
    {
        HDC hdc = GetDC (NULL);

        if (hdc)
        {
            gchar  *path;
            gint32  len = 0;

            GetICMProfile (hdc, &len, NULL);
            path = g_new (gchar, len);

            if (GetICMProfile (hdc, &len, path))
            {
                GFile *file = g_file_new_for_path (path);

                profile = gimp_color_profile_new_from_file (file, NULL);
                g_object_unref (file);
            }

            g_free (path);
            ReleaseDC (NULL, hdc);
        }
    }
#endif

    return profile;
}
Ejemplo n.º 27
0
gboolean
pre_event_handler (GtkWidget *widget, GdkEvent *event, jobject peer)
{
  GtkWidget *event_widget;
  static guint32 button_click_time = 0;
  static GdkWindow *button_window = NULL;
  static guint button_number = -1;
  static jint click_count = 1;

  /* If it is not a focus change event, the widget must be realized already.
     If not, ignore the event (Gtk+ will do the same). */
  if (!(event->type == GDK_FOCUS_CHANGE || GTK_WIDGET_REALIZED(widget)))
    return FALSE;
    
  /* Do not handle propagated events.  AWT has its own propagation rules */
  gdk_window_get_user_data (event->any.window, (void **) &event_widget);
  if (event_widget != widget)
    return FALSE;

  /* We only care about input events */    
  if (!(event->type == GDK_BUTTON_PRESS
       || event->type == GDK_BUTTON_RELEASE
       || event->type == GDK_ENTER_NOTIFY
       || event->type == GDK_LEAVE_NOTIFY
       || event->type == GDK_CONFIGURE
       || event->type == GDK_EXPOSE
       || event->type == GDK_KEY_PRESS
       || event->type == GDK_KEY_RELEASE
       || event->type == GDK_FOCUS_CHANGE
       || event->type == GDK_MOTION_NOTIFY))
    {
      return FALSE;
    }
  /* g_print("event %u widget %s peer %p\n",
            event->type, gtk_widget_get_name (widget), peer); */

  /* If it has no jobject associated we can send no AWT event */
  if (!peer)
    return FALSE;

  /* for all input events, which have a window with a jobject attached,
     send the AWT input event corresponding to the Gtk event off to Java  */

  /* keep track of clickCount ourselves, since the AWT allows more
     than a triple click to occur */
  if (event->type == GDK_BUTTON_PRESS)
    {
      if ((event->button.time < (button_click_time + MULTI_CLICK_TIME))
	  && (event->button.window == button_window)
	  && (event->button.button == button_number))
	click_count++;
      else
	click_count = 1;
      
      button_click_time = event->button.time;
      button_window = event->button.window;
      button_number = event->button.button;
    }

  switch (event->type)
    {
    case GDK_BUTTON_PRESS:
      (*gdk_env)->CallVoidMethod (gdk_env, peer,
                                  postMouseEventID,
				  AWT_MOUSE_PRESSED, 
				  (jlong)event->button.time,
				  state_to_awt_mods (event->button.state) |
				  button_to_awt_mods (event->button.button), 
				  (jint)event->button.x,
				  (jint)event->button.y, 
				  click_count, 
				  (event->button.button == 3) ? JNI_TRUE :
				                                JNI_FALSE);
      break;
    case GDK_BUTTON_RELEASE:
      {
	int width, height;

	(*gdk_env)->CallVoidMethod (gdk_env, peer,
				    postMouseEventID,
				    AWT_MOUSE_RELEASED, 
				    (jlong)event->button.time,
				    state_to_awt_mods (event->button.state) |
				    button_to_awt_mods (event->button.button), 
				    (jint)event->button.x,
				    (jint)event->button.y, 
				    click_count,
				    JNI_FALSE);

	/* check to see if the release occured in the window it was pressed
	   in, and if so, generate an AWT click event */
	gdk_window_get_size (event->any.window, &width, &height);
	if (event->button.x >= 0
            && event->button.y >= 0
	    && event->button.x <= width 
	    && event->button.y <= height)
          {
	    (*gdk_env)->CallVoidMethod (gdk_env, peer,
				        postMouseEventID,
				        AWT_MOUSE_CLICKED, 
				        (jlong)event->button.time,
				        state_to_awt_mods (event->button.state) |
				        button_to_awt_mods (event->button.button), 
				        (jint)event->button.x,
				        (jint)event->button.y, 
				        click_count,
				        JNI_FALSE);
          }
      }
      break;
    case GDK_MOTION_NOTIFY:
      (*gdk_env)->CallVoidMethod (gdk_env, peer, postMouseEventID,
				  AWT_MOUSE_MOVED,
				  (jlong)event->motion.time,
				  state_to_awt_mods (event->motion.state),
				  (jint)event->motion.x,
				  (jint)event->motion.y,
				  0,
				  JNI_FALSE);

      if (event->motion.state & (GDK_BUTTON1_MASK
				 | GDK_BUTTON2_MASK
				 | GDK_BUTTON3_MASK
				 | GDK_BUTTON4_MASK
				 | GDK_BUTTON5_MASK))
	{
	  (*gdk_env)->CallVoidMethod (gdk_env, peer,
			              postMouseEventID,
				      AWT_MOUSE_DRAGGED,
				      (jlong)event->motion.time,
				      state_to_awt_mods (event->motion.state),
				      (jint)event->motion.x,
				      (jint)event->motion.y,
				      0,
				      JNI_FALSE);
	}
      break;
    case GDK_ENTER_NOTIFY:
      (*gdk_env)->CallVoidMethod (gdk_env, peer, postMouseEventID,
				  AWT_MOUSE_ENTERED, 
				  (jlong)event->crossing.time,
				  state_to_awt_mods (event->crossing.state), 
				  (jint)event->crossing.x,
				  (jint)event->crossing.y, 
				  0,
				  JNI_FALSE);
      break;
    case GDK_LEAVE_NOTIFY:
      if (event->crossing.mode == GDK_CROSSING_NORMAL)
	(*gdk_env)->CallVoidMethod (gdk_env, peer,
				    postMouseEventID,
				    AWT_MOUSE_EXITED, 
				    (jlong)event->crossing.time,
				    state_to_awt_mods (event->crossing.state),
				    (jint)event->crossing.x,
				    (jint)event->crossing.y, 
				    0,
				    JNI_FALSE);
      break;
    case GDK_CONFIGURE:
      {
	/* GtkWidget *widget;

	gdk_window_get_user_data (event->any.window, (void **) &widget); */
	    
	if (widget && GTK_WIDGET_TOPLEVEL (widget))
	  {
	    /* Configure events are not posted to the AWT event
	       queue, and as such, the gdk/gtk peer functions will
	       be called back before postConfigureEvent
	       returns. */
	    gdk_threads_leave ();

 	    (*gdk_env)->CallVoidMethod (gdk_env, peer,
					postConfigureEventID,
					(jint) event->configure.x,
					(jint) event->configure.y,
					(jint) event->configure.width,
					(jint) event->configure.height);
	    gdk_threads_enter ();
	  }
      }
      break;
    case GDK_EXPOSE:
      {
	(*gdk_env)->CallVoidMethod (gdk_env, peer,
				    postExposeEventID,
				    (jint)event->expose.area.x,
				    (jint)event->expose.area.y,
				    (jint)event->expose.area.width,
				    (jint)event->expose.area.height);
      }
      break;
    case GDK_FOCUS_CHANGE:
      (*gdk_env)->CallVoidMethod (gdk_env, peer,
				  postFocusEventID,
				  (jint) (event->focus_change.in) ? 
				  AWT_FOCUS_GAINED : AWT_FOCUS_LOST,
				  JNI_FALSE);
      break;
    case GDK_KEY_PRESS:
    case GDK_KEY_RELEASE:
      {
        GdkWindow *obj_window;
        jobject *focus_obj_ptr = NULL;
	int generates_key_typed = 0;

        /* A widget with a grab will get key events */
	if (!GTK_IS_WINDOW (widget))
	  focus_obj_ptr = &peer;
	else
	  {
            GtkWindow *window;

            /* Check if we have an enabled focused widget in this window.
	       If not don't handle the event. */
	    window = GTK_WINDOW (widget);
	    if (!window->focus_widget
	        || !GTK_WIDGET_IS_SENSITIVE (window->focus_widget)
	        || !window->focus_widget->window)
	      return FALSE;
	
            /* TextArea peers are attached to the scrolled window
               that contains the GtkTextView, not to the text view
               itself.  Same for List. */
            if (GTK_IS_TEXT_VIEW (window->focus_widget)
                || GTK_IS_CLIST (window->focus_widget))
              {
                obj_window = gtk_widget_get_parent (window->focus_widget)->window;
              }
            else if (GTK_IS_BUTTON (window->focus_widget))
	      /* GtkButton events go to the "event_window" and this is what
	         we registered when the button was created. */
              obj_window = GTK_BUTTON (window->focus_widget)->event_window;
            else
              obj_window = window->focus_widget->window;

            gdk_property_get (obj_window,
                              gdk_atom_intern ("_GNU_GTKAWT_ADDR", FALSE),
                              gdk_atom_intern ("CARDINAL", FALSE),
                              0,
                              sizeof (jobject),
                              FALSE,
                              NULL,
                              NULL,
                              NULL,
                              (guchar **)&focus_obj_ptr);

            /* If the window has no jobject attached we can't send anything */
	    if (!focus_obj_ptr)
	      return FALSE;
	      
	    /* Should we generate an AWT_KEY_TYPED event? */
	    generates_key_typed = generates_key_typed_event (event, window->focus_widget);
	  }	

	if (event->type == GDK_KEY_PRESS)	
	  {
            (*gdk_env)->CallVoidMethod (gdk_env, *focus_obj_ptr,
				        postKeyEventID,
				        (jint) AWT_KEY_PRESSED,
				        (jlong) event->key.time,
                                        keyevent_state_to_awt_mods (event),
                                        keysym_to_awt_keycode (event),
                                        keyevent_to_awt_keychar (event),
                                        keysym_to_awt_keylocation (event));

            if (generates_key_typed)
              {
                (*gdk_env)->CallVoidMethod (gdk_env, *focus_obj_ptr,
                                            postKeyEventID,
                                            (jint) AWT_KEY_TYPED,
                                            (jlong) event->key.time,
                                            state_to_awt_mods (event->key.state),
                                            VK_UNDEFINED,
                                            keyevent_to_awt_keychar (event),
                                            AWT_KEY_LOCATION_UNKNOWN);
              }
          }
	else /* GDK_KEY_RELEASE */
          {
	    (*gdk_env)->CallVoidMethod (gdk_env, *focus_obj_ptr,
				        postKeyEventID,
				        (jint) AWT_KEY_RELEASED,
				        (jlong) event->key.time,
			                keyevent_state_to_awt_mods (event),
			                keysym_to_awt_keycode (event),
                                        keyevent_to_awt_keychar (event),
                                        keysym_to_awt_keylocation (event));
	  }
      }
      break;
    default:
      break;
    }
  
  return FALSE;
}