File colord-gtk-0.2.0+8.obscpio of Package colord-gtk

Overview Repositories Revisions Requests Users Attributes Meta

File colord-gtk-0.2.0+8.obscpio of Package colord-gtk (Revision 2c84c75a77baa41e2560bd4bb4dba752)

Currently displaying revision 2c84c75a77baa41e2560bd4bb4dba752 , Show latest

07070100000000000081A400000000000000000000000161CC381A00000025000000000000000000000000000000000000001B00000000colord-gtk-0.2.0+8/AUTHORSRichard Hughes <richard@hughsie.com>
07070100000001000081A400000000000000000000000161CC381A00001DE3000000000000000000000000000000000000001B00000000colord-gtk-0.2.0+8/COPYING                   GNU LESSER GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.

0. Additional Definitions.

As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.

"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.

An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.

A "Combined Work" is a work produced by combining or linking an
Application with the Library.  The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".

The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.

The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.

1. Exception to Section 3 of the GNU GPL.

You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.

2. Conveying Modified Versions.

If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:

a) under this License, provided that you make a good faith effort to
   ensure that, in the event an Application does not supply the
   function or data, the facility still operates, and performs
   whatever part of its purpose remains meaningful, or

b) under the GNU GPL, with none of the additional permissions of
   this License applicable to that copy.

3. Object Code Incorporating Material from Library Header Files.

The object code form of an Application may incorporate material from
a header file that is part of the Library.  You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:

a) Give prominent notice with each copy of the object code that the
   Library is used in it and that the Library and its use are
   covered by this License.

b) Accompany the object code with a copy of the GNU GPL and this license
   document.

4. Combined Works.

You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:

a) Give prominent notice with each copy of the Combined Work that
   the Library is used in it and that the Library and its use are
   covered by this License.

b) Accompany the Combined Work with a copy of the GNU GPL and this license
   document.

c) For a Combined Work that displays copyright notices during
   execution, include the copyright notice for the Library among
   these notices, as well as a reference directing the user to the
   copies of the GNU GPL and this license document.

d) Do one of the following:

0) Convey the Minimal Corresponding Source under the terms of this
       License, and the Corresponding Application Code in a form
       suitable for, and under terms that permit, the user to
       recombine or relink the Application with a modified version of
       the Linked Version to produce a modified Combined Work, in the
       manner specified by section 6 of the GNU GPL for conveying
       Corresponding Source.

1) Use a suitable shared library mechanism for linking with the
       Library.  A suitable mechanism is one that (a) uses at run time
       a copy of the Library already present on the user's computer
       system, and (b) will operate properly with a modified version
       of the Library that is interface-compatible with the Linked
       Version.

e) Provide Installation Information, but only if you would otherwise
   be required to provide such information under section 6 of the
   GNU GPL, and only to the extent that such information is
   necessary to install and execute a modified version of the
   Combined Work produced by recombining or relinking the
   Application with a modified version of the Linked Version. (If
   you use option 4d0, the Installation Information must accompany
   the Minimal Corresponding Source and Corresponding Application
   Code. If you use option 4d1, you must provide the Installation
   Information in the manner specified by section 6 of the GNU GPL
   for conveying Corresponding Source.)

5. Combined Libraries.

You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:

a) Accompany the combined library with a copy of the same work based
   on the Library, uncombined with any other library facilities,
   conveyed under the terms of this License.

b) Give prominent notice with the combined library that part of it
   is a work based on the Library, and explaining where to find the
   accompanying uncombined form of the same work.

6. Revised Versions of the GNU Lesser General Public License.

The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.

Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.

If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
07070100000002000081A400000000000000000000000161CC381A00000025000000000000000000000000000000000000001F00000000colord-gtk-0.2.0+8/MAINTAINERSRichard Hughes <richard@hughsie.com>
07070100000003000081A400000000000000000000000161CC381A000007CE000000000000000000000000000000000000001800000000colord-gtk-0.2.0+8/NEWSVersion 0.2.0
~~~~~~~~~~~~~
Released: 2019-06-20

New Features:
 - Migrate to gettext (Martin Blanchard)
 - Port to DocBook 5 (Martin Blanchard)
 - Port to the Meson build system (Martin Blanchard)

Bugfixes:
 - Do not leak plug_name (Roman Lebedev)
 - Fix gtk-doc build when srcdir != builddir (Ting-Wei Lan)

Version 0.1.26
~~~~~~~~~~~~~~
Released: 2014-12-02

New Features:
 - Actually install the cd-convert utility (Richard Hughes)
 - Provide an optional Gtk2 version of libcolord-gtk (Richard Hughes)

Bugfixes:
 - Do not link against the unused gio-unix-2.0 (Richard Hughes)
 - Fix cd-convert to work with multiple sensors attached (Richard Hughes)

Version 0.1.25
~~~~~~~~~~~~~~
Released: 2013-03-19

New Features:
 - Give the sample widget slightly curved corners and a gray outline (Richard Hughes)

Bugfixes:
 - Do not use deprecated functions from libcolord (Richard Hughes)
 - Fix warnings when building ColordGtk-1.0.gir (Richard Hughes)
 - Fix up the licence boilerplate for CdSampleWidget (Richard Hughes)

Version 0.1.24
~~~~~~~~~~~~~~
Released: 2012-12-17

New Features:
 - Hide the mouse cursor when it goes over the sample widget (Richard Hughes)

Bugfixes:
 - Don't use a GtkImage for the sample window (Richard Hughes)
 - Fix automatic dep on vala (Pacho Ramos)
 - Fix the build (Matthias Clasen)
 - Never use -Werror as it breaks jhbuild (Richard Hughes)

Version 0.1.23
~~~~~~~~~~~~~~
Released: 2012-08-29

Bugfixes:
 - Do not reuse __COLORD_H_INSIDE__ as this causes #include insanity (Richard Hughes)
 - Add include guards to cd-sample-window.h (Richard Hughes)

Version 0.1.22
~~~~~~~~~~~~~~
Released: 2012-06-27

New Features:
 - Import GTK-specific code from colord into a new project (Richard Hughes)

Bugfixes:
 - Assorted colord-gtk introspection fixes (Evan Nemerson)
 - Clarify that CdSampleWindow is LGPLv2+, not GPLv2+ (Richard Hughes)
 - Fix release instructions and version number (Richard Hughes)
 - Fix Vala binding generation for colord-gtk (Evan Nemerson)
07070100000004000081A400000000000000000000000161CC381A00000072000000000000000000000000000000000000001A00000000colord-gtk-0.2.0+8/README              colord-gtk

colord-gtk is a GTK+ support library.

See http://colord.hughsie.com/ for more details.
07070100000005000081A400000000000000000000000161CC381A0000055F000000000000000000000000000000000000001B00000000colord-gtk-0.2.0+8/RELEASEcolord-gtk Release Notes

1. Write NEWS entries for colord in the same format as usual.

git shortlog COLORD_GTK_0_2_0.. | grep -i -v trivial | grep -v Merge > NEWS.new

Version 0.2.1
~~~~~~~~~~~~~
Released: 2019-xx-xx

New Features:
Bugfixes:

2. Commit changes to git:

# MAKE SURE THESE ARE CORRECT
export release_version="0.2.0"
export release_tag="COLORD_GTK_0_2_0"

git commit -a -m "Release colord-gtk ${release_version}"
git tag -s -f -m "Release colord-gtk ${release_version}" "${release_tag}"
<wait>
git push --tags
git push

3. Generate the tarball:

ninja dist

3a. Generate the additon verification metadata

sha1sum meson-dist/colord-gtk-${release_version}.tar.xz > colord-gtk-${release_version}.tar.xz.sha1
gpg -b -a meson-dist/colord-gtk-${release_version}.tar.xz

4. Upload tarball:

scp meson-dist/colord-gtk-${release_version}.tar.* hughsient@annarchy.freedesktop.org:/srv/www.freedesktop.org/www/software/colord/releases/

5. Do post release version bump in meson.build

6. Commit changes:

git commit -a -m "trivial: post release version bump"
git push

8. Send an email to colord@lists.freedesktop.org

colord-gtk is a support library for colord and provides additional functionality that requires GTK+.

See http://www.freedesktop.org/software/colord/ for more details.

Tarballs can be found here:
http://www.freedesktop.org/software/colord/releases/
07070100000006000081A400000000000000000000000161CC381A00000189000000000000000000000000000000000000001800000000colord-gtk-0.2.0+8/TODO		Things still left to do...

These are a list of things that have to be done, in no particular order.
If you're taking on one of these items, please email the mailing list
to ensure hard work is not duplicated.

* device.Created has to be saved in the database

* device.Modified has to be saved in the database (even for temp devices)

* Test device.Modified gets changed on profile changes
07070100000007000041ED00000000000000000000000261CC381A00000000000000000000000000000000000000000000001A00000000colord-gtk-0.2.0+8/client07070100000008000081A400000000000000000000000161CC381A000026B7000000000000000000000000000000000000002700000000colord-gtk-0.2.0+8/client/cd-convert.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012-2014 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU General Public License Version 2
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "config.h"

#include <glib.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <gio/gio.h>
#include <locale.h>
#include <colord.h>

#include "cd-sample-window.h"

/**
 * cd_convert_ti3_ti3_to_ccmx:
 **/
static gboolean
cd_convert_ti3_ti3_to_ccmx (const gchar *reference_fn,
			    const gchar *measured_fn,
			    const gchar *device_fn,
			    GError **error)
{
	CdIt8 *it8_ccmx = NULL;
	CdIt8 *it8_measured = NULL;
	CdIt8 *it8_reference = NULL;
	gboolean ret;
	GFile *file_ccmx = NULL;
	GFile *file_measured = NULL;
	GFile *file_reference = NULL;

/* load reference */
	it8_reference = cd_it8_new ();
	file_reference = g_file_new_for_path (reference_fn);
	ret = cd_it8_load_from_file (it8_reference,
				     file_reference,
				     error);
	if (!ret)
		goto out;

/* load measured */
	it8_measured = cd_it8_new ();
	file_measured = g_file_new_for_path (measured_fn);
	ret = cd_it8_load_from_file (it8_measured,
				     file_measured,
				     error);
	if (!ret)
		goto out;

/* calculate calibration matrix */
	it8_ccmx = cd_it8_new_with_kind (CD_IT8_KIND_CCMX);
	ret = cd_it8_utils_calculate_ccmx (it8_reference,
					   it8_measured,
					   it8_ccmx,
					   error);
	if (!ret)
		goto out;

/* save file */
	file_ccmx = g_file_new_for_path (device_fn);
	cd_it8_set_title (it8_ccmx, "Factory Calibration");
	cd_it8_set_originator (it8_ccmx, "cd-convert");
	cd_it8_add_option (it8_ccmx, "TYPE_FACTORY");
	ret = cd_it8_save_to_file (it8_ccmx, file_ccmx, error);
	if (!ret)
		goto out;
out:
	if (file_reference != NULL)
		g_object_unref (file_reference);
	if (file_measured != NULL)
		g_object_unref (file_measured);
	if (file_ccmx != NULL)
		g_object_unref (file_ccmx);
	if (it8_reference != NULL)
		g_object_unref (it8_reference);
	if (it8_measured != NULL)
		g_object_unref (it8_measured);
	if (it8_ccmx != NULL)
		g_object_unref (it8_ccmx);
	return ret;
}

/**
 * cd_convert_setup_sensor:
 **/
static CdSensor *
cd_convert_setup_sensor (CdClient *client, GError **error)
{
	CdSensor *sensor = NULL;
	CdSensor *sensor_tmp;
	gboolean ret;
	GPtrArray *sensors = NULL;

/* get sensor */
	sensors = cd_client_get_sensors_sync (client, NULL, error);
	if (sensors == NULL) {
		ret = FALSE;
		goto out;
	}
	if (sensors->len == 0) {
		ret = FALSE;
		g_set_error_literal (error, 1, 0,
				     "No native sensors plugged in!");
		goto out;
	}
	sensor_tmp = g_ptr_array_index (sensors, 0);
	ret = cd_sensor_connect_sync (sensor_tmp, NULL, error);
	if (!ret)
		goto out;
	sensor = g_object_ref (sensor_tmp);
out:
	if (sensors != NULL)
		g_ptr_array_unref (sensors);
	return sensor;
}

/**
 * cd_convert_idle_delay_cb:
 **/
static gboolean
cd_convert_idle_delay_cb (gpointer user_data)
{
	GMainLoop *loop = (GMainLoop *) user_data;
	g_main_loop_quit (loop);
	return FALSE;
}

/**
 * cd_convert_idle_delay:
 **/
