static GwyContainer*
apefile_get_metadata(APEFile *apefile)
{
GwyContainer *meta;
gchar *p;
meta = gwy_container_new();
HASH_STORE("Version", "%u", version);
HASH_STORE("Tip oscilation frequency", "%g Hz", freq_osc_tip);
HASH_STORE("Acquire delay", "%.6f s", acquire_delay);
HASH_STORE("Raster delay", "%.6f s", raster_delay);
HASH_STORE("Tip distance", "%g nm", tip_dist);
if (apefile->remark && *apefile->remark
&& (p = g_convert(apefile->remark, strlen(apefile->remark),
"UTF-8", "ISO-8859-1", NULL, NULL, NULL)))
gwy_container_set_string_by_name(meta, "Comment", p);
gwy_container_set_string_by_name
(meta, "SPM mode",
g_strdup(gwy_enum_to_string(apefile->spm_mode, spm_modes,
G_N_ELEMENTS(spm_modes))));
p = format_vt_date(apefile->scan_date);
if (p)
gwy_container_set_string_by_name(meta, "Date", p);
return meta;
}
static gboolean
gwyfile_save(GwyContainer *data,
const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GByteArray *buffer;
gchar *filename_orig_utf8, *filename_utf8;
FILE *fh;
gboolean restore_filename, ok = TRUE;
if (!(fh = g_fopen(filename, "wb"))) {
err_OPEN_WRITE(error);
return FALSE;
}
/* Assure the saved file contains its own name under "/filename" */
restore_filename = TRUE;
filename_orig_utf8 = NULL;
gwy_container_gis_string_by_name(data, "/filename",
(const guchar**)&filename_orig_utf8);
filename_orig_utf8 = g_strdup(filename_orig_utf8);
filename_utf8 = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
if (!filename_utf8)
gwy_container_remove_by_name(data, "/filename");
else if (filename_orig_utf8
&& gwy_strequal(filename_orig_utf8, filename_utf8)) {
restore_filename = FALSE;
}
else {
gwy_container_set_string_by_name(data, "/filename", filename_utf8);
filename_utf8 = NULL;
}
/* Serialize */
buffer = gwy_serializable_serialize(G_OBJECT(data), NULL);
if (fwrite(MAGIC2, 1, MAGIC_SIZE, fh) != MAGIC_SIZE
|| fwrite(buffer->data, 1, buffer->len, fh) != buffer->len) {
err_WRITE(error);
ok = FALSE;
g_unlink(filename);
}
fclose(fh);
g_byte_array_free(buffer, TRUE);
/* Restore filename if save failed */
if (!ok && restore_filename) {
if (filename_orig_utf8)
gwy_container_set_string_by_name(data, "/filename",
filename_orig_utf8);
else
gwy_container_remove_by_name(data, "/filename");
filename_orig_utf8 = NULL;
}
g_free(filename_orig_utf8);
g_free(filename_utf8);
return ok;
}
static void
grain_cross_save_args(GwyContainer *container,
GrainCrossArgs *args)
{
target_id = args->target_graph;
gwy_container_set_string_by_name(container, abscissa_key,
g_strdup(args->abscissa));
gwy_container_set_boolean_by_name(container, abscissa_expanded_key,
args->abscissa_expanded);
gwy_container_set_string_by_name(container, ordinate_key,
g_strdup(args->ordinate));
gwy_container_set_boolean_by_name(container, ordinate_expanded_key,
args->ordinate_expanded);
}
static void
gfilter_save_args(GwyContainer *container,
GFilterArgs *args)
{
gchar *filename;
FILE *fh;
guint i;
gwy_container_set_boolean_by_name(container, update_key, args->update);
gwy_container_set_int32_by_name(container, expanded_key, args->expanded);
gwy_container_set_enum_by_name(container, logical_key, args->logical);
for (i = 0; i < NQUANTITIES; i++) {
gchar buf[sizeof(quantity_key) + 10];
g_snprintf(buf, sizeof(buf), "%s%u", quantity_key, i+1);
gwy_container_set_string_by_name(container, buf,
g_strdup(args->ranges[i].quantity));
}
filename = g_build_filename(gwy_get_user_dir(), "grain_filter", NULL);
if (!g_file_test(filename, G_FILE_TEST_IS_DIR))
g_mkdir(filename, 0700);
g_free(filename);
filename = g_build_filename(gwy_get_user_dir(), "grain_filter", "ranges",
NULL);
if ((fh = g_fopen(filename, "w"))) {
g_hash_table_foreach(args->ranges_history, save_range, fh);
fclose(fh);
}
g_free(filename);
}
static void
store_meta(gpointer key,
gpointer value,
gpointer user_data)
{
GwyContainer *meta = (GwyContainer*)user_data;
if (g_utf8_validate(value, -1, NULL)) {
gwy_container_set_string_by_name(meta, key, g_strdup(value));
}
else {
gchar *s = g_convert(value, -1, "UTF-8", "CP1252", NULL, NULL, NULL);
if (s)
gwy_container_set_string_by_name(meta, key, s);
}
}
static void
add_metadata(gpointer hkey,
gpointer hvalue,
gpointer user_data)
{
gchar *key = (gchar*)hkey;
NanoscopeValue *val = (NanoscopeValue*)hvalue;
gchar *v, *w;
if (gwy_strequal(key, "#self")
|| !val->hard_value_str
|| !val->hard_value_str[0])
return;
if (key[0] == '@')
key++;
v = g_strdup(val->hard_value_str);
if (strchr(v, '\272')) {
w = gwy_strreplace(v, "\272", "deg", -1);
g_free(v);
v = w;
}
if (strchr(v, '~')) {
w = gwy_strreplace(v, "~", "µ", -1);
g_free(v);
v = w;
}
gwy_container_set_string_by_name(GWY_CONTAINER(user_data), key, v);
}
/**
* gwy_layer_basic_set_gradient:
* @layer: A basic data view layer.
* @gradient: Name of gradient @layer should use. It should exist.
*
* Sets the color gradient a basic layer should use.
*
* Since: 1.8
**/
void
gwy_layer_basic_set_gradient(GwyLayerBasic *layer,
const gchar *gradient)
{
GwyGradient *grad, *old;
gchar *gradstr;
g_return_if_fail(GWY_IS_LAYER_BASIC(layer));
gwy_debug("%s", gradient);
grad = gwy_gradients_get_gradient(gradient);
if (!grad || grad == layer->gradient)
return;
/* the string we've got as argument can be owned by somethin we are
* going to destroy */
gradstr = g_strdup(gradient);
old = layer->gradient;
g_signal_handlers_disconnect_matched(layer->gradient, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, layer);
g_object_ref(grad);
layer->gradient = grad;
g_signal_connect_swapped(layer->gradient, "value_changed",
G_CALLBACK(gwy_layer_basic_update), layer);
gwy_container_set_string_by_name(GWY_DATA_VIEW_LAYER(layer)->data,
"/0/base/palette", gradstr);
g_object_unref(old);
/* XXX: remove */
if (!gwy_palette_set_by_name(layer->palette, gradstr))
g_warning("Palette <%s> doesn't exist, we've got out of sync",
gradstr);
gwy_layer_basic_update(GWY_DATA_VIEW_LAYER(layer));
}
static GwyContainer*
spmlab_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
const gchar *title;
gint type;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
/* 2048 is wrong. moreover it differs for r5 and r4, kasigra uses 5752 for
* r5 */
if (size < 2048) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (buffer[0] != '#' || buffer[1] != 'R') {
err_FILE_TYPE(error, "Thermicroscopes SpmLab");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
switch (buffer[2]) {
case '3':
case '4':
case '5':
case '6':
dfield = read_data_field(buffer, size, buffer[2], &type, error);
break;
default:
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Unknown format version %c."), buffer[2]);
break;
}
gwy_file_abandon_contents(buffer, size, NULL);
if (!dfield)
return NULL;
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
title = gwy_enum_to_string(type,
spmlab_channel_types,
G_N_ELEMENTS(spmlab_channel_types));
if (*title)
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup(title));
return container;
}
static void
add_meta_record(gpointer hkey, gpointer hvalue, gpointer user_data)
{
const gchar *key = (const gchar*)hkey;
const gchar *value = (const gchar*)hvalue;
GwyContainer *meta = (GwyContainer*)user_data;
if (!gwy_stramong(key,
"/ISO5436_2/Record1/Revision",
"/ISO5436_2/Record1/FeatureType",
"/ISO5436_2/Record2/Date",
"/ISO5436_2/Record2/Creator",
"/ISO5436_2/Record2/Instrument/Manufacturer",
"/ISO5436_2/Record2/Instrument/Model",
"/ISO5436_2/Record2/Instrument/Serial",
"/ISO5436_2/Record2/Instrument/Version",
"/ISO5436_2/Record2/CalibrationDate",
"/ISO5436_2/Record2/ProbingSystem/Type",
"/ISO5436_2/Record2/ProbingSystem/Identification",
"/ISO5436_2/Record2/Comment",
NULL)
&& !g_str_has_prefix(key,
"/ISO5436_2/Record2/ProbingSystem/Identification/")
&& !g_str_has_prefix(key,
"/ISO5436_2/Record1/Axes/Rotation"))
return;
key = strrchr(key, '/');
g_return_if_fail(key);
key++;
gwy_container_set_string_by_name(meta, key, (const guchar*)g_strdup(value));
}
static void
gather_channel_meta(gpointer hkey,
gpointer hvalue,
gpointer user_data)
{
const gchar *key = (const gchar*)hkey;
const gchar *value = (const gchar*)hvalue;
IgorFile *igorfile = (IgorFile*)user_data;
guint i;
if (!*value)
return;
for (i = 0; i < igorfile->nchannels; i++) {
if (igorfile->channel_info[i].name
&& g_str_has_prefix(key, igorfile->channel_info[i].name))
return;
}
for (i = 0; igorfile->ignore_prefixes[i]; i++) {
if (g_str_has_prefix(key, igorfile->ignore_prefixes[i]))
return;
}
if (g_utf8_validate(value, -1, NULL))
value = g_strdup(value);
else
value = g_convert(value, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
if (value)
gwy_container_set_string_by_name(igorfile->channelmeta, key, value);
}
static void
oldmda_read_data(OldMDAFile *mdafile, const gchar *buffer)
{
GwyBrick *brick;
GwyDataField *dfield;
GwyDataLine *cal;
gdouble *data;
gint i, j, k;
const guchar *p;
p = buffer;
brick = gwy_brick_new(mdafile->xres, mdafile->yres, mdafile->zres,
mdafile->xreal, mdafile->yreal, mdafile->zres,
TRUE);
data = gwy_brick_get_data(brick);
for (k = 0; k < mdafile->zres; k++) {
p = buffer + k * 4;
for (i = 0; i < mdafile->yres; i++)
for (j = 0; j < mdafile->xres; j++) {
*(data + k * mdafile->xres * mdafile->yres + j
+ (mdafile->yres - i - 1) * mdafile->xres)
= (gdouble)gwy_get_gint32_le(&p);
p += (mdafile->zres - 1) * 4;
}
}
gwy_brick_set_si_unit_x(brick, mdafile->siunitx);
gwy_brick_set_si_unit_y(brick, mdafile->siunity);
gwy_brick_set_si_unit_z(brick, mdafile->siunitz);
cal = gwy_data_line_new(mdafile->zres, mdafile->zres, FALSE);
data = gwy_data_line_get_data(cal);
for (k = 0; k < mdafile->zres; k++) {
*(data++) = g_array_index(mdafile->xdata, gdouble, k);
}
gwy_data_line_set_si_unit_y(cal, mdafile->siunitz);
gwy_brick_set_zcalibration(brick, cal);
g_object_unref(cal);
g_object_unref(mdafile->siunitx);
g_object_unref(mdafile->siunity);
g_object_unref(mdafile->siunitz);
dfield = gwy_data_field_new(mdafile->xres, mdafile->yres,
mdafile->xreal, mdafile->yreal,
TRUE);
gwy_container_set_object_by_name(mdafile->data, "/brick/0", brick);
gwy_container_set_string_by_name(mdafile->data, "/brick/0/title",
g_strdup("MDA data"));
gwy_brick_mean_plane(brick, dfield, 0, 0, 0,
mdafile->xres, mdafile->yres, -1, FALSE);
gwy_container_set_object_by_name(mdafile->data, "/brick/0/preview",
dfield);
g_object_unref(dfield);
g_object_unref(brick);
gwy_file_volume_import_log_add(mdafile->data, 0, NULL, mdafile->filename);
}
static void
store_meta(gpointer key,
gpointer value,
gpointer user_data)
{
GwyContainer *meta = (GwyContainer*)user_data;
if (g_utf8_validate(value, -1, NULL)) {
gwy_container_set_string_by_name(meta, key, g_strdup(value));
}
else {
// FIXME: Is this Windows-locale dependent?
gchar *s = g_convert(value, -1, "UTF-8", "GB2312", NULL, NULL, NULL);
if (s)
gwy_container_set_string_by_name(meta, key, s);
}
}
static void
tiff_load_meta_string(TIFF *tiff,
GwyContainer *container, ttag_t tag, const gchar *name)
{
const gchar *string;
if (tiff_get_custom_string(tiff, tag, &string))
gwy_container_set_string_by_name(container, name, g_strdup(string));
}
static void
add_meta(gpointer key, gpointer value, gpointer user_data)
{
const gchar *strkey = (const gchar*)key;
const gchar *strvalue = (const gchar*)value;
GwyContainer *meta = (GwyContainer*)user_data;
gwy_container_set_string_by_name(meta, strkey, g_strdup(strvalue));
}
/*Sets the field into the metadata container*/
static gboolean apedax_set_meta_field (GwyContainer *meta,
xmlDocPtr doc,
APEXmlField data)
{
gboolean outcome = FALSE;
gchar* buffer = NULL;
buffer = apedax_get_xml_field_as_string(doc, data.xpath);
if (buffer) {
switch (data.type) {
case FIELD_TYPE_STRING:
gwy_container_set_string_by_name(meta,
data.name,
g_strdup(buffer));
break;
case FIELD_TYPE_DATE:
{
gchar *datestring = apedax_format_date(buffer);
if (datestring != NULL) {
gwy_container_set_string_by_name(meta,
"Date",
g_strdup(datestring));
g_free(datestring);
}
else {
g_free(buffer);
return FALSE;
}
}
break;
default:
break;
}
g_free(buffer);
outcome = TRUE;
}
return outcome;
}
static void
fix_scales(EZDSection *section,
gint idx,
GwyContainer *container)
{
GwyDataField *dfield;
GwySIUnit *siunit;
gchar key[40];
gint power10;
gdouble r;
g_snprintf(key, sizeof(key), "/%d/data", idx);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(container, key));
/* Fix value scale */
siunit = gwy_si_unit_new_parse(section->zrange.unit, &power10);
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
r = pow10(power10);
gwy_data_field_multiply(dfield, r*section->zrange.range);
gwy_data_field_add(dfield, r*section->zrange.min);
/* Fix lateral scale */
siunit = gwy_si_unit_new_parse(section->xrange.unit, &power10);
gwy_data_field_set_si_unit_xy(dfield, siunit);
g_object_unref(siunit);
gwy_data_field_set_xreal(dfield, pow10(power10)*section->xrange.range);
siunit = gwy_si_unit_new_parse(section->yrange.unit, &power10);
gwy_data_field_set_yreal(dfield, pow10(power10)*section->yrange.range);
g_object_unref(siunit);
/* Some metadata */
if (section->zrange.name) {
const gchar *s;
switch (section->direction) {
case SCAN_FORWARD:
s = " forward";
break;
case SCAN_BACKWARD:
s = " backward";
break;
default:
s = "";
break;
}
g_snprintf(key, sizeof(key), "/%d/data/title", idx);
gwy_container_set_string_by_name(container, key,
g_strdup_printf("%s%s",
section->zrange.name,
s));
}
}
static void
add_meta(gpointer hkey, gpointer hvalue, gpointer user_data)
{
gchar *value = g_convert((const gchar*)hvalue, -1,
"UTF-8", "ISO-8859-1",
NULL, NULL, NULL);
if (value)
gwy_container_set_string_by_name(GWY_CONTAINER(user_data),
(gchar*)hkey, value);
}
static GwyContainer*
hitachi_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error,
const gchar *name)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
GwyDataField *(*do_load)(const guchar*, guint, GError**);
guint header_size;
if (gwy_strequal(name, "hitachi-afm")) {
do_load = &read_data_field;
header_size = HEADER_SIZE;
}
else if (gwy_strequal(name, "hitachi-afm-old")) {
do_load = &read_data_field_old;
header_size = HEADER_SIZE_OLD;
}
else {
g_set_error(error, GWY_MODULE_FILE_ERROR,
GWY_MODULE_FILE_ERROR_UNIMPLEMENTED,
_("Hitachi-AFM has not registered file type `%s'."), name);
return NULL;
}
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < header_size + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = do_load(buffer, size, error);
gwy_file_abandon_contents(buffer, size, NULL);
if (!dfield)
return NULL;
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
gwy_app_channel_check_nonsquare(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
static void
add_metadata(gpointer hkey,
gpointer hvalue,
gpointer user_data)
{
const gchar *key = (const gchar*)hkey, *value = (const gchar*)hvalue;
GwyContainer *meta = (GwyContainer*)user_data;
if (g_utf8_validate(key, -1, NULL) && g_utf8_validate(value, -1, NULL))
gwy_container_set_string_by_name(meta, key, g_strdup(value));
}
static void
add_meta(gpointer hkey, gpointer hvalue, gpointer user_data)
{
if (gwy_stramong((gchar*)hkey,
"XRes", "YRes", "XReal", "YReal", "XOffset", "YOffset",
"XYUnits", "ZUnits", "Title",
NULL))
return;
gwy_container_set_string_by_name(GWY_CONTAINER(user_data),
(gchar*)hkey, g_strdup((gchar*)hvalue));
}
static void
store_meta_string(GwyContainer *container,
const gchar *key,
gchar *field)
{
gchar *p;
g_strstrip(field);
if (field[0]
&& (p = g_locale_to_utf8(field, strlen(field), NULL, NULL, NULL)))
gwy_container_set_string_by_name(container, key, p);
}
static void
store_metadata(SurfFile *surffile,
GwyContainer *container)
{
char date[20];
g_snprintf(date, sizeof(date), "%d. %d. %d", surffile->day, surffile->month, surffile->year);
HASH_STORE("Version", "%u", version);
HASH_STORE("Operator name", "%s", operator_name);
HASH_STORE("Object name", "%s", object_name);
gwy_container_set_string_by_name(container, "/meta/Date", g_strdup(date));
gwy_container_set_string_by_name
(container, "/meta/Acquisition type",
g_strdup(gwy_enum_to_string(surffile->acquisition, acq_modes,
G_N_ELEMENTS(acq_modes))));
}
static void
rhk_sm4_meta_string(const RHKPage *page,
RHKStringType stringid,
const gchar *name,
GwyContainer *meta)
{
const gchar *s;
g_return_if_fail(stringid < RHK_STRING_NSTRINGS);
if ((s = page->strings[stringid]))
gwy_container_set_string_by_name(meta, name, g_strdup(s));
}
static GwyContainer*
surffile_get_metadata(SurfFile *surffile)
{
GwyContainer *meta;
char date[40];
meta = gwy_container_new();
g_snprintf(date, sizeof(date), "%d. %d. %d",
surffile->day, surffile->month, surffile->year);
HASH_STORE("Version", "%u", version);
HASH_STORE("Operator name", "%s", operator_name);
HASH_STORE("Object name", "%s", object_name);
gwy_container_set_string_by_name(meta, "Date", g_strdup(date));
gwy_container_set_string_by_name
(meta, "Acquisition type",
g_strdup(gwy_enum_to_string(surffile->acquisition, acq_modes,
G_N_ELEMENTS(acq_modes))));
return meta;
}
static void
store_meta(gpointer key,
gpointer value,
gpointer user_data)
{
GwyContainer *meta = (GwyContainer*)user_data;
gchar *cval;
if (!(cval = g_convert(value, strlen(value), "UTF-8", "ISO-8859-1",
NULL, NULL, NULL)))
return;
gwy_container_set_string_by_name(meta, key, cval);
}
static GwyContainer*
unisoku_get_metadata(UnisokuFile *ufile)
{
GwyContainer *meta;
meta = gwy_container_new();
gwy_container_set_string_by_name(meta, "Date",
g_strconcat(ufile->date, " ",
ufile->time, NULL));
if (*ufile->remark)
gwy_container_set_string_by_name(meta, "Remark",
g_strdup(ufile->remark));
if (*ufile->sample_name)
gwy_container_set_string_by_name(meta, "Sample name",
g_strdup(ufile->sample_name));
if (*ufile->ad_name)
gwy_container_set_string_by_name(meta, "AD name",
g_strdup(ufile->ad_name));
return meta;
}
static void
format_meta(GwyContainer *meta,
const gchar *name,
const gchar *format,
...)
{
gchar *s;
va_list ap;
va_start(ap, format);
s = g_strdup_vprintf(format, ap);
va_end(ap);
gwy_container_set_string_by_name(meta, name, s);
}
static GwyContainer*
pt3file_get_metadata(PicoHarpFile *pt3file)
{
GwyContainer *meta;
meta = gwy_container_new();
add_meta_str("Format Version", format_version);
add_meta_str("Creator Name", creator_name);
add_meta_str("Creator Version", creator_version);
add_meta_str("Date", file_time);
add_meta_str("Comment", comment);
add_meta_str("Hardware", board.hardware_ident);
add_meta_str("Hardware Version", board.hardware_version);
gwy_container_set_string_by_name
(meta, "Measurement Mode",
g_strdup_printf("%u", pt3file->measurement_mode));
gwy_container_set_string_by_name
(meta, "Offset", g_strdup_printf("%d ns", pt3file->offset));
gwy_container_set_string_by_name
(meta, "Acquisition Time",
g_strdup_printf("%d ms", pt3file->acquisition_time));
gwy_container_set_string_by_name
(meta, "Hardware Serial Number",
g_strdup_printf("%u", pt3file->board.hardware_serial));
gwy_container_set_string_by_name
(meta, "Imaging Device",
g_strdup(gwy_enuml_to_string(pt3file->imaging.common.instrument,
"PI E710", 1,
"KDT180-100-Im", 2,
"LSM", 3,
NULL)));
return meta;
}
static void
format_bit(GwyContainer *meta,
const gchar *name,
guint n,
const GwyFlatEnum *table,
const gchar *names,
guint value)
{
gchar *t;
t = gwy_flat_flags_to_string(value, n, table, names, NULL);
if (t)
gwy_container_set_string_by_name(meta, name, t);
else
g_free(t);
}
static void
gwy_layer_basic_plugged(GwyDataViewLayer *layer)
{
GwyPixmapLayer *pixmap_layer;
GwyLayerBasic *basic_layer;
GwyDataField *data_field = NULL;
gint width, height;
const guchar *gradient_name;
gwy_debug(" ");
g_return_if_fail(GWY_IS_LAYER_BASIC(layer));
pixmap_layer = GWY_PIXMAP_LAYER(layer);
basic_layer = GWY_LAYER_BASIC(layer);
basic_layer->changed = TRUE;
GWY_DATA_VIEW_LAYER_CLASS(parent_class)->plugged(layer);
/* TODO Container */
/* XXX */
data_field = GWY_DATA_FIELD(gwy_container_get_object_by_name(layer->data,
"/0/data"));
gwy_container_gis_object_by_name(layer->data, "/0/show",
(GObject**)&data_field);
g_return_if_fail(data_field);
width = gwy_data_field_get_xres(data_field);
height = gwy_data_field_get_yres(data_field);
if (gwy_container_gis_string_by_name(layer->data, "/0/base/palette",
&gradient_name))
gwy_layer_basic_set_gradient((GwyLayerBasic*)layer, gradient_name);
else {
/* FIXME: this is probably wrong, it should work with unset gradient
* and use default, but things depend on the fact /0/base/palette
* is set. */
gwy_layer_basic_set_gradient((GwyLayerBasic*)layer,
GWY_GRADIENT_DEFAULT);
gwy_container_set_string_by_name(GWY_DATA_VIEW_LAYER(layer)->data,
"/0/base/palette",
g_strdup(GWY_GRADIENT_DEFAULT));
}
pixmap_layer->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE,
BITS_PER_SAMPLE, width, height);
gwy_debug_objects_creation(G_OBJECT(pixmap_layer->pixbuf));
}
