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
create_images(const X3PFile *x3pfile, GwyContainer *container)
{
gint id;
for (id = 0; id < x3pfile->zres; id++) {
GwyContainer *meta;
guint n = x3pfile->xres*x3pfile->yres, k;
GwyDataField *dfield, *mask;
const gboolean *valid = x3pfile->valid + id*n;
GQuark quark;
gchar buf[40];
dfield = gwy_data_field_new(x3pfile->xres,
x3pfile->yres,
x3pfile->xres*x3pfile->dx,
x3pfile->yres*x3pfile->dy,
FALSE);
memcpy(dfield->data, x3pfile->values + id*n, n*sizeof(gdouble));
for (k = 0; k < n; k++) {
if (!valid[k])
dfield->data[k] = NAN;
}
quark = gwy_app_get_data_key_for_id(id);
gwy_container_set_object(container, quark, dfield);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
gwy_app_channel_title_fall_back(container, id);
gwy_app_channel_check_nonsquare(container, id);
if ((mask = gwy_app_channel_mask_of_nans(dfield, TRUE))) {
quark = gwy_app_get_mask_key_for_id(id);
gwy_container_set_object(container, quark, mask);
g_object_unref(mask);
}
g_object_unref(dfield);
if ((meta = get_meta(x3pfile))) {
g_snprintf(buf, sizeof(buf), "/%u/meta", id);
gwy_container_set_object_by_name(container, buf, meta);
g_object_unref(meta);
}
}
}
static GwyContainer*
surffile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
SurfFile surffile;
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize expected_size, size = 0;
GError *err = NULL;
gchar signature[12];
gdouble max, min;
gint add = 0;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
g_clear_error(&err);
return NULL;
}
if (size < SURF_HEADER_SIZE + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
p = buffer;
get_CHARARRAY(signature, &p);
if (strncmp(signature, "DIGITAL SURF", 12) != 0) {
err_FILE_TYPE(error, "Surf");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
surffile.format = gwy_get_guint16_le(&p);
surffile.nobjects = gwy_get_guint16_le(&p);
surffile.version = gwy_get_guint16_le(&p);
surffile.type = gwy_get_guint16_le(&p);
get_CHARS0(surffile.object_name, &p, 30);
get_CHARS0(surffile.operator_name, &p, 30);
surffile.material_code = gwy_get_guint16_le(&p);
surffile.acquisition = gwy_get_guint16_le(&p);
surffile.range = gwy_get_guint16_le(&p);
surffile.special_points = gwy_get_guint16_le(&p);
surffile.absolute = gwy_get_guint16_le(&p);
/*reserved*/
p += 8;
surffile.pointsize = gwy_get_guint16_le(&p);
surffile.zmin = gwy_get_gint32_le(&p);
surffile.zmax = gwy_get_gint32_le(&p);
surffile.xres = gwy_get_gint32_le(&p);
surffile.yres = gwy_get_gint32_le(&p);
surffile.nofpoints = gwy_get_guint32_le(&p);
surffile.dx = gwy_get_gfloat_le(&p);
surffile.dy = gwy_get_gfloat_le(&p);
surffile.dz = gwy_get_gfloat_le(&p);
get_CHARS0(surffile.xaxis, &p, 16);
get_CHARS0(surffile.yaxis, &p, 16);
get_CHARS0(surffile.zaxis, &p, 16);
get_CHARS0(surffile.dx_unit, &p, 16);
get_CHARS0(surffile.dy_unit, &p, 16);
get_CHARS0(surffile.dz_unit, &p, 16);
get_CHARS0(surffile.xlength_unit, &p, 16);
get_CHARS0(surffile.ylength_unit, &p, 16);
get_CHARS0(surffile.zlength_unit, &p, 16);
surffile.xunit_ratio = gwy_get_gfloat_le(&p);
surffile.yunit_ratio = gwy_get_gfloat_le(&p);
surffile.zunit_ratio = gwy_get_gfloat_le(&p);
surffile.imprint = gwy_get_guint16_le(&p);
surffile.inversion = gwy_get_guint16_le(&p);
surffile.leveling = gwy_get_guint16_le(&p);
p += 12;
surffile.seconds = gwy_get_guint16_le(&p);
surffile.minutes = gwy_get_guint16_le(&p);
surffile.hours = gwy_get_guint16_le(&p);
surffile.day = gwy_get_guint16_le(&p);
surffile.month = gwy_get_guint16_le(&p);
surffile.year = gwy_get_guint16_le(&p);
surffile.measurement_duration = gwy_get_guint16_le(&p);
surffile.comment_size = gwy_get_guint16_le(&p);
surffile.private_size = gwy_get_guint16_le(&p);
get_CHARARRAY(surffile.client_zone, &p);
surffile.XOffset = gwy_get_gfloat_le(&p);
surffile.YOffset = gwy_get_gfloat_le(&p);
surffile.ZOffset = gwy_get_gfloat_le(&p);
gwy_debug("fileformat: %d, n_of_objects: %d, "
"version: %d, object_type: %d",
surffile.format, surffile.nobjects,
surffile.version, surffile.type);
gwy_debug("object name: <%s>", surffile.object_name);
gwy_debug("operator name: <%s>", surffile.operator_name);
gwy_debug("material code: %d, acquisition type: %d",
surffile.material_code, surffile.acquisition);
gwy_debug("range type: %d, special points: %d, absolute: %d",
surffile.range,
surffile.special_points, (gint)surffile.absolute);
gwy_debug("data point size: %d", surffile.pointsize);
gwy_debug("zmin: %d, zmax: %d", surffile.zmin, surffile.zmax);
gwy_debug("xres: %d, yres: %d (xres*yres = %d)",
surffile.xres, surffile.yres, (surffile.xres*surffile.yres));
gwy_debug("total number of points: %d", surffile.nofpoints);
gwy_debug("dx: %g, dy: %g, dz: %g",
surffile.dx, surffile.dy, surffile.dz);
gwy_debug("X axis name: %16s", surffile.xaxis);
gwy_debug("Y axis name: %16s", surffile.yaxis);
gwy_debug("Z axis name: %16s", surffile.zaxis);
gwy_debug("dx unit: %16s", surffile.dx_unit);
gwy_debug("dy unit: %16s", surffile.dy_unit);
gwy_debug("dz unit: %16s", surffile.dz_unit);
gwy_debug("X axis unit: %16s", surffile.xlength_unit);
gwy_debug("Y axis unit: %16s", surffile.ylength_unit);
gwy_debug("Z axis unit: %16s", surffile.zlength_unit);
gwy_debug("xunit_ratio: %g, yunit_ratio: %g, zunit_ratio: %g",
surffile.xunit_ratio, surffile.yunit_ratio, surffile.zunit_ratio);
gwy_debug("imprint: %d, inversion: %d, leveling: %d",
surffile.imprint, surffile.inversion, surffile.leveling);
gwy_debug("Time: %d:%d:%d, Date: %d.%d.%d",
surffile.hours, surffile.minutes, surffile.seconds,
surffile.day, surffile.month, surffile.year);
gwy_debug("private zone size: %d, comment size %d",
surffile.private_size, surffile.comment_size);
expected_size = (SURF_HEADER_SIZE
+ surffile.pointsize/8*surffile.xres*surffile.yres);
if (expected_size != size) {
gwy_debug("Size mismatch!");
if (size > expected_size) add = size - expected_size; /*TODO correct this !*/
else {
err_SIZE_MISMATCH(error, expected_size, size);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
p = buffer + SURF_HEADER_SIZE + add;
if (!fill_data_fields(&surffile, p, error)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (!surffile.absolute) {
max = gwy_data_field_get_max(surffile.dfield);
min = gwy_data_field_get_min(surffile.dfield);
gwy_data_field_add(surffile.dfield, -min);
gwy_data_field_multiply(surffile.dfield,
(surffile.zmax - surffile.zmin)/(max-min));
}
switch (surffile.inversion) {
case SURF_INV_Z:
gwy_data_field_invert(surffile.dfield, FALSE, FALSE, TRUE);
break;
case SURF_FLIP_Z:
gwy_data_field_invert(surffile.dfield, FALSE, TRUE, TRUE);
break;
case SURF_FLOP_Z:
gwy_data_field_invert(surffile.dfield, TRUE, FALSE, TRUE);
break;
default:
break;
}
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", surffile.dfield);
g_object_unref(surffile.dfield);
meta = surffile_get_metadata(&surffile);
gwy_container_set_object_by_name(container, "/0/meta", meta);
g_object_unref(meta);
gwy_app_channel_check_nonsquare(container, 0);
return container;
}
static GwyContainer*
sly_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL, *meta = NULL;
gchar *buffer = NULL;
GError *err = NULL;
GHashTable *hash = NULL;
gchar *p, *line, *value;
guint expecting_data = 0;
SensolyticsChannel *channels = NULL;
Dimensions dimensions;
gint ndata = 0, i;
if (!g_file_get_contents(filename, &buffer, NULL, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
p = buffer;
line = gwy_str_next_line(&p);
g_strstrip(line);
if (!gwy_strequal(line, MAGIC)) {
err_FILE_TYPE(error, "Sensolytics");
goto fail;
}
hash = g_hash_table_new(g_str_hash, g_str_equal);
for (line = gwy_str_next_line(&p); line; line = gwy_str_next_line(&p)) {
if (!line[0])
continue;
if (expecting_data) {
expecting_data--;
/* The columns are comma-separated and numbers use decimal points.
* Do not tempt the number parsing functions more than necessary
* and fix commas to tab characters. */
g_strdelimit(line, ",", '\t');
/* Ignore X, Y and Z, each is two values */
for (i = 0; i < 6; i++)
g_ascii_strtod(line, &line);
for (i = 0; i < ndata; i++)
channels[i].data[expecting_data]
= channels[i].q * g_ascii_strtod(line, &line);
}
else {
g_strstrip(line);
if (line[0] != '#') {
g_warning("Comment line does not start with #.");
continue;
}
do {
line++;
} while (g_ascii_isspace(*line));
if (g_str_has_prefix(line, "X [")) {
if (channels) {
g_warning("Multiple data headers!?");
continue;
}
if (!read_dimensions(hash, &ndata, &dimensions, error)
|| !(channels = create_fields(hash, line,
ndata, &dimensions)))
goto fail;
expecting_data = dimensions.xres * dimensions.yres;
continue;
}
value = strchr(line, ':');
if (!value) {
if (!gwy_strequal(line, "ArrayScan"))
g_warning("Non-parameter-like line %s", line);
continue;
}
*value = '\0';
g_strchomp(line);
do {
value++;
} while (g_ascii_isspace(*value));
if (gwy_strequal(line, "Warning"))
continue;
gwy_debug("<%s>=<%s>", line, value);
g_hash_table_insert(hash, line, value);
}
}
if (!channels) {
err_NO_DATA(error);
goto fail;
}
container = gwy_container_new();
for (i = 0; i < ndata; i++) {
GQuark key = gwy_app_get_data_key_for_id(i);
gwy_data_field_invert(channels[i].dfield, FALSE, TRUE, FALSE);
gwy_container_set_object(container, key, channels[i].dfield);
gwy_app_channel_check_nonsquare(container, i);
if (channels[i].name) {
gchar *s = g_strconcat(g_quark_to_string(key), "/title", NULL);
gwy_container_set_string_by_name(container, s,
g_strdup(channels[i].name));
g_free(s);
}
else
gwy_app_channel_title_fall_back(container, i);
gwy_file_channel_import_log_add(container, i, NULL, filename);
}
meta = get_meta(hash);
clone_meta(container, meta, ndata);
g_object_unref(meta);
fail:
g_free(buffer);
if (hash)
g_hash_table_destroy(hash);
if (channels) {
for (i = 0; i < ndata; i++)
g_object_unref(channels[i].dfield);
g_free(channels);
}
return container;
}
static GwyContainer*
rhk_sm3_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GPtrArray *rhkfile;
RHKPage *rhkpage;
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
const guchar *p;
GString *key;
guint i, count;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < HEADER_SIZE) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
rhkfile = g_ptr_array_new();
p = buffer;
count = 0;
gwy_debug("position %04x", p - buffer);
while ((rhkpage = rhk_sm3_read_page(&p, &size, &err))) {
gwy_debug("Page #%u read OK", count);
count++;
rhkpage->pageno = count;
gwy_debug("position %04x", p - buffer);
if (rhkpage->type != RHK_TYPE_IMAGE) {
gwy_debug("Page is not IMAGE, skipping");
rhk_sm3_page_free(rhkpage);
continue;
}
g_ptr_array_add(rhkfile, rhkpage);
}
/* Be tolerant and don't fail when we were able to import at least
* something */
if (!rhkfile->len) {
if (err)
g_propagate_error(error, err);
else
err_NO_DATA(error);
gwy_file_abandon_contents(buffer, size, NULL);
g_ptr_array_free(rhkfile, TRUE);
return NULL;
}
g_clear_error(&err);
container = gwy_container_new();
key = g_string_new("");
for (i = 0; i < rhkfile->len; i++) {
const gchar *cs;
gchar *s;
rhkpage = g_ptr_array_index(rhkfile, i);
dfield = rhk_sm3_page_to_data_field(rhkpage);
g_string_printf(key, "/%d/data", i);
gwy_container_set_object_by_name(container, key->str, dfield);
g_object_unref(dfield);
p = rhkpage->strings[RHK_STRING_LABEL];
cs = gwy_enum_to_string(rhkpage->scan_dir,
scan_directions, G_N_ELEMENTS(scan_directions));
if (p && *p) {
g_string_append(key, "/title");
if (cs)
s = g_strdup_printf("%s [%s]", p, cs);
else
s = g_strdup(p);
gwy_container_set_string_by_name(container, key->str, s);
}
meta = rhk_sm3_get_metadata(rhkpage);
g_string_printf(key, "/%d/meta", i);
gwy_container_set_object_by_name(container, key->str, meta);
g_object_unref(meta);
gwy_app_channel_check_nonsquare(container, i);
}
g_string_free(key, TRUE);
gwy_file_abandon_contents(buffer, size, NULL);
for (i = 0; i < rhkfile->len; i++)
rhk_sm3_page_free(g_ptr_array_index(rhkfile, i));
g_ptr_array_free(rhkfile, TRUE);
return container;
}
static GwyContainer*
int_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL, *meta;
GwyDataField *dfield = NULL, *mfield = NULL;
CodeVGridDataType type;
gchar *line, *p, *comment, *end, *buffer = NULL;
const gchar *unit, *title;
gchar **fields = NULL;
gsize size;
GError *err = NULL;
gdouble xreal, yreal;
gint i, xres, yres, no_data_value = 32767;
guint fi;
gdouble scale_size, wavelength, q = 1.0, x_scale = 1.0;
gboolean nearest_neighbour = FALSE;
gdouble *data, *mdata;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
goto fail;
}
/* Skip comments. */
p = buffer;
for (line = gwy_str_next_line(&p);
line && line[0] == '!';
line = gwy_str_next_line(&p)) {
gwy_debug("comment <%s>", line);
}
if (!line) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
/* The title. */
comment = line;
if (!(line = gwy_str_next_line(&p))) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
gwy_debug("comment <%s>", comment);
fields = split_line_in_place(line);
if (!fields
|| g_strv_length(fields) < 8
|| !gwy_strequal(fields[0], "GRD")
|| !(xres = atoi(fields[1]))
|| !(yres = atoi(fields[2]))
|| !(type = gwy_stramong(fields[3],
"SUR", "WFR", "FIL", "THV", "BIR", "CAO",
NULL))
|| !gwy_strequal(fields[4], "WVL")
|| (!(wavelength = g_ascii_strtod(fields[5], &end))
&& end == fields[5])) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
gwy_debug("type %u (%s)", type, fields[3]);
gwy_debug("xres %d, yres %d", xres, yres);
gwy_debug("wavelength %g", wavelength);
fi = 6;
if (gwy_strequal(fields[fi], "NNB")) {
nearest_neighbour = TRUE;
fi++;
}
gwy_debug("nearest_neighbour %d", nearest_neighbour);
if (!fields[fi] || !gwy_strequal(fields[fi], "SSZ")) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
fi++;
if (!(scale_size = g_ascii_strtod(fields[fi], &end)) && end == fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
gwy_debug("scale_size %g", scale_size);
if (!scale_size) {
g_warning("Zero SSZ, fixing to 1.0");
scale_size = 1.0;
}
fi++;
if (fields[fi] && gwy_strequal(fields[fi], "NDA")) {
fi++;
if (!fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
no_data_value = atoi(fields[fi]);
fi++;
}
gwy_debug("no_data_value %d", no_data_value);
if (fields[fi] && gwy_strequal(fields[fi], "XSC")) {
fi++;
if (!fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
if (!(x_scale = g_ascii_strtod(fields[fi], &end))
&& end == fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
fi++;
}
gwy_debug("x_scale %g", x_scale);
if (!x_scale) {
g_warning("Zero XSC, fixing to 1.0");
x_scale = 1.0;
}
/* There may be more stuff but we do not know anything about it. */
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
goto fail;
yreal = 1.0;
xreal = x_scale*yreal;
dfield = gwy_data_field_new(xres, yres, xreal, yreal, TRUE);
if (type == CODEV_INT_SURFACE_DEFORMATION) {
q = 1e-6*wavelength/scale_size;
unit = "m";
title = "Surface";
}
else if (type == CODEV_INT_WAVEFRONT_DEFORMATION) {
q = 1e-6*wavelength/scale_size;
unit = "m";
title = "Wavefront";
}
else {
g_warning("Don't know how to convert this grid data type to physical "
"units.");
title = fields[3];
}
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), unit);
mfield = gwy_data_field_new_alike(dfield, TRUE);
data = gwy_data_field_get_data(dfield);
mdata = gwy_data_field_get_data(mfield);
for (i = 0; i < xres*yres; i++, p = end) {
gint value = strtol(p, &end, 10);
if (value != no_data_value && (type != CODEV_INT_INTENSITY_FILTER
|| value >= 0)) {
mdata[i] = 1.0;
data[i] = q*value;
}
}
if (!gwy_app_channel_remove_bad_data(dfield, mfield))
gwy_object_unref(mfield);
container = gwy_container_new();
/*
gwy_data_field_invert(dfield, TRUE, FALSE, FALSE);
from F. Riguet : apparently no flip is needed (the raw data import module
gives the correct orientation without further flipping)
*/
gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield);
g_object_unref(dfield);
gwy_app_channel_check_nonsquare(container, 0);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup(title));
if (mfield) {
/*
gwy_data_field_invert(mfield, FALSE, TRUE, FALSE);
*/
gwy_container_set_object(container, gwy_app_get_mask_key_for_id(0),
mfield);
g_object_unref(mfield);
}
meta = gwy_container_new();
gwy_container_set_string_by_name(meta, "Comment", g_strdup(comment));
gwy_container_set_string_by_name(meta, "Interpolation",
g_strdup(nearest_neighbour
? "NNB" : "Linear"));
gwy_container_set_string_by_name(meta, "Wavelength",
g_strdup_printf("%g μm", wavelength));
gwy_container_set_object_by_name(container, "/0/meta", meta);
g_object_unref(meta);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
fail:
g_free(fields);
g_free(buffer);
return container;
}
static GwyContainer*
nanoscope_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *meta, *container = NULL;
GError *err = NULL;
gchar *buffer = NULL;
gchar *p;
const gchar *self;
gsize size = 0;
NanoscopeFileType file_type;
NanoscopeData *ndata;
NanoscopeValue *val;
GHashTable *hash, *scannerlist = NULL, *scanlist = NULL;
GList *l, *list = NULL;
gint i, xres = 0, yres = 0;
gboolean ok, has_version = FALSE;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
file_type = NANOSCOPE_FILE_TYPE_NONE;
if (size > MAGIC_SIZE) {
if (!memcmp(buffer, MAGIC_TXT, MAGIC_SIZE))
file_type = NANOSCOPE_FILE_TYPE_TXT;
else if (!memcmp(buffer, MAGIC_BIN, MAGIC_SIZE))
file_type = NANOSCOPE_FILE_TYPE_BIN;
}
if (!file_type) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("File is not a Nanoscope file, "
"or it is a unknown subtype."));
g_free(buffer);
return NULL;
}
gwy_debug("File type: %d", file_type);
/* as already know file_type, fix the first char for hash reading */
*buffer = '\\';
p = buffer;
while ((hash = read_hash(&p, &err))) {
ndata = g_new0(NanoscopeData, 1);
ndata->hash = hash;
list = g_list_append(list, ndata);
}
if (err) {
g_propagate_error(error, err);
ok = FALSE;
}
else
ok = TRUE;
for (l = list; ok && l; l = g_list_next(l)) {
ndata = (NanoscopeData*)l->data;
hash = ndata->hash;
self = g_hash_table_lookup(hash, "#self");
/* The alternate names were found in files written by some beast
* called Nanoscope E software */
if (gwy_strequal(self, "Scanner list")
|| gwy_strequal(self, "Microscope list")) {
scannerlist = hash;
continue;
}
if (gwy_strequal(self, "File list")) {
has_version = !!g_hash_table_lookup(hash, "Version");
gwy_debug("has Version: %d", has_version);
continue;
}
if (gwy_strequal(self, "Ciao scan list")
|| gwy_strequal(self, "Afm list")
|| gwy_strequal(self, "NC Afm list")) {
get_scan_list_res(hash, &xres, &yres);
scanlist = hash;
}
if (!gwy_strequal(self, "Ciao image list")
&& !gwy_strequal(self, "AFM image list")
&& !gwy_strequal(self, "NCAFM image list"))
continue;
ndata->data_field = hash_to_data_field(hash, scannerlist, scanlist,
file_type, has_version,
size, buffer,
xres, yres,
&p, error);
ok = ok && ndata->data_field;
}
if (ok) {
gchar key[40];
i = 0;
container = gwy_container_new();
for (l = list; l; l = g_list_next(l)) {
ndata = (NanoscopeData*)l->data;
if (ndata->data_field) {
g_snprintf(key, sizeof(key), "/%d/data", i);
gwy_container_set_object_by_name(container, key,
ndata->data_field);
if ((val = g_hash_table_lookup(ndata->hash, "@2:Image Data"))
&& val->soft_scale) {
g_snprintf(key, sizeof(key), "/%d/data/title", i);
gwy_container_set_string_by_name(container, key,
g_strdup(val->soft_scale));
}
meta = nanoscope_get_metadata(ndata->hash, list);
g_snprintf(key, sizeof(key), "/%d/meta", i);
gwy_container_set_object_by_name(container, key, meta);
g_object_unref(meta);
gwy_app_channel_check_nonsquare(container, i);
i++;
}
}
if (!i)
gwy_object_unref(container);
}
for (l = list; l; l = g_list_next(l)) {
ndata = (NanoscopeData*)l->data;
gwy_object_unref(ndata->data_field);
if (ndata->hash)
g_hash_table_destroy(ndata->hash);
g_free(ndata);
}
g_free(buffer);
g_list_free(list);
if (!container && ok)
err_NO_DATA(error);
return container;
}