static void
cd_convert_idle_delay (guint ms)
{
	GMainLoop *loop;
	loop = g_main_loop_new (NULL, FALSE);
	g_timeout_add (ms, cd_convert_idle_delay_cb, loop);
	g_main_loop_run (loop);
	g_main_loop_unref (loop);
}

/**
 * cd_convert_ti1_to_ti3:
 **/
static gboolean
cd_convert_ti1_to_ti3 (const gchar *patches_fn,
		       const gchar *measured_fn,
		       CdSensor *sensor,
		       GError **error)
{
	CdColorRGB rgb;
	CdColorXYZ *xyz_tmp;
	CdIt8 *it8_measured = NULL;
	CdIt8 *it8_patches = NULL;
	gboolean ret;
	GFile *file_measured = NULL;
	GFile *file_patches = NULL;
	GtkWindow *sample_window = NULL;
	guint i;
	guint size;

/* load patches */
	it8_patches = cd_it8_new ();
	file_patches = g_file_new_for_path (patches_fn);
	ret = cd_it8_load_from_file (it8_patches,
				     file_patches,
				     error);
	if (!ret)
		goto out;

/* lock the sensor */
	ret = cd_sensor_lock_sync (sensor,
				   NULL,
				   error);
	if (!ret)
		goto out;

/* create measurement file */
	sample_window = cd_sample_window_new ();
	gtk_window_present (sample_window);
	it8_measured = cd_it8_new_with_kind (CD_IT8_KIND_TI3);
	size = cd_it8_get_data_size (it8_patches);
	for (i = 0; i < size; i++) {
		cd_it8_get_data_item (it8_patches, i, &rgb, NULL);
		cd_sample_window_set_color (CD_SAMPLE_WINDOW (sample_window), &rgb);
		cd_sample_window_set_fraction (CD_SAMPLE_WINDOW (sample_window),
					       (gdouble) i / (gdouble) size);
		cd_convert_idle_delay (200);

/* get the sample using the default matrix */
		xyz_tmp = cd_sensor_get_sample_sync (sensor,
						     CD_SENSOR_CAP_LCD,
						     NULL,
						     error);
		if (xyz_tmp == NULL) {
			ret = FALSE;
			goto out;
		}

/* add to measured sheet */
		cd_it8_add_data (it8_measured, &rgb, xyz_tmp);
		cd_color_xyz_free (xyz_tmp);
	}

/* unlock the sensor */
	ret = cd_sensor_unlock_sync (sensor,
				     NULL,
				     error);
	if (!ret)
		goto out;

/* save file */
	file_measured = g_file_new_for_path (measured_fn);
	cd_it8_set_title (it8_measured, "Calibration");
	cd_it8_set_originator (it8_measured, "cd-convert");
	cd_it8_set_instrument (it8_measured, cd_sensor_get_model (sensor));
	ret = cd_it8_save_to_file (it8_measured, file_measured, error);
	if (!ret)
		goto out;
out:
	if (file_patches != NULL)
		g_object_unref (file_patches);
	if (file_measured != NULL)
		g_object_unref (file_measured);
	if (it8_patches != NULL)
		g_object_unref (it8_patches);
	if (it8_measured != NULL)
		g_object_unref (it8_measured);
	return ret;
}

/**
 * main:
 **/
int
main (int argc, char **argv)
{
	CdClient *client = NULL;
	CdDevice *device = NULL;
	CdSensor *sensor = NULL;
	gboolean ret;
	gchar *device_id = NULL;
	gchar *sensor_id = NULL;
	GError *error = NULL;
	gint retval = EXIT_FAILURE;
	GOptionContext *context;
	guint xid = 0;

const GOptionEntry options[] = {
		{ "device", '\0', 0, G_OPTION_ARG_STRING, &device_id,
			/* TRANSLATORS: command line option */
			_("Use this device for profiling"), NULL },
		{ "sensor", '\0', 0, G_OPTION_ARG_STRING, &sensor_id,
			/* TRANSLATORS: command line option */
			_("Use this sensor for profiling"), NULL },
		{ "xid", '\0', 0, G_OPTION_ARG_INT, &xid,
			/* TRANSLATORS: command line option */
			_("Make the window modal to this XID"), NULL },
		{ NULL}
	};

setlocale (LC_ALL, "");

bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
	textdomain (GETTEXT_PACKAGE);

gtk_init (&argc, &argv);

context = g_option_context_new (NULL);
	g_option_context_add_main_entries (context, options, NULL);
	g_option_context_add_group (context, gtk_get_option_group (TRUE));
	ret = g_option_context_parse (context, &argc, &argv, &error);
	if (!ret)
		goto out;

/* get client */
	client = cd_client_new ();
	ret = cd_client_connect_sync (client, NULL, &error);
	if (!ret)
		goto out;

/* find device */
	if (device_id != NULL) {
		device = cd_client_find_device_sync (client,
						     device_id,
						     NULL,
						     &error);
		if (device == NULL) {
			ret = FALSE;
			goto out;
		}
		ret = cd_device_connect_sync (device,
					      NULL,
					      &error);
		if (!ret)
			goto out;
	}

/* find sensor */
	if (sensor_id != NULL) {
		sensor = cd_client_find_sensor_sync (client,
						     sensor_id,
						     NULL,
						     &error);
		if (sensor == NULL) {
			ret = FALSE;
			goto out;
		}
		ret = cd_sensor_connect_sync (sensor,
					      NULL,
					      &error);
		if (!ret)
			goto out;
	}

/* create a .ccmx from two .ti3 files */
	if (argc == 4 &&
	    g_str_has_suffix (argv[1], ".ti3") &&
	    g_str_has_suffix (argv[2], ".ti3") &&
	    g_str_has_suffix (argv[3], ".ccmx")) {
		ret = cd_convert_ti3_ti3_to_ccmx (argv[1],
						  argv[2],
						  argv[3],
						  &error);
		if (!ret) {
			g_print ("failed to create ccmx: %s", error->message);
			g_error_free (error);
			goto out;
		}
	} else if (argc == 3 &&
		   g_str_has_suffix (argv[1], ".ti1") &&
		   g_str_has_suffix (argv[2], ".ti3")) {

/* get default sensor */
		if (sensor == NULL) {
			sensor = cd_convert_setup_sensor (client, &error);
			if (sensor == NULL) {
				ret = FALSE;
				goto out;
			}
		}

/* mark device to be profiled in colord */
		if (device != NULL) {
			ret = cd_device_profiling_inhibit_sync (device,
								NULL,
								&error);
			if (!ret)
				goto out;
		}

/* run the samples */
		ret = cd_convert_ti1_to_ti3 (argv[1],
					     argv[2],
					     sensor,
					     &error);
		if (!ret) {
			g_print ("failed to create ti3: %s", error->message);
			g_error_free (error);
			goto out;
		}
	} else {
		ret = FALSE;
		g_set_error_literal (&error, 1, 0,
				     "Specify one of:\n"
				     "patches.ti1 measured.ti3\n"
				     "reference.ti3 measured.ti3 device.ccmx");
		goto out;
	}

/* success */
	retval = EXIT_SUCCESS;
out:
	if (!ret) {
		g_print ("%s: %s\n", _("Failed to calibrate"), error->message);
		g_error_free (error);
	}
	g_option_context_free (context);
	if (device != NULL)
		g_object_unref (device);
	if (client != NULL)
		g_object_unref (client);
	if (sensor != NULL)
		g_object_unref (sensor);
	g_free (device_id);
	g_free (sensor_id);
	return retval;
}
07070100000009000081A400000000000000000000000161CC381A000001A8000000000000000000000000000000000000002600000000colord-gtk-0.2.0+8/client/meson.buildexecutable(
  'cd-convert',
  sources : [
    'cd-convert.c',
  ],
  include_directories : [
    root_incdir,
    colord_gtk_incdir,
  ],
  dependencies : [
    glib,
    gio,
    gtk3,
    colord,
  ],
  link_with : colord_gtk,
  c_args : [
    '-DG_LOG_DOMAIN="Cd"',
    '-DVERSION="@0@"'.format(colord_gtk_version),
    '-DLOCALEDIR="@0@"'.format(get_option('localedir')),
  ],
  install : true,
  install_dir : bindir
)
0707010000000A000081A400000000000000000000000161CC381A00000388000000000000000000000000000000000000002300000000colord-gtk-0.2.0+8/colord-gtk.doap<Project xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
         xmlns:foaf="http://xmlns.com/foaf/0.1/"
         xmlns:gnome="http://api.gnome.org/doap-extensions#"
         xmlns="http://usefulinc.com/ns/doap#">

<name xml:lang="en">colord-gtk</name>
  <shortdesc xml:lang="en">colord-gtk is a Gtk helper library for colord.</shortdesc>
  <description xml:lang="en">
    colord-gtk is a Gtk helper library for colord.
  </description>

<maintainer>
    <foaf:Person>
      <foaf:name>Richard Hughes</foaf:name>
      <foaf:mbox rdf:resource="mailto:richard@hughsie.com" />
      <foaf:homepage rdf:resource="http://www.hughsie.com/" />
    </foaf:Person>
  </maintainer>

</Project>
0707010000000B000041ED00000000000000000000000261CC381A00000000000000000000000000000000000000000000001B00000000colord-gtk-0.2.0+8/contrib0707010000000C000081A400000000000000000000000161CC381A00000727000000000000000000000000000000000000002E00000000colord-gtk-0.2.0+8/contrib/colord-gtk.spec.in%define alphatag                #ALPHATAG#

Summary:   GTK support library for colord
Name:      colord-gtk
Version:   #VERSION#
Release:   0.#BUILD#%{?alphatag}%{?dist}
License:   LGPLv2+
URL:       http://www.freedesktop.org/software/colord/
Source0:   http://www.freedesktop.org/software/colord/releases/%{name}-%{version}.tar.xz

BuildRequires: meson
BuildRequires: docbook5-style-xsl
BuildRequires: gettext >= 0.19.8
BuildRequires: glib2-devel
BuildRequires: colord-devel >= 0.1.23
BuildRequires: lcms2-devel >= 2.2
BuildRequires: gobject-introspection-devel
BuildRequires: vala
BuildRequires: gtk3-devel
BuildRequires: gtk-doc

%description
colord-gtk is a support library for colord and provides additional
functionality that requires GTK+.

%package devel
Summary: Development package for %{name}
Requires: %{name}%{?_isa} = %{version}-%{release}

%description devel
Files for development with %{name}.

%prep
%autosetup -p1

%build
%meson -Ddocs=true -Dgtk2=false -Dman=true -Dtests=false -Dvapi=true
%meson_build

%install
%meson_install

%find_lang %{name}

%ldconfig_scriptlets

