isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-30 20:01:00 -05:00
Code Issues Packages Projects Releases Wiki Activity
cfb8f18cef
mutter/src/tests/clutter/conform/units.c

132 lines
4.8 KiB
C
Raw Normal View History

[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
#include <clutter/clutter.h>
conformance: Add more tests Add back some deprecated and general purpose API tests. These are the ones that were written already pretty much conforming to the GTest API and style, and thus require minimal porting.
2013-12-12 10:05:16 -05:00
static void
units_cache (void)
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
{
ClutterUnits units;
conform: Do not use deprecated API in test-clutter-units Setting the DPI is done through the ClutterSettings:font-dpi property.
2010-06-22 06:59:07 -04:00
ClutterSettings *settings;
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
gfloat pixels;
test-clutter-units: Force a known resolution to avoid fuzzyness Instead of taking the current resolution, whatever it may be, use a known DPI. This should alleviate fuzzyness and create consistent results.
2010-09-24 11:21:06 -04:00
gint old_dpi;
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
conform: Do not use deprecated API in test-clutter-units Setting the DPI is done through the ClutterSettings:font-dpi property.
2010-06-22 06:59:07 -04:00
settings = clutter_settings_get_default ();
test-clutter-units: Force a known resolution to avoid fuzzyness Instead of taking the current resolution, whatever it may be, use a known DPI. This should alleviate fuzzyness and create consistent results.
2010-09-24 11:21:06 -04:00
g_object_get (settings, "font-dpi", &old_dpi, NULL);
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
test-clutter-units: Force a known resolution to avoid fuzzyness Instead of taking the current resolution, whatever it may be, use a known DPI. This should alleviate fuzzyness and create consistent results.
2010-09-24 11:21:06 -04:00
g_object_set (settings, "font-dpi", 96 * 1024, NULL);
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
clutter_units_from_em (&units, 1.0);
pixels = clutter_units_to_pixels (&units);
test-clutter-units: Force a known resolution to avoid fuzzyness Instead of taking the current resolution, whatever it may be, use a known DPI. This should alleviate fuzzyness and create consistent results.
2010-09-24 11:21:06 -04:00
g_object_set (settings, "font-dpi", ((96 * 2) * 1024), NULL);
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
g_assert_cmpfloat (clutter_units_to_pixels (&units), !=, pixels);
test-clutter-units: Force a known resolution to avoid fuzzyness Instead of taking the current resolution, whatever it may be, use a known DPI. This should alleviate fuzzyness and create consistent results.
2010-09-24 11:21:06 -04:00
g_object_set (settings, "font-dpi", (96 * 1024), NULL);
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
g_assert_cmpfloat (clutter_units_to_pixels (&units), ==, pixels);
test-clutter-units: Force a known resolution to avoid fuzzyness Instead of taking the current resolution, whatever it may be, use a known DPI. This should alleviate fuzzyness and create consistent results.
2010-09-24 11:21:06 -04:00
g_object_set (settings, "font-dpi", old_dpi, NULL);
units: Cache the pixels value inside Units When computing the pixels value of a ClutterUnits value we should be caching the value to avoid recomputing for every call of clutter_units_to_pixels(). We already have a flag telling us to return the cached value, but we miss the mechanism to evict the cache whenever the Backend settings affecting the conversion, that is default font and resolution, change. In order to implement the eviction we can use a "serial"; the Backend will have an internal serial field which we retrieve and put inside the ClutterUnits structure (we split one of the two 64 bit padding fields into two 32 bit fields to maintain ABI); every time we call clutter_units_to_pixels() we compare the units serial with that of the Backend; if they match and pixels_set is set to TRUE then we just return the stored pixels value. If the serials do not match then we unset the pixels_set flag and recompute the pixels value. We can verify this by adding a simple test unit checking that by changing the resolution of ClutterBackend we get different pixel values for 1 em. http://bugzilla.openedhand.com/show_bug.cgi?id=1843
2009-10-16 10:25:37 -04:00
}
conformance: Add more tests Add back some deprecated and general purpose API tests. These are the ones that were written already pretty much conforming to the GTest API and style, and thus require minimal porting.
2013-12-12 10:05:16 -05:00
static void
units_constructors (void)
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
{
[units] Add support for centimeters The only tricky part of the patch is to remember that 1cm is 10mm. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 12:47:34 -04:00
ClutterUnits units, units_cm;
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
[units] Add binding-friendly initializers We should follow the convention for boxed types initializers of: <type_name>_from_<another_type> (boxed, value) For ClutterUnits as well; so: clutter_units_pixels -> clutter_units_from_pixels clutter_units_em -> clutter_units_from_em ... We should still keep the short-hand version as a macro, though.
2009-07-28 08:43:52 -04:00
clutter_units_from_pixels (&units, 100);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_PIXEL);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 100.0);
g_assert_cmpfloat (clutter_units_to_pixels (&units), ==, 100.0);
[units] Add binding-friendly initializers We should follow the convention for boxed types initializers of: <type_name>_from_<another_type> (boxed, value) For ClutterUnits as well; so: clutter_units_pixels -> clutter_units_from_pixels clutter_units_em -> clutter_units_from_em ... We should still keep the short-hand version as a macro, though.
2009-07-28 08:43:52 -04:00
clutter_units_from_em (&units, 5.0);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_EM);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 5.0);
g_assert_cmpfloat (clutter_units_to_pixels (&units), !=, 5.0);
[units] Add support for centimeters The only tricky part of the patch is to remember that 1cm is 10mm. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 12:47:34 -04:00
clutter_units_from_cm (&units_cm, 5.0);
g_assert (clutter_units_get_unit_type (&units_cm) == CLUTTER_UNIT_CM);
g_assert_cmpfloat (clutter_units_get_unit_value (&units_cm), ==, 5.0);
g_assert_cmpfloat (clutter_units_to_pixels (&units_cm), !=, 5.0);
clutter_units_from_mm (&units, 50.0);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_MM);
g_assert_cmpfloat (clutter_units_to_pixels (&units),
==,
clutter_units_to_pixels (&units_cm));
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
}
conformance: Add more tests Add back some deprecated and general purpose API tests. These are the ones that were written already pretty much conforming to the GTest API and style, and thus require minimal porting.
2013-12-12 10:05:16 -05:00
static void
units_string (void)
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
{
ClutterUnits units;
gchar *string;
units: Improve coverage of clutter_units_from_string() Add a unit for an empty string as well as units for the missing unit types like cm, mm and px.
2010-01-13 12:31:13 -05:00
g_assert (clutter_units_from_string (&units, "") == FALSE);
Fix string parsing when no unit is given The check should really be on the character pointed by str. Added the corresponding test case.
2009-10-03 09:08:33 -04:00
g_assert (clutter_units_from_string (&units, "10") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_PIXEL);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 10);
units: Improve coverage of clutter_units_from_string() Add a unit for an empty string as well as units for the missing unit types like cm, mm and px.
2010-01-13 12:31:13 -05:00
g_assert (clutter_units_from_string (&units, "10 px") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_PIXEL);
g_assert (clutter_units_from_string (&units, "10 mm") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_MM);
g_assert (clutter_units_from_string (&units, "10 cm") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_CM);
[units] Be more strict in the grammar we are parsing Current parsing of units has a number of shortcomings: * a number followed by trailing space (without any unit specified) was not recognized, * "5 emeralds" was parsed as 5em, * the way we parse the digits after the separator makes us lose precision for no good reason (5.0 is parsed as 5.00010014...f which makes g_assert_cmpfloat() fail) Let's define a stricter grammar we can recognize and try to do so. The description is in EBNF form, removing the optional <> which is a pain when having to write DocBook, and using '' for the terminal symbols. Last step, add more ClutterUnits unit test to get a better coverage of the grammar we want to parse. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 07:02:15 -04:00
g_assert (clutter_units_from_string (&units, "10 ") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_PIXEL);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 10);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
g_assert (clutter_units_from_string (&units, "5 em") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_EM);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 5);
[units] Be more strict in the grammar we are parsing Current parsing of units has a number of shortcomings: * a number followed by trailing space (without any unit specified) was not recognized, * "5 emeralds" was parsed as 5em, * the way we parse the digits after the separator makes us lose precision for no good reason (5.0 is parsed as 5.00010014...f which makes g_assert_cmpfloat() fail) Let's define a stricter grammar we can recognize and try to do so. The description is in EBNF form, removing the optional <> which is a pain when having to write DocBook, and using '' for the terminal symbols. Last step, add more ClutterUnits unit test to get a better coverage of the grammar we want to parse. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 07:02:15 -04:00
g_assert (clutter_units_from_string (&units, "5 emeralds") == FALSE);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
g_assert (clutter_units_from_string (&units, " 16 mm") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_MM);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 16);
[units] Be more strict in the grammar we are parsing Current parsing of units has a number of shortcomings: * a number followed by trailing space (without any unit specified) was not recognized, * "5 emeralds" was parsed as 5em, * the way we parse the digits after the separator makes us lose precision for no good reason (5.0 is parsed as 5.00010014...f which makes g_assert_cmpfloat() fail) Let's define a stricter grammar we can recognize and try to do so. The description is in EBNF form, removing the optional <> which is a pain when having to write DocBook, and using '' for the terminal symbols. Last step, add more ClutterUnits unit test to get a better coverage of the grammar we want to parse. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 07:02:15 -04:00
g_assert (clutter_units_from_string (&units, " 24 pt ") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_POINT);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 24);
g_assert (clutter_units_from_string (&units, " 32 em garbage") == FALSE);
[units] Add support for centimeters The only tricky part of the patch is to remember that 1cm is 10mm. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 12:47:34 -04:00
g_assert (clutter_units_from_string (&units, "5.1cm") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_CM);
[units] Be more strict in the grammar we are parsing Current parsing of units has a number of shortcomings: * a number followed by trailing space (without any unit specified) was not recognized, * "5 emeralds" was parsed as 5em, * the way we parse the digits after the separator makes us lose precision for no good reason (5.0 is parsed as 5.00010014...f which makes g_assert_cmpfloat() fail) Let's define a stricter grammar we can recognize and try to do so. The description is in EBNF form, removing the optional <> which is a pain when having to write DocBook, and using '' for the terminal symbols. Last step, add more ClutterUnits unit test to get a better coverage of the grammar we want to parse. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-06 07:02:15 -04:00
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 5.1f);
g_assert (clutter_units_from_string (&units, "5,mm") == FALSE);
g_assert (clutter_units_from_string (&units, ".5pt") == TRUE);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_POINT);
g_assert_cmpfloat (clutter_units_get_unit_value (&units), ==, 0.5f);
[units] Ensure we don't have ponies The documentation states we should not parse ponies. Even with those with exclamation marks. Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-10-07 12:09:41 -04:00
g_assert (clutter_units_from_string (&units, "1 omg!!pony") == FALSE);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
[units] Add binding-friendly initializers We should follow the convention for boxed types initializers of: <type_name>_from_<another_type> (boxed, value) For ClutterUnits as well; so: clutter_units_pixels -> clutter_units_from_pixels clutter_units_em -> clutter_units_from_em ... We should still keep the short-hand version as a macro, though.
2009-07-28 08:43:52 -04:00
clutter_units_from_pt (&units, 24.0);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
string = clutter_units_to_string (&units);
g_assert_cmpstr (string, ==, "24.0 pt");
g_free (string);
[units] Add binding-friendly initializers We should follow the convention for boxed types initializers of: <type_name>_from_<another_type> (boxed, value) For ClutterUnits as well; so: clutter_units_pixels -> clutter_units_from_pixels clutter_units_em -> clutter_units_from_em ... We should still keep the short-hand version as a macro, though.
2009-07-28 08:43:52 -04:00
clutter_units_from_em (&units, 3.0);
[units] Rework Units into logical distance value Units as they have been implemented since Clutter 0.4 have always been misdefined as "logical distance unit", while they were just pixels with fractionary bits. Units should be reworked to be opaque structures to hold a value and its unit type, that can be then converted into pixels when Clutter needs to paint or compute size requisitions and perform allocations. The previous API should be completely removed to avoid collisions, and a new type: ClutterUnits should be added; the ability to install GObject properties using ClutterUnits should be maintained.
2009-06-03 06:12:09 -04:00
string = clutter_units_to_string (&units);
g_assert_cmpstr (string, ==, "3.00 em");
units.unit_type = CLUTTER_UNIT_PIXEL;
units.value = 0;
g_assert (clutter_units_from_string (&units, string) == TRUE);
g_assert (clutter_units_get_unit_type (&units) != CLUTTER_UNIT_PIXEL);
g_assert (clutter_units_get_unit_type (&units) == CLUTTER_UNIT_EM);
g_assert_cmpint ((int) clutter_units_get_unit_value (&units), ==, 3);
g_free (string);
}
conformance: Add more tests Add back some deprecated and general purpose API tests. These are the ones that were written already pretty much conforming to the GTest API and style, and thus require minimal porting.
2013-12-12 10:05:16 -05:00
CLUTTER_TEST_SUITE (
CLUTTER_TEST_UNIT ("/units/string", units_string)
CLUTTER_TEST_UNIT ("/units/cache", units_cache)
CLUTTER_TEST_UNIT ("/units/constructors", units_constructors)
)
Reference in New Issue Copy Permalink