%files -f %{name}.lang
%doc README AUTHORS NEWS COPYING
%{_bindir}/*
%{_mandir}/man1/*.1.gz
%{_libdir}/libcolord-gtk.so.*
%{_libdir}/girepository-1.0/ColordGtk-1.0.typelib

%files devel
%{_libdir}/libcolord-gtk.so
%{_libdir}/pkgconfig/colord-gtk.pc
%dir %{_includedir}/colord-1
%{_includedir}/colord-1/colord-gtk.h
%dir %{_includedir}/colord-1/colord-gtk
%{_includedir}/colord-1/colord-gtk/*.h
%dir %{_datadir}/gir-1.0
%{_datadir}/gir-1.0/ColordGtk-1.0.gir
%doc %{_datadir}/gtk-doc/html/colord-gtk
%{_datadir}/vala/vapi/colord-gtk.vapi
%{_datadir}/vala/vapi/colord-gtk.deps
%dir %{_datadir}/gtk-doc
%dir %{_datadir}/gtk-doc/html

%changelog
* #LONGDATE# Richard Hughes <richard@hughsie.com> #VERSION#-0.#BUILD##ALPHATAG#
- Update from git

0707010000000D000041ED00000000000000000000000361CC381A00000000000000000000000000000000000000000000001700000000colord-gtk-0.2.0+8/doc0707010000000E000041ED00000000000000000000000261CC381A00000000000000000000000000000000000000000000001B00000000colord-gtk-0.2.0+8/doc/api0707010000000F000081A400000000000000000000000161CC381A00000B10000000000000000000000000000000000000002F00000000colord-gtk-0.2.0+8/doc/api/colord-gtk-docs.xml<?xml version="1.0"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
               "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY version SYSTEM "version.xml">
]>
<book id="index" xmlns:xi="http://www.w3.org/2003/XInclude">
  <bookinfo>
    <title>colord-gtk Reference Manual</title>
    <releaseinfo>Version &version;</releaseinfo>
    <authorgroup>
      <author>
        <firstname>Richard</firstname>
        <surname>Hughes</surname>
        <affiliation>
          <address>
            <email>richard@hughsie.com</email>
          </address>
        </affiliation>
      </author>
    </authorgroup>

<copyright>
      <year>2012</year>
      <holder>The colord-gtk authors</holder>
    </copyright>

<legalnotice>
      <para>
	Permission is granted to copy, distribute and/or modify this
	document under the terms of the <citetitle>GNU Free
	Documentation License</citetitle>, Version 1.1 or any later
	version published by the Free Software Foundation with no
	Invariant Sections, no Front-Cover Texts, and no Back-Cover
	Texts. You may obtain a copy of the <citetitle>GNU Free
	Documentation License</citetitle> from the Free Software
	Foundation by visiting <ulink type="http"
	url="http://www.fsf.org">their Web site</ulink> or by writing
	to:

<address>
	  The Free Software Foundation, Inc.,
	  <street>59 Temple Place</street> - Suite 330,
	  <city>Boston</city>, <state>MA</state> <postcode>02111-1307</postcode>,
	  <country>USA</country>
	</address>
      </para>

<para>
	Many of the names used by companies to distinguish their
	products and services are claimed as trademarks. Where those
	names appear in any freedesktop.org documentation, and those
	trademarks are made aware to the members of the
	freedesktop.org Project, the names have been printed in caps
	or initial caps.
      </para>
    </legalnotice>
  </bookinfo>

<reference id="libcolord-gtk">
    <title>libcolord-gtk GObjects</title>
    <partintro>
      <para>
        This part documents GObjects used in libcolord-gtk.
      </para>
    </partintro>
    <xi:include href="xml/cd-sample-window.xml"/>
    <xi:include href="xml/cd-window.xml"/>
  </reference>

<reference id="libcolord-glib-helpers">
    <title>libcolord-glib helpers</title>
    <partintro>
      <para>
        This part documents helper funtions in libcolord-gtk.
      </para>
    </partintro>
    <xi:include href="xml/cd-version.xml"/>
  </reference>

<index>
    <title>Index</title>
  </index>

<appendix id="license">
    <title>License</title>
    <para>
<programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="../../COPYING" parse="text"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting>
    </para>
  </appendix>
</book>
07070100000010000081A400000000000000000000000161CC381A00000181000000000000000000000000000000000000002700000000colord-gtk-0.2.0+8/doc/api/meson.buildversion_xml = configure_file(
  input : 'version.xml.in',
  output : 'version.xml',
  configuration : conf,
)

gnome.gtkdoc(
  'colord-gtk',
  src_dir : [
    join_paths(meson.source_root(), 'libcolord-gtk'),
    join_paths(meson.build_root(), 'libcolord-gtk'),
  ],
  main_xml : 'colord-gtk-docs.xml',
  content_files : [
    '../../COPYING',
    version_xml,
  ],
  install : true
)
07070100000011000081A400000000000000000000000161CC381A0000000A000000000000000000000000000000000000002A00000000colord-gtk-0.2.0+8/doc/api/version.xml.in@VERSION@
07070100000012000081A400000000000000000000000161CC381A0000000E000000000000000000000000000000000000002300000000colord-gtk-0.2.0+8/doc/meson.buildsubdir('api')
07070100000013000041ED00000000000000000000000261CC381A00000000000000000000000000000000000000000000002100000000colord-gtk-0.2.0+8/libcolord-gtk07070100000014000081A400000000000000000000000161CC381A000015C7000000000000000000000000000000000000003900000000colord-gtk-0.2.0+8/libcolord-gtk/cd-sample-widget-gtk4.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2021 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
 *               2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "config.h"

#include <gtk/gtk.h>
#include <colord.h>

#include "cd-sample-widget.h"

struct CdSampleWidgetPrivate
{
	cairo_t			*cr;
	CdColorRGB		 color;
};

G_DEFINE_TYPE_WITH_CODE (CdSampleWidget, cd_sample_widget, GTK_TYPE_DRAWING_AREA,
			 G_ADD_PRIVATE (CdSampleWidget));

enum
{
	PROP_0,
	PROP_COLOR,
};

/**
 * up_sample_get_property:
 **/
static void
up_sample_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
	CdSampleWidget *sample = CD_SAMPLE_WIDGET (object);
	CdSampleWidgetPrivate *priv = cd_sample_widget_get_instance_private (sample);
	switch (prop_id) {
	case PROP_COLOR:
		g_value_set_boxed (value, &priv->color);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}

/**
 * up_sample_set_property:
 **/
static void
up_sample_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
	CdColorRGB *tmp;
	CdSampleWidget *sample = CD_SAMPLE_WIDGET (object);
	CdSampleWidgetPrivate *priv = cd_sample_widget_get_instance_private (sample);

switch (prop_id) {
	case PROP_COLOR:
		tmp = g_value_get_boxed (value);
		cd_color_rgb_copy (tmp, &priv->color);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}

/* refresh widget */
	gtk_widget_hide (GTK_WIDGET (sample));
	gtk_widget_show (GTK_WIDGET (sample));
}

/**
 * cd_sample_widget_draw_rounded_rectangle:
 **/
static void
cd_sample_widget_draw_rounded_rectangle (cairo_t *cr,
					 gdouble x,
					 gdouble y,
					 gdouble width,
					 gdouble height,
					 gdouble corner_radius)
{
	gdouble aspect = width / height;
	gdouble radius = corner_radius / aspect;
	gdouble degrees = G_PI / 180.0;

cairo_new_sub_path (cr);
	cairo_arc (cr, x + width - radius, y + radius,
		   radius, -90 * degrees, 0 * degrees);
	cairo_arc (cr, x + width - radius, y + height - radius,
		   radius, 0 * degrees, 90 * degrees);
	cairo_arc (cr, x + radius, y + height - radius,
		   radius, 90 * degrees, 180 * degrees);
	cairo_arc (cr, x + radius, y + radius,
		   radius, 180 * degrees, 270 * degrees);
	cairo_close_path (cr);
}

/**
 * cd_sample_widget_draw:
 **/
static void
cd_sample_widget_draw (GtkDrawingArea *drawing_area,
                       cairo_t        *cr,
                       int             width,
                       int             height,
                       gpointer        user_data)
{
	CdSampleWidget *sample = CD_SAMPLE_WIDGET (drawing_area);
	CdSampleWidgetPrivate *priv = cd_sample_widget_get_instance_private (sample);
	CdColorRGB *color;

color = &priv->color;
	cairo_save (cr);
	cairo_set_source_rgb (cr, color->R, color->G, color->B);
	cd_sample_widget_draw_rounded_rectangle (cr, 0, 0, width, height, 10.5);
	cairo_fill_preserve (cr);
	cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 1.0);
	cairo_set_line_width (cr, 1.0);
	cairo_stroke (cr);
	cairo_restore (cr);
}

/**
 * cd_sample_widget_class_init:
 **/
static void
cd_sample_widget_class_init (CdSampleWidgetClass *class)
{
	GObjectClass *object_class = G_OBJECT_CLASS (class);

object_class->get_property = up_sample_get_property;
	object_class->set_property = up_sample_set_property;

/* properties */
	g_object_class_install_property (object_class,
					 PROP_COLOR,
					 g_param_spec_boxed ("color", NULL, NULL,
							     CD_TYPE_COLOR_RGB,
							     G_PARAM_READWRITE));
}

/**
 * cd_sample_widget_init:
 **/
static void
cd_sample_widget_init (CdSampleWidget *sample)
{
	CdSampleWidgetPrivate *priv = cd_sample_widget_get_instance_private (sample);

gtk_widget_set_cursor (GTK_WIDGET (sample), gdk_cursor_new_from_name ("blank", NULL));
	cd_color_rgb_set (&priv->color, 1.0, 1.0, 1.0);
	gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (sample),
					cd_sample_widget_draw,
					sample, NULL);
}

/**
 * cd_sample_widget_set_color:
 * @sample: This class instance
 * @color: A color
 *
 * Sets the color for the sample widget
 *
 * Since: 0.1.24
 **/
void
cd_sample_widget_set_color (CdSampleWidget *sample, const CdColorRGB *color)
{
	CdSampleWidgetPrivate *priv;

g_return_if_fail (color != NULL);
	g_return_if_fail (CD_IS_SAMPLE_WIDGET (sample));

priv = cd_sample_widget_get_instance_private (sample);

/* set new color and refresh */
	cd_color_rgb_copy (color, &priv->color);
	gtk_widget_queue_draw (GTK_WIDGET (sample));
}

/**
 * cd_sample_widget_new:
 *
 * Return value: A new #CdSampleWidget object.
 *
 * Since: 0.1.24
 **/
GtkWidget *
cd_sample_widget_new (void)
{
	return g_object_new (CD_TYPE_SAMPLE_WIDGET, NULL);
}
07070100000015000081A400000000000000000000000161CC381A00001A54000000000000000000000000000000000000003400000000colord-gtk-0.2.0+8/libcolord-gtk/cd-sample-widget.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "config.h"

#include <gtk/gtk.h>
#include <colord.h>

#include "cd-sample-widget.h"

G_DEFINE_TYPE (CdSampleWidget, cd_sample_widget, GTK_TYPE_DRAWING_AREA);
#define CD_SAMPLE_WIDGET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CD_TYPE_SAMPLE_WIDGET, CdSampleWidgetPrivate))

struct CdSampleWidgetPrivate
{
	cairo_t			*cr;
	CdColorRGB		 color;
};

enum
{
	PROP_0,
	PROP_COLOR,
};

/**
 * up_sample_get_property:
 **/
static void
up_sample_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
	CdSampleWidget *sample = CD_SAMPLE_WIDGET (object);
	switch (prop_id) {
	case PROP_COLOR:
		g_value_set_boxed (value, &sample->priv->color);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}

switch (prop_id) {
	case PROP_COLOR:
		tmp = g_value_get_boxed (value);
		cd_color_rgb_copy (tmp, &sample->priv->color);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}

/* refresh widget */
	gtk_widget_hide (GTK_WIDGET (sample));
	gtk_widget_show (GTK_WIDGET (sample));
}

/**
 * cd_sample_widget_draw:
 **/
static gboolean
cd_sample_widget_draw (GtkWidget *widget, cairo_t *cr)
{
	CdColorRGB *color;
	CdSampleWidget *sample = CD_SAMPLE_WIDGET (widget);
	GtkAllocation allocation;

g_return_val_if_fail (CD_IS_SAMPLE_WIDGET (sample), FALSE);

color = &sample->priv->color;
	gtk_widget_get_allocation (widget, &allocation);
	cairo_save (cr);
	cairo_set_source_rgb (cr, color->R, color->G, color->B);
	cd_sample_widget_draw_rounded_rectangle (cr, 0, 0,
						 allocation.width,
						 allocation.height,
						 10.5);
	cairo_fill_preserve (cr);
	cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 1.0);
	cairo_set_line_width (cr, 1.0);
	cairo_stroke (cr);
	cairo_restore (cr);
	return FALSE;
}

/**
 * cd_sample_window_enter_notify_event_cb:
 **/
static gboolean
cd_sample_window_enter_notify_event_cb (GtkWidget *widget,
					GdkEvent *event,
					gpointer user_data)
{
	GdkCursor *cursor;
	GdkWindow *window;

cursor = gdk_cursor_new (GDK_BLANK_CURSOR);
	window = gtk_widget_get_window (widget);
	gdk_window_set_cursor (window, cursor);
	g_object_unref (cursor);
	return TRUE;
}

/**
 * cd_sample_window_leave_notify_event_cb:
 **/
static gboolean
cd_sample_window_leave_notify_event_cb (GtkWidget *widget,
					GdkEvent *event,
					gpointer user_data)
{
	GdkCursor *cursor;
	GdkWindow *window;

cursor = gdk_cursor_new (GDK_ARROW);
	window = gtk_widget_get_window (widget);
	gdk_window_set_cursor (window, cursor);
	g_object_unref (cursor);
	return TRUE;
}

/**
 * cd_sample_widget_class_init:
 **/
static void
cd_sample_widget_class_init (CdSampleWidgetClass *class)
{
	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
	GObjectClass *object_class = G_OBJECT_CLASS (class);

widget_class->draw = cd_sample_widget_draw;
	object_class->get_property = up_sample_get_property;
	object_class->set_property = up_sample_set_property;

g_type_class_add_private (class, sizeof (CdSampleWidgetPrivate));

/* properties */
	g_object_class_install_property (object_class,
					 PROP_COLOR,
					 g_param_spec_boxed ("color", NULL, NULL,
							     CD_TYPE_COLOR_RGB,
							     G_PARAM_READWRITE));
}

/**
 * cd_example_window_realize_cb:
 **/
static void
cd_example_window_realize_cb (GtkWidget *widget, gpointer user_data)
{
	GdkWindow *window;

/* hide the mouse pointer when over the calibration widget */
	window = gtk_widget_get_window (widget);
	g_assert (window != NULL);
	gdk_window_set_events (window, GDK_EXPOSURE_MASK |
				       GDK_ENTER_NOTIFY_MASK |
				       GDK_LEAVE_NOTIFY_MASK);
}

/**
 * cd_sample_widget_init:
 **/
static void
cd_sample_widget_init (CdSampleWidget *sample)
{
	sample->priv = CD_SAMPLE_WIDGET_GET_PRIVATE (sample);
	cd_color_rgb_set (&sample->priv->color, 1.0, 1.0, 1.0);

g_signal_connect (sample, "realize",
			  G_CALLBACK (cd_example_window_realize_cb), NULL);
	g_signal_connect (sample, "enter-notify-event",
			  G_CALLBACK (cd_sample_window_enter_notify_event_cb), NULL);
	g_signal_connect (sample, "leave-notify-event",
			  G_CALLBACK (cd_sample_window_leave_notify_event_cb), NULL);
}

/* set new color and refresh */
	cd_color_rgb_copy (color, &sample->priv->color);
	gtk_widget_queue_draw (GTK_WIDGET (sample));
}

/**
 * cd_sample_widget_new:
 *
 * Return value: A new #CdSampleWidget object.
 *
 * Since: 0.1.24
 **/
GtkWidget *
cd_sample_widget_new (void)
{
	return g_object_new (CD_TYPE_SAMPLE_WIDGET, NULL);
}
07070100000016000081A400000000000000000000000161CC381A000008FF000000000000000000000000000000000000003400000000colord-gtk-0.2.0+8/libcolord-gtk/cd-sample-widget.h/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#if !defined (__COLORD_GTK_H_INSIDE__) && !defined (CD_COMPILATION)
#error "Only <colord-gtk.h> can be included directly."
#endif

#ifndef __CD_SAMPLE_WIDGET_H__
#define __CD_SAMPLE_WIDGET_H__

#include <gtk/gtk.h>
#include <colord.h>

G_BEGIN_DECLS

#define CD_TYPE_SAMPLE_WIDGET		(cd_sample_widget_get_type ())
#define CD_SAMPLE_WIDGET(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), CD_TYPE_SAMPLE_WIDGET, CdSampleWidget))
#define CD_SAMPLE_WIDGET_CLASS(obj)	(G_TYPE_CHECK_CLASS_CAST ((obj), CD_SAMPLE_WIDGET, CdSampleWidgetClass))
#define CD_IS_SAMPLE_WIDGET(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), CD_TYPE_SAMPLE_WIDGET))
#define CD_IS_SAMPLE_WIDGET_CLASS(obj)	(G_TYPE_CHECK_CLASS_TYPE ((obj), EFF_TYPE_SAMPLE_WIDGET))
#define CD_SAMPLE_WIDGET_GET_CLASS	(G_TYPE_INSTANCE_GET_CLASS ((obj), CD_TYPE_SAMPLE_WIDGET, CdSampleWidgetClass))

typedef struct CdSampleWidget		CdSampleWidget;
typedef struct CdSampleWidgetClass	CdSampleWidgetClass;
typedef struct CdSampleWidgetPrivate	CdSampleWidgetPrivate;

struct CdSampleWidget
{
	GtkDrawingArea		 parent;
	CdSampleWidgetPrivate	*priv;
};

struct CdSampleWidgetClass
{
	GtkDrawingAreaClass	 parent_class;
};

GType		 cd_sample_widget_get_type	(void);
GtkWidget	*cd_sample_widget_new		(void);
void		 cd_sample_widget_set_color	(CdSampleWidget		*sample,
						 const CdColorRGB	*color);

G_END_DECLS

#endif
07070100000017000081A400000000000000000000000161CC381A00001490000000000000000000000000000000000000003900000000colord-gtk-0.2.0+8/libcolord-gtk/cd-sample-window-gtk4.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2021 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
 *               2009-2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "config.h"

#include <glib-object.h>

#include <colord.h>

#include "cd-sample-widget.h"
#include "cd-sample-window.h"

static void     cd_sample_window_finalize	(GObject     *object);

#define CD_SAMPLE_WINDOW_PULSE_DELAY		80	/* ms */

/**
 * CdSampleWindowPrivate:
 *
 * Private #CdSampleWindow data
 **/
struct _CdSampleWindowPrivate
{
	GtkWidget			*sample_widget;
	GtkWidget			*progress_bar;
	guint				 pulse_id;
};

G_DEFINE_TYPE_WITH_CODE (CdSampleWindow, cd_sample_window, GTK_TYPE_WINDOW,
			 G_ADD_PRIVATE (CdSampleWindow))

/**
 * cd_sample_window_pulse_cb:
 **/
static gboolean
cd_sample_window_pulse_cb (CdSampleWindow *sample_window)
{
	CdSampleWindowPrivate *priv = cd_sample_window_get_instance_private (sample_window);
	gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->progress_bar));
	return TRUE;
}

/**
 * cd_sample_window_set_fraction:
 * @sample_window: a valid #CdSampleWindow instance
 * @fraction: the fraction value to show, or -1 for pulsing.
 *
 * Sets the percentage value on the window.
 *
 * Since: 0.1.22
 **/
void
cd_sample_window_set_fraction (CdSampleWindow *sample_window,
			       gdouble fraction)
{
	CdSampleWindowPrivate *priv = cd_sample_window_get_instance_private (sample_window);

/* make pulse */
	if (fraction == -1) {
		if (priv->pulse_id == 0) {
			priv->pulse_id = g_timeout_add (CD_SAMPLE_WINDOW_PULSE_DELAY,
							(GSourceFunc) cd_sample_window_pulse_cb,
							sample_window);
		}
		return;
	}

/* no more pulsing */
	if (priv->pulse_id != 0) {
		g_source_remove (priv->pulse_id);
		priv->pulse_id = 0;
	}

/* set static value */
	gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->progress_bar), fraction);
}

/**
 * cd_sample_window_set_color:
 * @sample_window: a valid #CdSampleWindow instance
 * @color: the color
 *
 * Sets the window to a specific color.
 *
 * Since: 0.1.22
 **/
void
cd_sample_window_set_color (CdSampleWindow *sample_window,
			    const CdColorRGB *color)
{
	CdSampleWindowPrivate *priv = cd_sample_window_get_instance_private (sample_window);

g_debug ("setting RGB: %f, %f, %f", color->R, color->G, color->B);
	cd_sample_widget_set_color (CD_SAMPLE_WIDGET (priv->sample_widget), color);

/* force redraw */
	gtk_widget_set_visible (priv->sample_widget, FALSE);
	gtk_widget_set_visible (priv->sample_widget, TRUE);
}

/**
 * cd_sample_window_class_init:
 **/
static void
cd_sample_window_class_init (CdSampleWindowClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);
	object_class->finalize = cd_sample_window_finalize;
}

/**
 * cd_sample_window_init:
 **/
static void
cd_sample_window_init (CdSampleWindow *sample_window)
{
	CdSampleWindowPrivate *priv = cd_sample_window_get_instance_private (sample_window);
	GtkWindow *window = GTK_WINDOW (sample_window);
	GtkWidget *vbox;
	priv->sample_widget = cd_sample_widget_new ();
	priv->progress_bar = gtk_progress_bar_new ();

/* pack in two widgets into the window */
	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_window_set_child (window, vbox);
	gtk_box_append (GTK_BOX (vbox), priv->sample_widget);
	gtk_box_append (GTK_BOX (vbox), priv->progress_bar);
	gtk_widget_set_size_request (priv->sample_widget, 400, 400);

gtk_widget_set_cursor (GTK_WIDGET (window), gdk_cursor_new_from_name ("blank", NULL));
}

/**
 * cd_sample_window_finalize:
 **/
static void
cd_sample_window_finalize (GObject *object)
{
	CdSampleWindow *sample_window = CD_SAMPLE_WINDOW (object);
	CdSampleWindowPrivate *priv = cd_sample_window_get_instance_private (sample_window);

if (priv->pulse_id != 0)
		g_source_remove (priv->pulse_id);

G_OBJECT_CLASS (cd_sample_window_parent_class)->finalize (object);
}

/**
 * cd_sample_window_new:
 *
 * Return value: a new #CdSampleWindow object.
 *
 * Since: 0.1.22
 **/
GtkWindow *
cd_sample_window_new (void)
{
	CdSampleWindow *sample_window;
	sample_window = g_object_new (CD_TYPE_SAMPLE_WINDOW,
				      "decorated", FALSE,
				      "default-height", 400,
				      "default-width", 400,
				      "deletable", FALSE,
				      "destroy-with-parent", TRUE,
				      "icon-name", "icc-profile",
				      "resizable", FALSE,
				      "title", "calibration square",
				      NULL);
	return GTK_WINDOW (sample_window);
}
07070100000018000081A400000000000000000000000161CC381A00001AA0000000000000000000000000000000000000003400000000colord-gtk-0.2.0+8/libcolord-gtk/cd-sample-window.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2009-2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "config.h"

#include <glib-object.h>

#include <colord.h>

#include "cd-sample-widget.h"
#include "cd-sample-window.h"

static void     cd_sample_window_finalize	(GObject     *object);

#define CD_SAMPLE_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CD_TYPE_SAMPLE_WINDOW, CdSampleWindowPrivate))
#define CD_SAMPLE_WINDOW_PULSE_DELAY		80	/* ms */

/**
 * CdSampleWindowPrivate:
 *
 * Private #CdSampleWindow data
 **/
struct _CdSampleWindowPrivate
{
	GtkWidget			*sample_widget;
	GtkWidget			*progress_bar;
	guint				 pulse_id;
};

G_DEFINE_TYPE (CdSampleWindow, cd_sample_window, GTK_TYPE_WINDOW)

/**
 * cd_sample_window_pulse_cb:
 **/
static gboolean
cd_sample_window_pulse_cb (CdSampleWindow *sample_window)
{
	gtk_progress_bar_pulse (GTK_PROGRESS_BAR (sample_window->priv->progress_bar));
	return TRUE;
}

/* no more pulsing */
	if (priv->pulse_id != 0) {
		g_source_remove (priv->pulse_id);
		priv->pulse_id = 0;
	}

/* set static value */
	gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (sample_window->priv->progress_bar), fraction);
}

/**
 * cd_sample_window_set_color:
 * @sample_window: a valid #CdSampleWindow instance
 * @color: the color
 *
 * Sets the window to a specific color.
 *
 * Since: 0.1.22
 **/
void
cd_sample_window_set_color (CdSampleWindow *sample_window,
			    const CdColorRGB *color)
{
	g_debug ("setting RGB: %f, %f, %f", color->R, color->G, color->B);
	cd_sample_widget_set_color (CD_SAMPLE_WIDGET (sample_window->priv->sample_widget), color);

/* force redraw */
	gtk_widget_set_visible (sample_window->priv->sample_widget, FALSE);
	gtk_widget_set_visible (sample_window->priv->sample_widget, TRUE);
}

/**
 * cd_sample_window_enter_notify_cb:
 **/
static gboolean
cd_sample_window_enter_notify_cb (GtkWidget *widget, GdkEventCrossing *event, CdSampleWindow *sample_window)
{
	GdkCursor *cursor;

/* hide cursor */
	cursor = gdk_cursor_new_for_display (gdk_display_get_default (), GDK_BLANK_CURSOR);
	gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
	g_object_unref (cursor);

return FALSE;
}

/**
 * cd_sample_window_leave_notify_cb:
 **/
static gboolean
cd_sample_window_leave_notify_cb (GtkWidget *widget, GdkEventCrossing *event,
				   CdSampleWindow *sample_window)
{
	/* restore cursor */
	gdk_window_set_cursor (gtk_widget_get_window (widget), NULL);
	return FALSE;
}

static gboolean
cd_sample_window_visibility_notify_cb (GtkWidget *widget, GdkEventVisibility *event,
					CdSampleWindow *sample_window)
{
	/* reshow it */
	gtk_window_present (GTK_WINDOW (widget));
	return TRUE;
}

/**
 * cd_sample_window_init:
 **/
static void
cd_sample_window_init (CdSampleWindow *sample_window)
{
	GtkWindow *window = GTK_WINDOW (sample_window);
	GtkWidget *vbox;
	sample_window->priv = CD_SAMPLE_WINDOW_GET_PRIVATE (sample_window);
	sample_window->priv->sample_widget = cd_sample_widget_new ();
	sample_window->priv->progress_bar = gtk_progress_bar_new ();

/* pack in two widgets into the window */
	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_container_add (GTK_CONTAINER (sample_window), vbox);
	gtk_box_pack_start (GTK_BOX (vbox), sample_window->priv->sample_widget, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (vbox), sample_window->priv->progress_bar, FALSE, FALSE, 0);
	gtk_widget_set_size_request (sample_window->priv->sample_widget, 400, 400);
	gtk_widget_show_all (vbox);

/* be clever and allow the colorimeter to do it's job */
	g_signal_connect (window, "enter-notify-event",
			  G_CALLBACK(cd_sample_window_enter_notify_cb),
			  sample_window);
	g_signal_connect (window, "leave-notify-event",
			  G_CALLBACK(cd_sample_window_leave_notify_cb),
			  sample_window);
	g_signal_connect (window, "visibility-notify-event",
			  G_CALLBACK(cd_sample_window_visibility_notify_cb),
			  sample_window);

/* show on all virtual desktops */
	gtk_window_stick (window);
}

if (priv->pulse_id != 0)
		g_source_remove (priv->pulse_id);

G_OBJECT_CLASS (cd_sample_window_parent_class)->finalize (object);
}

/**
 * cd_sample_window_new:
 *
 * Return value: a new #CdSampleWindow object.
 *
 * Since: 0.1.22
 **/
GtkWindow *
cd_sample_window_new (void)
{
	CdSampleWindow *sample_window;
	sample_window = g_object_new (CD_TYPE_SAMPLE_WINDOW,
				      "accept-focus", FALSE,
				      "decorated", FALSE,
				      "default-height", 400,
				      "default-width", 400,
				      "deletable", FALSE,
				      "destroy-with-parent", TRUE,
				      "icon-name", "icc-profile",
				      "resizable", FALSE,
				      "skip-pager-hint", TRUE,
				      "skip-taskbar-hint", TRUE,
				      "title", "calibration square",
				      "type-hint", GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
				      "urgency-hint", TRUE,
				      NULL);
	return GTK_WINDOW (sample_window);
}
07070100000019000081A400000000000000000000000161CC381A0000085D000000000000000000000000000000000000003400000000colord-gtk-0.2.0+8/libcolord-gtk/cd-sample-window.h/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2010-2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#if !defined (__COLORD_GTK_H_INSIDE__) && !defined (CD_COMPILATION)
#error "Only <colord-gtk.h> can be included directly."
#endif

#ifndef __CD_SAMPLE_WINDOW_H
#define __CD_SAMPLE_WINDOW_H

#include <glib-object.h>
#include <gtk/gtk.h>
#include <colord.h>

G_BEGIN_DECLS

#define CD_TYPE_SAMPLE_WINDOW		(cd_sample_window_get_type ())
#define CD_SAMPLE_WINDOW(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), CD_TYPE_SAMPLE_WINDOW, CdSampleWindow))
#define CD_IS_SAMPLE_WINDOW(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), CD_TYPE_SAMPLE_WINDOW))

typedef struct _CdSampleWindowPrivate	CdSampleWindowPrivate;
typedef struct _CdSampleWindow		CdSampleWindow;
typedef struct _CdSampleWindowClass	CdSampleWindowClass;

struct _CdSampleWindow
{
	 GtkWindow			 parent;
	 CdSampleWindowPrivate		*priv;
};

struct _CdSampleWindowClass
{
	GtkWindowClass			 parent_class;
};

GType		 cd_sample_window_get_type		(void);
GtkWindow	*cd_sample_window_new			(void);
void		 cd_sample_window_set_color		(CdSampleWindow		*sample_window,
							 const CdColorRGB	*color);
void		 cd_sample_window_set_fraction		(CdSampleWindow		*sample_window,
							 gdouble		 fraction);

G_END_DECLS

#endif /* __CD_SAMPLE_WINDOW_H */

0707010000001A000081A400000000000000000000000161CC381A00000DBF000000000000000000000000000000000000003500000000colord-gtk-0.2.0+8/libcolord-gtk/cd-self-test-gtk4.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2021 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
 *               2010-2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "config.h"

#include <colord.h>
#include <glib.h>
#include <glib-object.h>
#include <gtk/gtk.h>

#include "cd-sample-window.h"
#include "cd-window.h"

static void
cd_window_get_profile_cb (GObject *source,
			  GAsyncResult *res,
			  gpointer user_data)
{
	CdWindow *window = CD_WINDOW (source);
	GtkWidget *widget = GTK_WIDGET (user_data);
	GError *error = NULL;
	CdProfile *profile;

profile = cd_window_get_profile_finish (window,
					        res,
					        &error);
	g_assert_no_error (error);
	g_assert (profile != NULL);
	g_debug ("profile was %s", cd_profile_get_filename (profile));
	g_object_unref (profile);

/* kill the dialog */
	gtk_window_destroy (GTK_WINDOW (widget));
}

static void
map_cb (GtkWidget *this_widget, gpointer user_data)
{
	CdWindow *window = CD_WINDOW (user_data);

/* get the profile for this widget */
	cd_window_get_profile (window,
			       this_widget,
			       NULL,
			       cd_window_get_profile_cb,
			       this_widget);
}

static void
colord_window_func (void)
{
	CdWindow *window;
	GtkWidget *dialog;

window = cd_window_new ();
	dialog = gtk_message_dialog_new (NULL,
					 GTK_DIALOG_MODAL,
					 GTK_MESSAGE_INFO,
					 GTK_BUTTONS_OK,
					 "%s", "Hello world");
	g_signal_connect (dialog, "map",
			  G_CALLBACK (map_cb),
			  window);
	gtk_window_present (GTK_WINDOW (dialog));
}

static gboolean
colord_sample_window_loop_cb (GMainLoop *loop)
{
	g_main_loop_quit (loop);
	return FALSE;
}

static void
colord_sample_window_func (void)
{
	GtkWindow *window;
	GMainLoop *loop;
	CdColorRGB source;

window = cd_sample_window_new ();
	g_assert (window != NULL);
	source.R = 1.0f;
	source.G = 1.0f;
	source.B = 0.0f;
	cd_sample_window_set_color (CD_SAMPLE_WINDOW (window), &source);
	cd_sample_window_set_fraction (CD_SAMPLE_WINDOW (window), -1);

/* move to the center of device lvds1 */
	gtk_window_present (window);

loop = g_main_loop_new (NULL, FALSE);
	g_timeout_add_seconds (5, (GSourceFunc) colord_sample_window_loop_cb, loop);
	g_main_loop_run (loop);

g_main_loop_unref (loop);
	gtk_window_destroy (GTK_WINDOW (window));
}

int
main (int argc, char **argv)
{
	g_test_init (&argc, &argv, NULL);
	gtk_init ();

/* only critical and error are fatal */
	g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);

/* tests go here */
	g_test_add_func ("/colord/window", colord_window_func);
	g_test_add_func ("/colors/sample-window", colord_sample_window_func);
	return g_test_run ();
}

0707010000001B000081A400000000000000000000000161CC381A00000D93000000000000000000000000000000000000003000000000colord-gtk-0.2.0+8/libcolord-gtk/cd-self-test.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2010-2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include "config.h"

#include <colord.h>
#include <glib.h>
#include <glib-object.h>
#include <gtk/gtk.h>

#include "cd-sample-window.h"
#include "cd-window.h"

/* kill the dialog */
	gtk_widget_destroy (widget);
}

static void
map_cb (GtkWidget *this_widget, gpointer user_data)
{
	CdWindow *window = CD_WINDOW (user_data);

/* get the profile for this widget */
	cd_window_get_profile (window,
			       this_widget,
			       NULL,
			       cd_window_get_profile_cb,
			       this_widget);
}

static void
colord_window_func (void)
{
	CdWindow *window;
	GtkWidget *dialog;

static gboolean
colord_sample_window_loop_cb (GMainLoop *loop)
{
	g_main_loop_quit (loop);
	return FALSE;
}

static void
colord_sample_window_func (void)
{
	GtkWindow *window;
	GMainLoop *loop;
	CdColorRGB source;

/* move to the center of device lvds1 */
	gtk_window_present (window);

loop = g_main_loop_new (NULL, FALSE);
	g_timeout_add_seconds (5, (GSourceFunc) colord_sample_window_loop_cb, loop);
	g_main_loop_run (loop);

g_main_loop_unref (loop);
	gtk_widget_destroy (GTK_WIDGET (window));
}

int
main (int argc, char **argv)
{
	g_type_init ();
	g_test_init (&argc, &argv, NULL);
	gtk_init (&argc, &argv);

/* only critical and error are fatal */
	g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);

/* tests go here */
	g_test_add_func ("/colord/window", colord_window_func);
	g_test_add_func ("/colors/sample-window", colord_sample_window_func);
	return g_test_run ();
}

0707010000001C000081A400000000000000000000000161CC381A0000089E000000000000000000000000000000000000003100000000colord-gtk-0.2.0+8/libcolord-gtk/cd-version.h.in/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2010 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

/**
 * SECTION:cd-version
 * @short_description: Obtains the version for the installed colord
 *
 * These compile time macros allow the user to enable parts of client code
 * depending on the version of libcolord installed.
 *
 * See also: #CdClient, #CdDevice
 */

#if !defined (__COLORD_GTK_H_INSIDE__) && !defined (CD_COMPILATION)
#error "Only <colord.h> can be included directly."
#endif

#ifndef __CD_VERSION_H
#define __CD_VERSION_H

/**
 * CD_GTK_MAJOR_VERSION:
 *
 * The compile-time major version
 */
#define CD_GTK_MAJOR_VERSION				(@CD_GTK_MAJOR_VERSION@)

/**
 * CD_GTK_MINOR_VERSION:
 *
 * The compile-time minor version
 */
#define CD_GTK_MINOR_VERSION				(@CD_GTK_MINOR_VERSION@)

/**
 * CD_GTK_MICRO_VERSION:
 *
 * The compile-time micro version
 */
#define CD_GTK_MICRO_VERSION				(@CD_GTK_MICRO_VERSION@)

/**
 * CD_CHECK_VERSION:
 *
 * Check whether a colord version equal to or greater than
 * major.minor.micro.
 */
#define CD_CHECK_VERSION(major,minor,micro)    \
    (CD_GTK_MAJOR_VERSION > (major) || \
     (CD_GTK_MAJOR_VERSION == (major) && CD_GTK_MINOR_VERSION > (minor)) || \
     (CD_GTK_MAJOR_VERSION == (major) && CD_GTK_MINOR_VERSION == (minor) && \
      CD_GTK_MICRO_VERSION >= (micro)))

#endif /* __CD_VERSION_H */
0707010000001D000081A400000000000000000000000161CC381A00000AF9000000000000000000000000000000000000003200000000colord-gtk-0.2.0+8/libcolord-gtk/cd-window-sync.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

/**
 * SECTION:cd-window-sync
 * @short_description: Sync helpers for #CdWindow
 *
 * These helper functions provide a simple way to use the async functions
 * in command line tools.
 *
 * See also: #CdWindow
 */

#include "config.h"

#include <glib.h>
#include <gio/gio.h>

#include <colord.h>

#include "cd-window.h"
#include "cd-window-sync.h"

/* tiny helper to help us do the async operation */
typedef struct {
	GError		**error;
	GMainLoop	*loop;
	CdProfile	*profile;
	CdWindow	*window;
} CdWindowHelper;

/**********************************************************************/

static void
cd_window_get_profile_finish_sync (CdWindow *window,
				   GAsyncResult *res,
				   CdWindowHelper *helper)
{
	helper->profile = cd_window_get_profile_finish (window,
							res,
							helper->error);
	g_main_loop_quit (helper->loop);
}

/**
 * cd_window_get_profile_sync:
 * @window: a #CdWindow instance.
 * @widget: a #GtkWidget
 * @cancellable: a #GCancellable or %NULL
 * @error: a #GError, or %NULL.
 *
 * Gets the screen profile that should be used for the widget,
 * which corresponds to the screen output the widget most covers.
 *
 * WARNING: This function is synchronous, and may block.
 * Do not use it in GUI applications.
 *
 * Return value: (transfer full): a #CdProfile or %NULL
 *
 * Since: 0.1.20
 **/
CdProfile *
cd_window_get_profile_sync (CdWindow *window,
			    GtkWidget *widget,
			    GCancellable *cancellable,
			    GError **error)
{
	CdWindowHelper helper;

/* create temp object */
	helper.loop = g_main_loop_new (NULL, FALSE);
	helper.error = error;

/* run async method */
	cd_window_get_profile (window, widget, cancellable,
				(GAsyncReadyCallback) cd_window_get_profile_finish_sync,
				&helper);
	g_main_loop_run (helper.loop);

/* free temp object */
	g_main_loop_unref (helper.loop);

return helper.profile;
}
0707010000001E000081A400000000000000000000000161CC381A00000573000000000000000000000000000000000000003200000000colord-gtk-0.2.0+8/libcolord-gtk/cd-window-sync.h/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#if !defined (__COLORD_GTK_H_INSIDE__) && !defined (CD_COMPILATION)
#error "Only <colord-gtk.h> can be included directly."
#endif

#ifndef __CD_WINDOW_SYNC_H
#define __CD_WINDOW_SYNC_H

#include <glib-object.h>
#include <gio/gio.h>

G_BEGIN_DECLS

CdProfile	*cd_window_get_profile_sync		(CdWindow	*window,
							 GtkWidget	*widget,
							 GCancellable	*cancellable,
							 GError		**error);

G_END_DECLS

#endif /* __CD_WINDOW_SYNC_H */

0707010000001F000081A400000000000000000000000161CC381A00003BF0000000000000000000000000000000000000002D00000000colord-gtk-0.2.0+8/libcolord-gtk/cd-window.c/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

/**
 * SECTION:cd-window
 * @short_description: Additional helper classes for working with GTK
 *
 * These functions are useful when GTK is being used alongside colord and
 * are just provided for convenience.
 *
 * See also: #CdDevice
 */

#include "config.h"

#include <gio/gio.h>
#include <glib.h>
#include <gtk/gtk.h>

#include <colord.h>

#include "cd-window.h"

static void	cd_window_class_init	(CdWindowClass	*klass);
static void	cd_window_init		(CdWindow	*window);
static void	cd_window_finalize	(GObject	*object);

#define CD_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CD_TYPE_WINDOW, CdWindowPrivate))

/**
 * CdWindowPrivate:
 *
 * Private #CdWindow data
 **/
struct _CdWindowPrivate
{
	CdClient		*client;
	CdDevice		*device;
	CdProfile		*profile;
	gchar			*plug_name;
	GtkWidget		*widget;
	guint			 device_changed_id;
};

enum {
	SIGNAL_CHANGED,
	SIGNAL_LAST
};

enum {
	PROP_0,
	PROP_PROFILE,
	PROP_LAST
};

static guint signals [SIGNAL_LAST] = { 0 };

G_DEFINE_TYPE (CdWindow, cd_window, G_TYPE_OBJECT)

/**
 * cd_window_error_quark:
 *
 * Return value: An error quark.
 *
 * Since: 0.1.20
 **/
GQuark
cd_window_error_quark (void)
{
	static GQuark quark = 0;
	if (!quark) {
		quark = g_quark_from_static_string ("cd_window_error");
	}
	return quark;
}

/**
 * cd_window_get_last_profile:
 * @window: a #CdWindow instance.
 *
 * Gets the color profile to use for this widget.
 *
 * Return value: (transfer none): a #CdProfile
 *
 * Since: 0.1.20
 **/
CdProfile *
cd_window_get_last_profile (CdWindow *window)
{
	g_return_val_if_fail (CD_IS_WINDOW (window), NULL);
	return window->priv->profile;
}

typedef struct {
	CdWindow		*window;
	GCancellable		*cancellable;
	GSimpleAsyncResult	*res;
} CdWindowSetWidgetHelper;

/**
 * cd_window_get_profile_finish:
 * @window: a #CdWindow instance.
 * @res: the #GAsyncResult
 * @error: A #GError or %NULL
 *
 * Gets the result from the asynchronous function.
 *
 * Return value: (transfer full): a #CdProfile or %NULL
 *
 * Since: 0.1.20
 **/
CdProfile *
cd_window_get_profile_finish (CdWindow *window,
			      GAsyncResult *res,
			      GError **error)
{
	GSimpleAsyncResult *simple;

g_return_val_if_fail (CD_IS_WINDOW (window), NULL);
	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), NULL);
	g_return_val_if_fail (error == NULL || *error == NULL, NULL);

simple = G_SIMPLE_ASYNC_RESULT (res);
	if (g_simple_async_result_propagate_error (simple, error))
		return NULL;

return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
}

static void
cd_window_import_free_helper (CdWindowSetWidgetHelper *helper)
{
	if (helper->cancellable != NULL)
		g_object_unref (helper->cancellable);
	g_object_unref (helper->window);
	g_object_unref (helper->res);
	g_free (helper);
}

static void cd_window_get_profile_new_data (CdWindowSetWidgetHelper *helper);

static void
cd_window_get_profile_client_connect_cb (GObject *source,
					 GAsyncResult *res,
					 gpointer user_data)
{
	CdClient *client = CD_CLIENT (source);
	CdWindowSetWidgetHelper *helper = (CdWindowSetWidgetHelper *) user_data;
	gboolean ret;
	GError *error = NULL;

ret = cd_client_connect_finish (client, res, &error);
	if (!ret) {
		g_simple_async_result_set_error (helper->res,
						 CD_WINDOW_ERROR,
						 CD_WINDOW_ERROR_FAILED,
						 "failed to connect to colord: %s",
						 error->message);
		g_simple_async_result_complete_in_idle (helper->res);
		cd_window_import_free_helper (helper);
		g_error_free (error);
		return;
	}
	cd_window_get_profile_new_data (helper);
}

static void
cd_window_get_profile_device_connect_cb (GObject *source,
					 GAsyncResult *res,
					 gpointer user_data)
{
	CdDevice *device = CD_DEVICE (source);
	CdWindowSetWidgetHelper *helper = (CdWindowSetWidgetHelper *) user_data;
	CdWindowPrivate *priv = helper->window->priv;
	gboolean ret;
	GError *error = NULL;

ret = cd_device_connect_finish (device, res, &error);
	if (!ret) {
		g_simple_async_result_set_error (helper->res,
						 CD_WINDOW_ERROR,
						 CD_WINDOW_ERROR_FAILED,
						 "failed to connect to device: %s",
						 error->message);
		g_simple_async_result_complete_in_idle (helper->res);
		cd_window_import_free_helper (helper);
		g_error_free (error);
		return;
	}

/* get the default profile for the device */
	priv->profile = cd_device_get_default_profile (priv->device);
	if (priv->profile == NULL) {
		g_simple_async_result_set_error (helper->res,
						 CD_WINDOW_ERROR,
						 CD_WINDOW_ERROR_FAILED,
						 "no default profile for device: %s",
						 priv->plug_name);
		g_simple_async_result_complete_in_idle (helper->res);
		cd_window_import_free_helper (helper);
		return;
	}

cd_window_get_profile_new_data (helper);
}

static void
cd_window_get_profile_profile_connect_cb (GObject *source,
					  GAsyncResult *res,
					  gpointer user_data)
{
	CdProfile *profile = CD_PROFILE (source);
	CdWindowSetWidgetHelper *helper = (CdWindowSetWidgetHelper *) user_data;
	CdWindowPrivate *priv = helper->window->priv;
	const gchar *filename;
	gboolean ret;
	GError *error = NULL;

ret = cd_profile_connect_finish (profile, res, &error);
	if (!ret) {
		g_simple_async_result_set_error (helper->res,
						 CD_WINDOW_ERROR,
						 CD_WINDOW_ERROR_FAILED,
						 "failed to connect to profile: %s",
						 error->message);
		g_simple_async_result_complete_in_idle (helper->res);
		cd_window_import_free_helper (helper);
		g_error_free (error);
		return;
	}

/* get the filename of the profile */
	filename = cd_profile_get_filename (priv->profile);
	if (filename == NULL) {
		g_simple_async_result_set_error (helper->res,
						 CD_WINDOW_ERROR,
						 CD_WINDOW_ERROR_FAILED,
						 "profile has no physical file, must be virtual");
		g_simple_async_result_complete_in_idle (helper->res);
		cd_window_import_free_helper (helper);
		return;
	}

/* SUCCESS! */
	g_simple_async_result_set_op_res_gpointer (helper->res,
						   g_object_ref (priv->profile),
						   (GDestroyNotify) g_object_unref);
	g_simple_async_result_complete_in_idle (helper->res);
	cd_window_import_free_helper (helper);
}

static void
cd_window_get_profile_device_find_cb (GObject *source,
				      GAsyncResult *res,
				      gpointer user_data)
{
	CdClient *client = CD_CLIENT (source);
	CdWindowSetWidgetHelper *helper = (CdWindowSetWidgetHelper *) user_data;
	CdWindowPrivate *priv = helper->window->priv;
	GError *error = NULL;

priv->device = cd_client_find_device_by_property_finish (client,
								 res,
								 &error);
	if (priv->device == NULL) {
		g_simple_async_result_set_error (helper->res,
						 CD_WINDOW_ERROR,
						 CD_WINDOW_ERROR_FAILED,
						 "no device with that property: %s",
						 error->message);
		g_simple_async_result_complete_in_idle (helper->res);
		cd_window_import_free_helper (helper);
		g_error_free (error);
		return;
	}
	cd_window_get_profile_new_data (helper);
}

static void
cd_window_device_changed_cb (CdDevice *device, CdWindow *window)
{
	CdProfile *profile;

/* no device set yet */
	if (window->priv->device == NULL)
		return;

/* the same device */
	if (!cd_device_equal (device, window->priv->device))
		return;

/* get new default profile */
	profile = cd_device_get_default_profile (window->priv->device);
	if (cd_profile_equal (profile, window->priv->profile))
		return;

/* replace profile instance and emit if changed */
	if (window->priv->profile != NULL)
		g_object_unref (window->priv->profile);
	window->priv->profile = g_object_ref (profile);
	g_signal_emit (window, signals[SIGNAL_CHANGED], 0,
		       window->priv->profile);
}

static void
cd_window_get_profile_new_data (CdWindowSetWidgetHelper *helper)
{
	CdWindowPrivate *priv = helper->window->priv;

/* connect to the daemon */
	if (priv->client == NULL) {
		priv->client = cd_client_new ();
		priv->device_changed_id =
			g_signal_connect (priv->client, "device-changed",
					  G_CALLBACK (cd_window_device_changed_cb),
					  helper->window);
		cd_client_connect (priv->client,
				   helper->cancellable,
				   cd_window_get_profile_client_connect_cb,
				   helper);
		goto out;
	}

/* find the new device */
	if (priv->device == NULL && priv->plug_name != NULL) {
		cd_client_find_device_by_property (priv->client,
						   CD_DEVICE_METADATA_XRANDR_NAME,
						   priv->plug_name,
						   helper->cancellable,
						   cd_window_get_profile_device_find_cb,
						   helper);
		goto out;
	}

/* connect to the device */
	if (priv->device != NULL && !cd_device_get_connected (priv->device)) {
		cd_device_connect (priv->device,
				   helper->cancellable,
				   cd_window_get_profile_device_connect_cb,
				   helper);
		goto out;
	}

/* connect to the profile */
	if (priv->profile != NULL && !cd_profile_get_connected (priv->profile)) {
		cd_profile_connect (priv->profile,
				    helper->cancellable,
				    cd_window_get_profile_profile_connect_cb,
				    helper);
		goto out;
	}
out:
	return;
}

static void
cd_window_update_widget_plug_name (CdWindow *window,
				   GtkWidget *widget)
{
	CdWindowPrivate *priv = window->priv;
	gchar *plug_name;

#ifndef BUILD_COLORD_GTK4
	GdkScreen *screen;
	GdkWindow *gdk_window;
	gint monitor_num;

/* use the largest bounding area */
	gdk_window = gtk_widget_get_window (widget);
	screen = gdk_window_get_screen (gdk_window);

monitor_num = gdk_screen_get_monitor_at_window (screen,
							gdk_window);
	plug_name = gdk_screen_get_monitor_plug_name (screen, monitor_num);
#else
	GdkSurface *surface;
	GdkDisplay *display;
	GdkMonitor *monitor;
	GtkNative *native;

native = gtk_widget_get_native (widget);
	surface = gtk_native_get_surface (native);
	display = gtk_widget_get_display (widget);
	monitor = gdk_display_get_monitor_at_surface (display, surface);
	plug_name = g_strdup (gdk_monitor_get_connector (monitor));
#endif

/* ignoring MAP as plug_name has not changed */
	if (g_strcmp0 (plug_name, priv->plug_name) == 0) {
		g_free (plug_name);
		return;
	}

/* refresh data */
	g_free (priv->plug_name);
	priv->plug_name = plug_name;
	if (priv->device != NULL) {
		g_object_unref (priv->device);
		priv->device = NULL;
	}
	if (priv->profile != NULL) {
		g_object_unref (priv->profile);
		priv->profile = NULL;
	}
}

/**
 * cd_window_get_profile:
 * @window: a #CdWindow instance.
 * @widget: a #GtkWidget
 * @cancellable: a #GCancellable or %NULL
 * @callback: the function to run on completion
 * @user_data: the data to pass to @callback
 *
 * Gets the screen profile that should be used for the widget,
 * which corresponds to the screen output the widget most covers.
 *
 * This method should be called when the widget has mapped, i.e.
 * g_signal_connect (dialog, "map", G_CALLBACK (map_cb), priv);
 *
 * Note, the returned profile from cd_client_get_profile_for_widget_finish()
 * has already been connected to, as is ready to use.
 *
 * Since: 0.1.20
 **/
void
cd_window_get_profile (CdWindow *window,
		      GtkWidget *widget,
		      GCancellable *cancellable,
		      GAsyncReadyCallback callback,
		      gpointer user_data)
{
	CdWindowSetWidgetHelper *helper;

g_return_if_fail (CD_IS_WINDOW (window));
	g_return_if_fail (GTK_IS_WIDGET (widget));
	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

helper = g_new0 (CdWindowSetWidgetHelper, 1);
	helper->window = g_object_ref (window);
	helper->res = g_simple_async_result_new (G_OBJECT (window),
						 callback,
						 user_data,
						 cd_window_get_profile);
	if (cancellable != NULL)
		helper->cancellable = g_object_ref (cancellable);

/* intially set the plug name */
	window->priv->widget = g_object_ref (widget);
	cd_window_update_widget_plug_name (window, widget);
	cd_window_get_profile_new_data (helper);
}

/**********************************************************************/

/*
 * cd_window_get_property:
 */
static void
cd_window_get_property (GObject *object,
			guint prop_id,
			GValue *value,
			GParamSpec *pspec)
{
	CdWindow *window = CD_WINDOW (object);

switch (prop_id) {
	case PROP_PROFILE:
		g_value_set_object (value, window->priv->profile);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}

/*
 * cd_window_class_init:
 */
static void
cd_window_class_init (CdWindowClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->get_property = cd_window_get_property;
	object_class->finalize = cd_window_finalize;

/**
	 * CdWindow:profile:
	 *
	 * The window profile.
	 *
	 * Since: 0.1.20
	 */
	g_object_class_install_property (object_class,
					 PROP_PROFILE,
					 g_param_spec_string ("Profile",
							      "Color profile",
							      NULL,
							      NULL,
							      G_PARAM_READABLE));

/**
	 * CdWindow::changed:
	 * @window: the #CdDevice instance that emitted the signal
	 *
	 * The ::changed signal is emitted when the device profile has
	 * changed. The #CdProfile that is referenced in the callback
	 * has not been connected to, and you will need to call
	 * cd_profile_connect() if the ICC filename is required.
	 *
	 * Since: 0.1.20
	 **/
	signals [SIGNAL_CHANGED] =
		g_signal_new ("changed",
			      G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
			      G_STRUCT_OFFSET (CdWindowClass, changed),
			      NULL, NULL, g_cclosure_marshal_VOID__OBJECT,
			      G_TYPE_NONE, 1, CD_TYPE_PROFILE);

g_type_class_add_private (klass, sizeof (CdWindowPrivate));
}

/*
 * cd_window_init:
 */
static void
cd_window_init (CdWindow *window)
{
	window->priv = CD_WINDOW_GET_PRIVATE (window);

/* ensure the remote errors are registered */
	cd_window_error_quark ();
}

/*
 * cd_window_finalize:
 */
static void
cd_window_finalize (GObject *object)
{
	CdWindow *window = CD_WINDOW (object);

g_return_if_fail (CD_IS_WINDOW (object));

if (window->priv->client != NULL) {
		g_signal_handler_disconnect (window->priv->client,
					     window->priv->device_changed_id);
		g_object_unref (window->priv->client);
	}
	if (window->priv->device != NULL)
		g_object_unref (window->priv->device);
	if (window->priv->profile != NULL)
		g_object_unref (window->priv->profile);
	g_free (window->priv->plug_name);

G_OBJECT_CLASS (cd_window_parent_class)->finalize (object);
}

/**
 * cd_window_new:
 *
 * Creates a new #CdWindow object.
 *
 * Return value: a new CdWindow object.
 *
 * Since: 0.1.20
 **/
CdWindow *
cd_window_new (void)
{
	CdWindow *window;
	window = g_object_new (CD_TYPE_WINDOW, NULL);
	return CD_WINDOW (window);
}
07070100000020000081A400000000000000000000000161CC381A00000C51000000000000000000000000000000000000002D00000000colord-gtk-0.2.0+8/libcolord-gtk/cd-window.h/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2012 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#if !defined (__COLORD_GTK_H_INSIDE__) && !defined (CD_COMPILATION)
#error "Only <colord-gtk.h> can be included directly."
#endif

#ifndef __CD_WINDOW_H
#define __CD_WINDOW_H

#include <glib-object.h>
#include <gio/gio.h>
#include <gtk/gtk.h>

G_BEGIN_DECLS

#define CD_TYPE_WINDOW		(cd_window_get_type ())
#define CD_WINDOW(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), CD_TYPE_WINDOW, CdWindow))
#define CD_WINDOW_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), CD_TYPE_WINDOW, CdWindowClass))
#define CD_IS_WINDOW(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), CD_TYPE_WINDOW))
#define CD_IS_WINDOW_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), CD_TYPE_WINDOW))
#define CD_WINDOW_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), CD_TYPE_WINDOW, CdWindowClass))
#define CD_WINDOW_ERROR		(cd_window_error_quark ())
#define CD_WINDOW_TYPE_ERROR	(cd_window_error_get_type ())

typedef struct _CdWindowPrivate CdWindowPrivate;

typedef struct
{
	 GObject		 parent;
	 CdWindowPrivate	*priv;
} CdWindow;

typedef struct
{
	GObjectClass		 parent_class;
	void			(*changed)	(CdWindow	*window,
						 CdProfile	*profile);
	/*< private >*/
	/* Padding for future expansion */
	void (*_cd_window_reserved1) (void);
	void (*_cd_window_reserved2) (void);
	void (*_cd_window_reserved3) (void);
	void (*_cd_window_reserved4) (void);
	void (*_cd_window_reserved5) (void);
	void (*_cd_window_reserved6) (void);
	void (*_cd_window_reserved7) (void);
	void (*_cd_window_reserved8) (void);
} CdWindowClass;

/**
 * CdWindowError:
 * @CD_WINDOW_ERROR_FAILED: the transaction failed for an unknown reason
 *
 * Errors that can be thrown
 */
typedef enum
{
	CD_WINDOW_ERROR_FAILED,
	CD_WINDOW_ERROR_LAST
} CdWindowError;

GType		 cd_window_get_type			(void);
GQuark		 cd_window_error_quark			(void);
CdWindow	*cd_window_new				(void);

/* async */
void		cd_window_get_profile			(CdWindow	*window,
							 GtkWidget	*widget,
							 GCancellable	*cancellable,
							 GAsyncReadyCallback callback,
							 gpointer	 user_data);
CdProfile	*cd_window_get_profile_finish		(CdWindow	*window,
							 GAsyncResult	*res,
							 GError		**error);

/* getters */
CdProfile	*cd_window_get_last_profile		(CdWindow	*window);

G_END_DECLS

#endif /* __CD_WINDOW_H */

07070100000021000081A400000000000000000000000161CC381A00000608000000000000000000000000000000000000002E00000000colord-gtk-0.2.0+8/libcolord-gtk/colord-gtk.h/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
 *
 * Copyright (C) 2010-2011 Richard Hughes <richard@hughsie.com>
 *
 * Licensed under the GNU Lesser General Public License Version 2.1
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

/**
 * SECTION:colord-gtk
 * @short_description: Client objects for accessing colord with GTK
 *
 * These objects allow client programs to get access to profiles.
 *
 * See also: #CdClient, #CdDevice
 */

#ifndef __COLORD_GTK_H__
#define __COLORD_GTK_H__

#define __COLORD_GTK_H_INSIDE__

#include <gtk/gtk.h>
#include <colord.h>

#include <colord-gtk/cd-sample-widget.h>
#include <colord-gtk/cd-sample-window.h>
#include <colord-gtk/cd-version.h>
#include <colord-gtk/cd-window.h>
#include <colord-gtk/cd-window-sync.h>

#undef __COLORD_GTK_H_INSIDE__

#endif /* __COLORD_GTK_H__ */

07070100000022000081A400000000000000000000000161CC381A00001176000000000000000000000000000000000000002D00000000colord-gtk-0.2.0+8/libcolord-gtk/meson.buildcargs = [
  '-DG_LOG_DOMAIN="libcolord-gtk"',
]

colord_gtk_version_h = configure_file(
  input : 'cd-version.h.in',
  output : 'cd-version.h',
  configuration : conf,
)

install_headers(
  'colord-gtk.h',
  subdir : 'colord-1',
)

colord_gtk_incdir = include_directories('.')

install_headers([
    'cd-sample-widget.h',
    'cd-sample-window.h',
    'cd-window.h',
    'cd-window-sync.h',
    colord_gtk_version_h,
  ],
  subdir : 'colord-1/colord-gtk',
)

pkgg = import('pkgconfig')

if get_option('gtk2')
  colord_gtk2 = shared_library(
    'colord-gtk2',
    sources : [
      'cd-window.c',
      'cd-window-sync.c',
    ],
    soversion : lt_current,
    version : lt_version,
    dependencies : [
      glib,
      gio,
      gtk2,
      colord,
    ],
    c_args : [
      cargs,
    ],
    include_directories : [
      root_incdir,
    ],
    install : true
  )

pkgg.generate(
    libraries : colord_gtk2,
    requires : [ 'colord', 'gtk+-2.0' ],
    subdirs : 'colord-1',
    version : meson.project_version(),
    name : 'colord-gtk2',
    filebase : 'colord-gtk2',
    description : 'colord-gtk is GTK2 integration for libcolord',
  )
endif

if get_option('gtk3')
  colord_gtk = shared_library(
    'colord-gtk',
    sources : [
      'cd-sample-widget.c',
      'cd-sample-window.c',
      'cd-window.c',
      'cd-window-sync.c',
    ],
    soversion : lt_current,
    version : lt_version,
    dependencies : [
      glib,
      gio,
      gtk3,
      colord,
    ],
    c_args : [
      cargs,
    ],
    include_directories : [
      root_incdir,
    ],
    install : true
  )

pkgg.generate(
    libraries : colord_gtk,
    requires : [ 'colord', 'gtk+-3.0' ],
    subdirs : 'colord-1',
    version : meson.project_version(),
    name : 'colord-gtk',
    filebase : 'colord-gtk',
    description : 'colord-gtk is GTK integration for libcolord',
  )

if get_option('introspection')
  libcolord_gtk_gir = gnome.generate_gir(
    colord_gtk,
    sources : [
      'cd-sample-widget.c',
      'cd-sample-widget.h',
      'cd-sample-window.c',
      'cd-sample-window.h',
      'cd-window.c',
      'cd-window.h',
      'cd-window-sync.c',
      'cd-window-sync.h',
      colord_gtk_version_h,
    ],
    nsversion : '1.0',
    namespace : 'ColordGtk',
    symbol_prefix : 'cd',
    identifier_prefix : 'Cd',
    export_packages : 'colord-gtk',
    extra_args : [
      '--c-include=colord-gtk.h',
      '-DCD_COMPILATION',
      ],
    dependencies : [
      glib,
      gio,
      gtk3,
      colord,
    ],
    includes : [
      'GObject-2.0',
      'Gio-2.0',
      'Gtk-3.0',
      'Colord-1.0',
    ],
    install : true
  )
  endif

if get_option('vapi')
    gnome.generate_vapi(
      'colord-gtk',
      sources: libcolord_gtk_gir[0],
      packages: [ 'glib-2.0', 'gio-2.0', 'gtk+-3.0', 'colord' ],
      install: true,
    )
  endif

if get_option('tests')
    e = executable(
      'colord-gtk-test',
      sources : [
        'cd-self-test.c',
      ],
      include_directories : [
        root_incdir,
      ],
      dependencies : [
        glib,
        gio,
        gtk3,
        colord,
      ],
      link_with : colord_gtk,
      c_args : [
        cargs,
      ]
    )
  test('colord-test-private', e)
  endif
endif

if get_option('gtk4')
  colord_gtk4 = shared_library(
    'colord-gtk4',
    sources : [
      'cd-sample-widget-gtk4.c',
      'cd-sample-window-gtk4.c',
      'cd-window.c',
      'cd-window-sync.c',
    ],
    soversion : lt_current,
    version : lt_version,
    dependencies : [
      glib,
      gio,
      gtk4,
      colord,
    ],
    c_args : [
      cargs,
      '-DBUILD_COLORD_GTK4',
    ],
    include_directories : [
      root_incdir,
    ],
    install : true
  )

pkgg.generate(
    libraries : colord_gtk4,
    requires : [ 'colord', 'gtk4' ],
    subdirs : 'colord-1',
    version : meson.project_version(),
    name : 'colord-gtk4',
    filebase : 'colord-gtk4',
    description : 'colord-gtk4 is GTK4 integration for libcolord',
  )

if get_option('tests')
    e = executable(
        'colord-gtk4-test',
        sources : [
          'cd-self-test-gtk4.c',
        ],
        include_directories : [
          root_incdir,
        ],
        dependencies : [
          glib,
          gio,
          gtk4,
          colord,
        ],
        link_with : colord_gtk4,
        c_args : [
          cargs,
        ]
      )
    test('colord-gtk4-test-private', e)
  endif

endif
07070100000023000041ED00000000000000000000000261CC381A00000000000000000000000000000000000000000000001700000000colord-gtk-0.2.0+8/man07070100000024000081A400000000000000000000000161CC381A0000075A000000000000000000000000000000000000002600000000colord-gtk-0.2.0+8/man/cd-convert.xml<refentry xmlns="http://docbook.org/ns/docbook" version="5.0">
  <info>
    <address>
      <email>richard@hughsie.com</email>;
    </address>
    <author>
      <personname>
        <firstname>Richard</firstname>
        <surname>Hughes</surname>
      </personname>
    </author>
    <copyright>
      <year>2014</year>
      <holder>Richard Hughes</holder>
    </copyright>
    <date>7 November,2014</date>
  </info>
  <refmeta>
    <refentrytitle>cd-convert</refentrytitle>
    <manvolnum>1</manvolnum>
    <refmiscinfo class="manual">User Commands</refmiscinfo>
  </refmeta>
  <refnamediv>
    <refname>cd-convert</refname>
    <refpurpose>Color Manager Testing Tool</refpurpose>
  </refnamediv>
  <refsynopsisdiv>
    <cmdsynopsis>
      <command>cd-convert</command>
      <arg><option>--verbose</option></arg>
    </cmdsynopsis>
  </refsynopsisdiv>
  <refsect1>
    <title>DESCRIPTION</title>
    <para>
      This manual page documents briefly the <command>cd-convert</command> command.
    </para>
    <para>
      <command>cd-convert</command> allows an administrator to create
      IT8 files, such as <filename>.ti3</filename>, <filename>.ccmx</filename>
      in various ways.
    </para>
  </refsect1>
  <refsect1>
    <title>OPTIONS</title>
    <para>
      This program follows the usual <acronym>GNU</acronym> command line syntax,
      with long options starting with two dashes (`-').  A summary of
      options is included below.
    </para>
    <variablelist>
      <varlistentry>
        <term>
          <option>--help</option>
        </term>
        <listitem>
          <para>Show summary of options.</para>
        </listitem>
      </varlistentry>
    </variablelist>
  </refsect1>
  <refsect1>
    <title>AUTHOR</title>
    <para>This manual page was written by Richard Hughes <email>richard@hughsie.com</email>.
    </para>
  </refsect1>
</refentry>
07070100000025000081A400000000000000000000000161CC381A00000330000000000000000000000000000000000000002300000000colord-gtk-0.2.0+8/man/meson.buildxsltproc = find_program('xsltproc')

stylesheet_url = 'http://docbook.sourceforge.net/release/xsl-ns/current/manpages/docbook.xsl'
ret = run_command(xsltproc, '--nonet', stylesheet_url)
if ret.returncode() != 0
  error('Cannot build man pages without docbook-xsl-ns')
endif

xsltproc_args = [
  xsltproc,
  '--output', '@OUTPUT@',
  '--nonet',
  '--stringparam', 'man.authors.section.enabled', '0',
  '--stringparam', 'man.copyright.section.enabled', '0',
  '--stringparam', 'man.output.quietly', '1',
  '--stringparam', 'man.th.extra1.suppress', '1',
  '--stringparam', 'funcsynopsis.style', 'ansi',
  stylesheet_url,
  '@INPUT@',
]

custom_target(
  'cd-convert-man',
  input : 'cd-convert.xml',
  output : '@BASENAME@.1',
  command : xsltproc_args,
  install : true,
  install_dir : join_paths(mandir, 'man1'),
)
07070100000026000081A400000000000000000000000161CC381A00001035000000000000000000000000000000000000001F00000000colord-gtk-0.2.0+8/meson.buildproject('colord-gtk', 'c',
  version : '0.2.1',
  license : 'LGPL-2.1+',
  meson_version : '>=0.46.0',
  default_options : ['c_std=c99']
)

colord_gtk_version = meson.project_version()
varr = colord_gtk_version.split('.')
colord_gtk_major_version = varr[0]
colord_gtk_minor_version = varr[1]
colord_gtk_micro_version = varr[2]

conf = configuration_data()
conf.set('CD_GTK_MAJOR_VERSION', colord_gtk_major_version)
conf.set('CD_GTK_MINOR_VERSION', colord_gtk_minor_version)
conf.set('CD_GTK_MICRO_VERSION', colord_gtk_micro_version)
conf.set_quoted('PACKAGE_VERSION', colord_gtk_version)

# libtool versioning - this applies to libcolord
#
# See http://sources.redhat.com/autobook/autobook/autobook_91.html#SEC91 for details
#
# - If interfaces have been changed or added, but binary compatibility
#   has been preserved, change:
#      CURRENT += 1
#      REVISION = 0
#      AGE += 1
# - If binary compatibility has been broken (eg removed or changed
#   interfaces), change:
#      CURRENT += 1
#      REVISION = 0
#      AGE = 0
# - If the interface is the same as the previous version, but bugs are
#   fixed, change:
#      REVISION += 1
lt_current = '1'
lt_revision = '3'
lt_age = '0'
lt_version = '@0@.@1@.@2@'.format(lt_current, lt_age, lt_revision)

# get supported warning flags
test_args = [
  '-fstack-protector-strong',
  '-Waggregate-return',
  '-Wunused',
  '-Warray-bounds',
  '-Wcast-align',
  '-Wclobbered',
  '-Wdeclaration-after-statement',
  '-Wempty-body',
  '-Wextra',
  '-Wformat=2',
  '-Wformat-nonliteral',
  '-Wformat-security',
  '-Wformat-signedness',
  '-Wignored-qualifiers',
  '-Wimplicit-function-declaration',
  '-Winit-self',
  '-Wmissing-declarations',
  '-Wmissing-format-attribute',
  '-Wmissing-include-dirs',
  '-Wmissing-noreturn',
  '-Wmissing-parameter-type',
  '-Wmissing-prototypes',
  '-Wnested-externs',
  '-Wno-discarded-qualifiers',
  '-Wno-missing-field-initializers',
  '-Wno-strict-aliasing',
  '-Wno-suggest-attribute=format',
  '-Wno-unused-parameter',
  '-Wold-style-definition',
  '-Woverride-init',
  '-Wpointer-arith',
  '-Wreturn-type',
  '-Wshadow',
  '-Wsign-compare',
  '-Wstrict-aliasing',
  '-Wstrict-prototypes',
  '-Wswitch-default',
  '-Wtype-limits',
  '-Wundef',
  '-Wuninitialized',
  '-Wunused-but-set-variable',
  '-Wwrite-strings'
]

cc = meson.get_compiler('c')
foreach arg: test_args
  if cc.has_argument(arg)
    add_project_arguments(arg, language : 'c')
  endif
endforeach

glib = dependency('glib-2.0', version : '>= 2.28.0')
gio = dependency('gio-2.0', version : '>= 2.25.9Z')
colord = dependency('colord', version : '>= 0.1.27')

if get_option('gtk2')
  gtk2 = dependency('gtk+-2.0')
  conf.set('HAVE_GTK2', '1')
endif

if get_option('gtk3')
  gtk3 = dependency('gtk+-3.0')
endif

if get_option('gtk4')
  gtk4 = dependency('gtk4', version : '>= 4.4')
endif

gnome = import('gnome')
i18n = import('i18n')

add_project_arguments('-DCD_COMPILATION', language: 'c')

prefix = get_option('prefix')

bindir = join_paths(prefix, get_option('bindir'))
libdir = join_paths(prefix, get_option('libdir'))
datadir = join_paths(prefix, get_option('datadir'))
libexecdir = join_paths(prefix, get_option('libexecdir'))
localstatedir = join_paths(prefix, get_option('localstatedir'))
sysconfdir = join_paths(prefix, get_option('sysconfdir'))
mandir = join_paths(prefix, get_option('mandir'))
includedir = join_paths(prefix, get_option('includedir'))

conf.set_quoted('SYSCONFDIR', sysconfdir)
conf.set_quoted('BINDIR', bindir)
conf.set_quoted('LIBDIR', libdir)
conf.set_quoted('DATADIR', datadir)
conf.set_quoted('LIBEXECDIR', libexecdir)
conf.set_quoted('LOCALSTATEDIR', localstatedir)

conf.set_quoted('GETTEXT_PACKAGE', meson.project_name())
conf.set_quoted('PACKAGE_NAME', meson.project_name())
conf.set_quoted('VERSION', meson.project_version())
conf.set_quoted('LOCALEDIR', get_option('localedir'))

configure_file(
  output : 'config.h',
  configuration : conf
)

root_incdir = include_directories('.')

subdir('libcolord-gtk')
subdir('po')

if get_option('gtk3')
  subdir('client')
endif
if get_option('docs')
  subdir('doc')
endif
if get_option('man')
  subdir('man')
endif
07070100000027000081A400000000000000000000000161CC381A000002BD000000000000000000000000000000000000002500000000colord-gtk-0.2.0+8/meson_options.txtoption('gtk4', type : 'boolean', value : true, description : 'Build Gtk4 library')
option('gtk3', type : 'boolean', value : true, description : 'Build Gtk3 library')
option('gtk2', type : 'boolean', value : false, description : 'Build Gtk2 library')
option('introspection', type : 'boolean', value : true, description : 'Build gobject-introspection typelib files')
option('vapi', type : 'boolean', value : false, description : 'Build vala bindings')
option('tests', type : 'boolean', value : true, description : 'Build self tests')
option('man', type : 'boolean', value : true, description : 'Generate man pages')
option('docs', type : 'boolean', value : true, description : 'Generate documentation')
07070100000028000041ED00000000000000000000000261CC381A00000000000000000000000000000000000000000000001600000000colord-gtk-0.2.0+8/po07070100000029000081A400000000000000000000000161CC381A00000059000000000000000000000000000000000000002100000000colord-gtk-0.2.0+8/po/.gitignore*.gmo
*.header
Makefile.in.in
Makevars.template
POTFILES
Rules-quot
*.sed
*.sin
stamp-it
0707010000002A000081A400000000000000000000000161CC381A00000006000000000000000000000000000000000000001E00000000colord-gtk-0.2.0+8/po/LINGUASen_GB
0707010000002B000081A400000000000000000000000161CC381A00000014000000000000000000000000000000000000002200000000colord-gtk-0.2.0+8/po/POTFILES.inclient/cd-convert.c
0707010000002C000081A400000000000000000000000161CC381A00000341000000000000000000000000000000000000001F00000000colord-gtk-0.2.0+8/po/en_GB.po# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# 
# Translators:
# Richard Hughes <richard@hughsie.com>, 2012.
msgid ""
msgstr ""
"Project-Id-Version: colord\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-05-09 22:55+0100\n"
"PO-Revision-Date: 2012-05-09 21:57+0000\n"
"Last-Translator: Richard Hughes <richard@hughsie.com>\n"
"Language-Team: English (United Kingdom) (http://www.transifex.net/projects/p/freedesktop/language/en_GB/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: en_GB\n"
"Plural-Forms: nplurals=2; plural=(n != 1)\n"

#. TRANSLATORS: command line option
#: ../client/cd-convert.c:273
msgid "Use this device for profiling"
msgstr ""
0707010000002D000081A400000000000000000000000161CC381A00000077000000000000000000000000000000000000002200000000colord-gtk-0.2.0+8/po/meson.buildi18n.gettext(meson.project_name(),
  preset : 'glib',
  args: [
    '--default-domain=' + meson.project_name(),
  ],
)
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!216 blocks

Places

File colord-gtk-0.2.0+8.obscpio of Package colord-gtk (Revision 2c84c75a77baa41e2560bd4bb4dba752)

Places