astrognome/src/ag-chart.c

1855 lines
51 KiB
C
Raw Normal View History

#include <errno.h>
#include <gio/gio.h>
#include <libxml/parser.h>
#include <libxml/xpath.h>
2013-09-17 22:29:13 +00:00
#include <libxml/tree.h>
2013-09-20 07:58:31 +00:00
#include <libxml/xinclude.h>
2013-09-19 17:56:25 +00:00
#include <libxslt/xsltInternals.h>
#include <libxslt/transform.h>
#include <swe-glib.h>
#include <locale.h>
#include <math.h>
2014-08-10 11:54:51 +00:00
#include <string.h>
#include <librsvg/rsvg.h>
#include "config.h"
#include "astrognome.h"
#include "ag-db.h"
#include "ag-chart.h"
2014-08-10 11:54:51 +00:00
#include "placidus.h"
typedef struct _AgChartPrivate {
gchar *name;
gchar *country;
gchar *city;
gchar *save_buffer;
GList *planet_list;
gchar *note;
} AgChartPrivate;
enum {
PROP_0,
PROP_NAME,
PROP_COUNTRY,
2014-08-11 11:12:34 +00:00
PROP_CITY,
PROP_NOTE,
2014-08-11 11:21:26 +00:00
PROP_LAST
};
typedef enum {
XML_CONVERT_STRING,
XML_CONVERT_DOUBLE,
XML_CONVERT_INT
} XmlConvertType;
#if !LIBRSVG_HAVE_CSS
# error "We need RSVG CSS support to export charts as images!"
#endif
G_DEFINE_QUARK(ag_chart_error_quark, ag_chart_error);
2014-06-29 14:53:52 +00:00
G_DEFINE_TYPE_WITH_PRIVATE(AgChart, ag_chart, GSWE_TYPE_MOMENT);
2014-08-11 11:21:26 +00:00
static GParamSpec *properties[PROP_LAST];
#define ag_g_variant_unref(v) \
if ((v) != NULL) { \
g_variant_unref((v)); \
}
static void ag_chart_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec);
static void ag_chart_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec);
static void ag_chart_finalize(GObject *gobject);
static void
ag_chart_class_init(AgChartClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
gobject_class->set_property = ag_chart_set_property;
gobject_class->get_property = ag_chart_get_property;
gobject_class->finalize = ag_chart_finalize;
2014-08-11 11:21:26 +00:00
properties[PROP_NAME] = g_param_spec_string(
"name",
"Chart name",
"Name of the person on this chart",
NULL,
G_PARAM_READWRITE
);
g_object_class_install_property(
gobject_class,
PROP_NAME,
2014-08-11 11:21:26 +00:00
properties[PROP_NAME]
);
properties[PROP_COUNTRY] = g_param_spec_string(
"country",
"Country",
"Name of the country of birth",
NULL,
G_PARAM_READWRITE
);
g_object_class_install_property(
gobject_class,
PROP_COUNTRY,
2014-08-11 11:21:26 +00:00
properties[PROP_COUNTRY]
);
properties[PROP_CITY] = g_param_spec_string(
"city",
"City name",
"Name of the city of birth",
NULL,
G_PARAM_READWRITE
);
g_object_class_install_property(
gobject_class,
PROP_CITY,
2014-08-11 11:21:26 +00:00
properties[PROP_CITY]
);
properties[PROP_NOTE] = g_param_spec_string(
"note",
"Note",
"Chart notes",
NULL,
G_PARAM_READWRITE
);
2014-08-11 11:12:34 +00:00
g_object_class_install_property(
gobject_class,
PROP_NOTE,
2014-08-11 11:21:26 +00:00
properties[PROP_NOTE]
2014-08-11 11:12:34 +00:00
);
}
static void
ag_chart_init(AgChart *chart)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
priv->name = NULL;
priv->country = NULL;
priv->city = NULL;
priv->save_buffer = NULL;
priv->planet_list = NULL;
}
static void
ag_chart_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
switch (prop_id) {
case PROP_NAME:
ag_chart_set_name(AG_CHART(gobject), g_value_get_string(value));
break;
case PROP_COUNTRY:
ag_chart_set_country(AG_CHART(gobject), g_value_get_string(value));
break;
case PROP_CITY:
ag_chart_set_city(AG_CHART(gobject), g_value_get_string(value));
2014-08-11 11:12:34 +00:00
break;
case PROP_NOTE:
ag_chart_set_note(AG_CHART(gobject), g_value_get_string(value));
break;
}
}
static void
ag_chart_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgChartPrivate *priv = ag_chart_get_instance_private(AG_CHART(gobject));
switch (prop_id) {
case PROP_NAME:
g_value_set_string(value, priv->name);
break;
case PROP_COUNTRY:
g_value_set_string(value, priv->country);
break;
case PROP_CITY:
g_value_set_string(value, priv->city);
break;
2014-08-11 11:12:34 +00:00
case PROP_NOTE:
g_value_set_string(value, priv->note);
break;
}
}
static void
ag_chart_finalize(GObject *gobject)
{
AgChart *chart = AG_CHART(gobject);
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
if (priv->name != NULL) {
g_free(priv->name);
}
if (priv->country != NULL) {
g_free(priv->country);
}
if (priv->city != NULL) {
g_free(priv->city);
}
if (priv->save_buffer != NULL) {
g_free(priv->save_buffer);
}
}
void
ag_chart_add_planets(AgChart *chart)
{
int i;
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
for (i = 0; i < used_planets_count; i++) {
gswe_moment_add_planet(GSWE_MOMENT(chart), used_planets[i], NULL);
priv->planet_list = g_list_prepend(
priv->planet_list,
GINT_TO_POINTER(used_planets[i])
);
}
priv->planet_list = g_list_reverse(priv->planet_list);
}
AgChart *
ag_chart_new_full(GsweTimestamp *timestamp,
gdouble longitude,
gdouble latitude,
gdouble altitude,
GsweHouseSystem house_system)
{
AgChart *chart;
GsweCoordinates *coords = g_new0(GsweCoordinates, 1);
coords->longitude = longitude;
coords->latitude = latitude;
coords->altitude = altitude;
2013-09-17 07:31:37 +00:00
chart = AG_CHART(g_object_new(AG_TYPE_CHART,
"timestamp", timestamp,
"coordinates", coords,
"house-system", house_system,
NULL));
g_free(coords);
ag_chart_add_planets(chart);
2013-09-17 07:31:37 +00:00
return chart;
}
void
ag_chart_set_name(AgChart *chart, const gchar *name)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
if (priv->name != NULL) {
g_free(priv->name);
}
priv->name = g_strdup(name);
2014-08-11 11:21:26 +00:00
g_object_notify_by_pspec(G_OBJECT(chart), properties[PROP_NAME]);
}
const gchar *
ag_chart_get_name(AgChart *chart)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
return priv->name;
}
void
ag_chart_set_country(AgChart *chart, const gchar *country)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
if (priv->country != NULL) {
g_free(priv->country);
}
priv->country = g_strdup(country);
2014-08-11 11:21:26 +00:00
g_object_notify_by_pspec(G_OBJECT(chart), properties[PROP_COUNTRY]);
}
const gchar *
ag_chart_get_country(AgChart *chart)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
return priv->country;
}
void
ag_chart_set_city(AgChart *chart, const gchar *city)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
if (priv->city != NULL) {
g_free(priv->city);
}
priv->city = g_strdup(city);
2014-08-11 11:21:26 +00:00
g_object_notify_by_pspec(G_OBJECT(chart), properties[PROP_CITY]);
}
const gchar *
ag_chart_get_city(AgChart *chart)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
return priv->city;
}
/**
* get_by_xpath:
* @xpath_context: an XPath context
* @uri: the name of the file currently being processed. Used in error messages
* only
* @xpath: an XPath expression
* @value_required: marks the value as required. Although the XML tags must be
* present, some values (like country or city name) may be
* omitted
* @type: the type of the variable to return
* @err: a GError
*
* Get the value of an XML tag via XPath.
*
* Returns: (transfer container): a GVariant with the requested value
*/
static GVariant *
get_by_xpath(xmlXPathContextPtr xpath_context,
const gchar *uri,
const gchar *xpath,
gboolean value_required,
XmlConvertType type,
GError **err)
{
xmlXPathObjectPtr xpathObj;
const gchar *text;
char *endptr;
GVariant *ret = NULL;
gdouble d;
gint i;
if ((xpathObj = xmlXPathEvalExpression(
(const xmlChar *)xpath,
xpath_context
)) == NULL) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_LIBXML,
"File '%s' could not be parsed due to internal XML error.",
uri
);
return NULL;
}
if (xpathObj->nodesetval == NULL) {
g_debug("No such node '%s'", xpath);
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"File '%s' doesn't look like a valid saved chart: "
"missing node: %s",
uri, xpath
);
xmlXPathFreeObject(xpathObj);
return NULL;
}
if (xpathObj->nodesetval->nodeNr > 1) {
g_debug("Too many '%s' nodes", xpath);
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"File '%s' doesn't look like a valid saved chart: "
"too many node: %s",
uri, xpath
);
xmlXPathFreeObject(xpathObj);
return NULL;
}
if (xpathObj->nodesetval->nodeNr == 0) {
if (value_required) {
g_debug("No '%s' nodes", xpath);
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"File '%s' doesn't look like a valid saved chart: "
"missing node: %s",
uri, xpath
);
xmlXPathFreeObject(xpathObj);
return NULL;
} else {
GVariant *ret = NULL;
switch (type) {
case XML_CONVERT_STRING:
ret = g_variant_new("ms", NULL);
break;
case XML_CONVERT_DOUBLE:
ret = g_variant_new("md", FALSE, 0);
break;
case XML_CONVERT_INT:
ret = g_variant_new("mi", FALSE, 0);
break;
}
return ret;
}
}
text = (const gchar *)xpathObj->nodesetval->nodeTab[0]->content;
switch (type) {
case XML_CONVERT_STRING:
ret = g_variant_new("ms", text);
break;
case XML_CONVERT_DOUBLE:
d = g_ascii_strtod(text, &endptr);
if ((*endptr != 0) || (errno != 0)) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"File '%s' doesn't look like a valid saved chart: "
"Invalid value in node: %s",
uri, xpath
);
ret = NULL;
} else {
ret = g_variant_new_double(d);
}
break;
case XML_CONVERT_INT:
i = strtol(text, &endptr, 10);
if ((*endptr != 0) || (errno != 0)) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"File '%s' doesn't look like a valid saved chart: "
"Invalid value in node: %s",
uri, xpath
);
ret = NULL;
} else {
ret = g_variant_new_int32(i);
}
break;
}
xmlXPathFreeObject(xpathObj);
return ret;
}
AgChart *
ag_chart_load_from_agc(GFile *file, GError **err)
{
AgChart *chart = NULL;
gchar *uri,
*xml = NULL,
*name,
*country_name,
*city_name,
*house_system_name,
*house_system_enum_name;
gsize length;
xmlDocPtr doc;
xmlXPathContextPtr xpath_context;
GVariant *chart_name,
*country,
*city,
*longitude,
*latitude,
*altitude,
*year,
*month,
*day,
*hour,
*minute,
*second,
*timezone,
*note,
*house_system;
GsweTimestamp *timestamp;
GEnumClass *house_system_class;
GEnumValue *enum_value;
gboolean found_error = FALSE;
uri = g_file_get_uri(file);
if (!g_file_load_contents(file, NULL, &xml, &length, NULL, err)) {
g_free(uri);
return NULL;
}
if ((doc = xmlReadMemory(xml, length, "chart.xml", NULL, 0)) == NULL) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"File '%s' can not be read. " \
"Maybe it is corrupt, or not a save file at all",
uri
);
g_free(xml);
g_free(uri);
return NULL;
}
if ((xpath_context = xmlXPathNewContext(doc)) == NULL) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_LIBXML,
"File '%s' could not be loaded due to internal LibXML error",
uri
);
xmlFreeDoc(doc);
g_free(xml);
g_free(uri);
return NULL;
}
if ((chart_name = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/name/text()",
TRUE,
XML_CONVERT_STRING,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((country = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/place/country/text()",
FALSE,
XML_CONVERT_STRING,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((city = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/place/city/text()",
FALSE,
XML_CONVERT_STRING,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((longitude = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/place/longitude/text()",
TRUE,
XML_CONVERT_DOUBLE,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((latitude = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/place/latitude/text()",
TRUE,
XML_CONVERT_DOUBLE,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((altitude = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/place/altitude/text()",
TRUE,
XML_CONVERT_DOUBLE,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((year = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/year/text()",
TRUE,
XML_CONVERT_INT,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((month = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/month/text()",
TRUE,
XML_CONVERT_INT,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((day = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/day/text()",
TRUE,
XML_CONVERT_INT,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((hour = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/hour/text()",
TRUE,
XML_CONVERT_INT,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((minute = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/minute/text()",
TRUE,
XML_CONVERT_INT,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((second = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/second/text()",
TRUE,
XML_CONVERT_INT,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((timezone = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/time/timezone/text()",
TRUE,
XML_CONVERT_DOUBLE,
err
)) == NULL) {
2013-09-21 13:47:48 +00:00
found_error = TRUE;
}
if ((house_system = get_by_xpath(
xpath_context,
uri,
"/chartinfo/data/housesystem/text()",
TRUE,
XML_CONVERT_STRING,
err
)) == NULL) {
found_error = TRUE;
}
note = get_by_xpath(
xpath_context,
uri,
"/chartinfo/note/text()",
FALSE,
XML_CONVERT_STRING,
NULL
);
2013-09-21 13:47:48 +00:00
if (found_error) {
ag_g_variant_unref(house_system);
ag_g_variant_unref(note);
2013-09-21 13:47:48 +00:00
ag_g_variant_unref(chart_name);
ag_g_variant_unref(country);
ag_g_variant_unref(city);
ag_g_variant_unref(longitude);
ag_g_variant_unref(latitude);
ag_g_variant_unref(altitude);
ag_g_variant_unref(year);
ag_g_variant_unref(month);
ag_g_variant_unref(day);
ag_g_variant_unref(hour);
ag_g_variant_unref(minute);
ag_g_variant_unref(second);
ag_g_variant_unref(timezone);
xmlFreeDoc(doc);
g_free(xml);
g_free(uri);
return NULL;
}
timestamp = gswe_timestamp_new_from_gregorian_full(
g_variant_get_int32(year),
g_variant_get_int32(month),
g_variant_get_int32(day),
g_variant_get_int32(hour),
g_variant_get_int32(minute),
g_variant_get_int32(second),
0,
g_variant_get_double(timezone)
);
g_variant_unref(year);
g_variant_unref(month);
g_variant_unref(day);
g_variant_unref(hour);
g_variant_unref(minute);
g_variant_unref(second);
g_variant_unref(timezone);
g_variant_get(house_system, "ms", &house_system_name);
g_variant_unref(house_system);
house_system_enum_name = g_utf8_strdown(house_system_name, -1);
g_free(house_system_name);
house_system_class = g_type_class_ref(GSWE_TYPE_HOUSE_SYSTEM);
if ((enum_value = g_enum_get_value_by_nick(
G_ENUM_CLASS(house_system_class),
house_system_enum_name
)) == NULL) {
g_variant_unref(longitude);
g_variant_unref(latitude);
g_variant_unref(altitude);
g_variant_unref(chart_name);
g_variant_unref(country);
g_variant_unref(city);
ag_g_variant_unref(note);
g_type_class_unref(house_system_class);
g_free(house_system_enum_name);
g_set_error(err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"Unknown house system in save file"
);
return NULL;
}
chart = ag_chart_new_full(
timestamp,
g_variant_get_double(longitude),
g_variant_get_double(latitude),
g_variant_get_double(altitude),
enum_value->value
);
g_type_class_unref(house_system_class);
g_free(house_system_enum_name);
g_variant_unref(longitude);
g_variant_unref(latitude);
g_variant_unref(altitude);
g_variant_get(chart_name, "ms", &name);
g_variant_unref(chart_name);
ag_chart_set_name(chart, name);
g_free(name);
g_variant_get(country, "ms", &country_name);
g_variant_unref(country);
ag_chart_set_country(chart, country_name);
g_free(country_name);
g_variant_get(city, "ms", &city_name);
g_variant_unref(city);
ag_chart_set_city(chart, city_name);
g_free(city_name);
if (note) {
gchar *note_text;
g_variant_get(note, "ms", &note_text);
g_variant_unref(note);
ag_chart_set_note(chart, note_text);
}
g_free(xml);
g_free(uri);
xmlXPathFreeContext(xpath_context);
xmlFreeDoc(doc);
return chart;
}
2014-08-10 11:54:51 +00:00
AgChart *ag_chart_load_from_placidus_file(GFile *file,
GError **err)
{
gchar *hor_contents,
*header,
*name_buf,
*name,
*type_buf,
*type,
*city_buf,
*city,
*notes_buf,
*notes,
*comma,
*country;
gsize hor_length,
name_len,
type_len,
city_len,
notes_len;
guint8 calendar,
month,
day,
hour,
minute,
long_deg,
long_min,
long_hemi,
lat_deg,
lat_min,
lat_hemi,
zone_type,
zone_hour,
zone_minute,
zone_sign,
gender;
guint16 year;
gdouble second,
swe_tz,
real_long,
real_lat;
GsweTimestamp *timestamp;
AgChart *chart;
GError *local_err = NULL;
if (!g_file_load_contents(
file,
NULL,
&hor_contents,
&hor_length,
NULL,
err)) {
return NULL;
}
// A Placidus save file is at least 2176 bytes (3926 in case of
// a Nostradamus save)
if (hor_length < 2176) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_INVALID_PLAC_FILE,
"Invalid Placidus file."
);
return NULL;
}
header = g_malloc0(PLAC_HEADER_LEN);
memcpy(header, hor_contents + PLAC_HEADER_POS, PLAC_HEADER_LEN);
if (strncmp(
"PLACIDUS v4.0 Horoscope File\x0d\x0a", header,
PLAC_HEADER_LEN)) {
g_free(header);
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_INVALID_PLAC_FILE,
"Invalid Placidus file."
);
return NULL;
}
g_free(header);
name_buf = g_malloc0(PLAC_NAME_LEN + 1);
memcpy(name_buf, hor_contents + PLAC_NAME_POS, PLAC_NAME_LEN);
name = g_convert(
name_buf, -1,
"UTF-8", "LATIN2",
NULL,
&name_len,
&local_err
);
g_free(name_buf);
type_buf = g_malloc0(PLAC_TYPE_LEN + 1);
memcpy(type_buf, hor_contents + PLAC_TYPE_POS, PLAC_TYPE_LEN);
type = g_convert(
type_buf, -1,
"UTF-8", "LATIN2",
NULL,
&type_len,
&local_err
);
g_free(type_buf);
notes_buf = g_malloc0(PLAC_NOTES_LEN + 1);
memcpy(notes_buf, hor_contents + PLAC_NOTES_POS, PLAC_NOTES_LEN);
notes = g_convert(
notes_buf, -1,
"UTF-8", "LATIN2",
NULL,
&notes_len,
&local_err
);
g_free(notes_buf);
city_buf = g_malloc0(PLAC_CITY_LEN + 1);
memcpy(city_buf, hor_contents + PLAC_CITY_POS, PLAC_CITY_LEN);
city = g_convert(
city_buf, -1,
"UTF-8", "LATIN2",
NULL,
&city_len,
&local_err
);
g_free(city_buf);
memcpy(&calendar, hor_contents + PLAC_CALENDAR_POS, sizeof(guint8));
memcpy(&year, hor_contents + PLAC_YEAR_POS, sizeof(guint16));
year = GUINT16_FROM_LE(year);
memcpy(&month, hor_contents + PLAC_MONTH_POS, sizeof(guint8));
memcpy(&day, hor_contents + PLAC_DAY_POS, sizeof(guint8));
memcpy(&hour, hor_contents + PLAC_HOUR_POS, sizeof(guint8));
memcpy(&minute, hor_contents + PLAC_MINUTE_POS, sizeof(guint8));
memcpy(&second, hor_contents + PLAC_SECOND_POS, sizeof(gdouble));
memcpy(&long_deg, hor_contents + PLAC_LONGDEG_POS, sizeof(guint8));
memcpy(&long_min, hor_contents + PLAC_LONGMIN_POS, sizeof(guint8));
memcpy(&long_hemi, hor_contents + PLAC_LONGSIGN_POS, sizeof(guint8));
memcpy(&lat_deg, hor_contents + PLAC_LATDEG_POS, sizeof(guint8));
memcpy(&lat_min, hor_contents + PLAC_LATMIN_POS, sizeof(guint8));
memcpy(&lat_hemi, hor_contents + PLAC_LATSIGN_POS, sizeof(guint8));
memcpy(&zone_type, hor_contents + PLAC_ZONETYPE_POS, sizeof(guint8));
memcpy(&zone_hour, hor_contents + PLAC_ZONEHOUR_POS, sizeof(guint8));
memcpy(&zone_minute, hor_contents + PLAC_ZONEMIN_POS, sizeof(guint8));
memcpy(&zone_sign, hor_contents + PLAC_ZONESIGN_POS, sizeof(guint8));
memcpy(&gender, hor_contents + PLAC_GENDER_POS, sizeof(guint8));
g_free(hor_contents);
switch (zone_type) {
// UTC
case 0:
swe_tz = 0.0;
break;
// Local mean time. It is unclear what it exactly means for Placidus,
// so we dont support it yet.
case 1:
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_UNSUPPORTED_PLAC_FILE,
"Local mean time Placidus charts are not supported yet."
);
g_free(name);
g_free(type);
g_free(city);
g_free(notes);
return NULL;
// Zone time
case 2:
{
GDateTime *utc,
*final;
GTimeZone *zone;
gchar *zone_string;
utc = g_date_time_new_utc(
year, month, day,
hour, minute, second
);
zone_string = g_strdup_printf(
"%c%02d:%02d",
(zone_sign == 0) ? '+' : '-',
zone_hour,
zone_minute
);
zone = g_time_zone_new(zone_string);
final = g_date_time_to_timezone(utc, zone);
g_date_time_unref(utc);
year = g_date_time_get_year(final);
month = g_date_time_get_month(final);
day = g_date_time_get_day_of_month(final);
hour = g_date_time_get_hour(final);
minute = g_date_time_get_minute(final);
second = g_date_time_get_second(final);
swe_tz = (gdouble)zone_hour + (gdouble)zone_minute / 60.0;
}
break;
default:
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_UNSUPPORTED_PLAC_FILE,
"Unknown time zone type."
);
g_free(name);
g_free(type);
g_free(city);
g_free(notes);
return NULL;
}
switch (calendar) {
// Julian calendar
case 0:
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_UNSUPPORTED_PLAC_FILE,
"Julian calendar is not supported by Astrognome yet."
);
g_free(name);
g_free(type);
g_free(city);
g_free(notes);
return NULL;
// Gregorian calendar
case 1:
break;
default:
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_UNSUPPORTED_PLAC_FILE,
"Unknown calendar type in Placidus chart."
);
g_free(name);
g_free(type);
g_free(city);
g_free(notes);
return NULL;
}
if (strncmp("radix", type, 5) != 0) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_UNSUPPORTED_PLAC_FILE,
"Only radix charts are supported by Astrognome yet."
);
g_free(name);
g_free(type);
g_free(city);
g_free(notes);
return NULL;
}
if ((comma = strchr(city, ',')) != NULL) {
*comma = 0;
country = comma + 2;
} else {
country = g_strdup("");
}
real_long = (gdouble)long_deg + (gdouble)long_min / 60.0;
real_lat = (gdouble)lat_deg + (gdouble)lat_deg / 60.0;
if (long_hemi == 1) {
real_long = - real_long;
}
if (lat_hemi == 1) {
real_lat = - real_lat;
}
if (zone_sign == 1) {
swe_tz = - swe_tz;
}
timestamp = gswe_timestamp_new_from_gregorian_full(
year, month, day,
hour, minute, second, 0,
swe_tz
);
chart = ag_chart_new_full(
timestamp,
real_long, real_lat, DEFAULT_ALTITUDE,
2014-08-10 11:54:51 +00:00
GSWE_HOUSE_SYSTEM_PLACIDUS
);
ag_chart_set_name(chart, name);
ag_chart_set_country(chart, country);
ag_chart_set_city(chart, city);
// TODO: implement gender
ag_chart_set_note(chart, notes);
return chart;
}
AgChart *
ag_chart_new_from_db_save(AgDbChartSave *save_data, GError **err)
{
GsweTimestamp *timestamp;
gchar *house_system_enum_name;
GTypeClass *house_system_class;
GEnumValue *enum_value;
GsweHouseSystem house_system;
AgChart *chart;
if (save_data == NULL) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_EMPTY_RECORD,
"Invalid chart"
);
return NULL;
}
house_system_enum_name = g_utf8_strdown(save_data->house_system, -1);
house_system_class = g_type_class_ref(GSWE_TYPE_HOUSE_SYSTEM);
if ((enum_value = g_enum_get_value_by_nick(
G_ENUM_CLASS(house_system_class),
house_system_enum_name
)) == NULL) {
g_free(house_system_enum_name);
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_INVALID_HOUSE_SYSTEM,
"Invalid house system: '%s'",
save_data->house_system
);
return NULL;
}
g_free(house_system_enum_name);
house_system = enum_value->value;
timestamp = gswe_timestamp_new_from_gregorian_full(
save_data->year, save_data->month, save_data->day,
save_data->hour, save_data->minute, save_data->second, 0,
save_data->timezone
);
chart = ag_chart_new_full(
timestamp,
save_data->longitude,
save_data->latitude,
save_data->altitude,
house_system
);
ag_chart_set_name(chart, save_data->name);
ag_chart_set_country(chart, save_data->country);
ag_chart_set_city(chart, save_data->city);
ag_chart_set_note(chart, save_data->note);
return chart;
}
static xmlDocPtr
create_save_doc(AgChart *chart)
{
xmlDocPtr doc = NULL;
xmlNodePtr root_node = NULL,
data_node = NULL,
place_node = NULL,
time_node = NULL;
gchar *value;
GsweCoordinates *coordinates;
GsweTimestamp *timestamp;
GEnumClass *house_system_class;
GEnumValue *enum_value;
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "chartinfo");
xmlDocSetRootElement(doc, root_node);
// Begin <data> node
data_node = xmlNewChild(root_node, NULL, BAD_CAST "data", NULL);
xmlNewChild(data_node, NULL, BAD_CAST "name", BAD_CAST priv->name);
// Begin <place> node
place_node = xmlNewChild(data_node, NULL, BAD_CAST "place", NULL);
xmlNewChild(place_node, NULL, BAD_CAST "country", BAD_CAST priv->country);
xmlNewChild(place_node, NULL, BAD_CAST "city", BAD_CAST priv->city);
coordinates = gswe_moment_get_coordinates(GSWE_MOMENT(chart));
value = g_malloc0(12);
g_ascii_dtostr(value, 12, coordinates->longitude);
xmlNewChild(place_node, NULL, BAD_CAST "longitude", BAD_CAST value);
g_free(value);
value = g_malloc0(12);
g_ascii_dtostr(value, 12, coordinates->latitude);
xmlNewChild(place_node, NULL, BAD_CAST "latitude", BAD_CAST value);
g_free(value);
value = g_malloc0(12);
g_ascii_dtostr(value, 12, coordinates->altitude);
xmlNewChild(place_node, NULL, BAD_CAST "altitude", BAD_CAST value);
g_free(value);
g_free(coordinates);
// Begin <time> node
time_node = xmlNewChild(data_node, NULL, BAD_CAST "time", NULL);
timestamp = gswe_moment_get_timestamp(GSWE_MOMENT(chart));
value = g_malloc0(10);
g_ascii_dtostr(
value, 10,
gswe_timestamp_get_gregorian_year(timestamp, NULL)
);
xmlNewChild(time_node, NULL, BAD_CAST "year", BAD_CAST value);
g_free(value);
value = g_malloc0(3);
g_ascii_dtostr(
value, 3,
gswe_timestamp_get_gregorian_month(timestamp, NULL)
);
xmlNewChild(time_node, NULL, BAD_CAST "month", BAD_CAST value);
g_free(value);
value = g_malloc0(3);
g_ascii_dtostr(value, 3, gswe_timestamp_get_gregorian_day(timestamp, NULL));
xmlNewChild(time_node, NULL, BAD_CAST "day", BAD_CAST value);
g_free(value);
value = g_malloc0(3);
g_ascii_dtostr(
value, 3,
gswe_timestamp_get_gregorian_hour(timestamp, NULL)
);
xmlNewChild(time_node, NULL, BAD_CAST "hour", BAD_CAST value);
g_free(value);
value = g_malloc0(3);
g_ascii_dtostr(
value, 3,
gswe_timestamp_get_gregorian_minute(timestamp, NULL)
);
xmlNewChild(time_node, NULL, BAD_CAST "minute", BAD_CAST value);
g_free(value);
value = g_malloc0(3);
g_ascii_dtostr(
value, 3,
gswe_timestamp_get_gregorian_second(timestamp, NULL)
);
xmlNewChild(time_node, NULL, BAD_CAST "second", BAD_CAST value);
g_free(value);
value = g_malloc0(7);
g_ascii_dtostr(value, 7, gswe_timestamp_get_gregorian_timezone(timestamp));
xmlNewChild(time_node, NULL, BAD_CAST "timezone", BAD_CAST value);
g_free(value);
house_system_class = g_type_class_ref(GSWE_TYPE_HOUSE_SYSTEM);
enum_value = g_enum_get_value(
house_system_class,
gswe_moment_get_house_system(GSWE_MOMENT(chart))
);
xmlNewChild(
data_node,
NULL,
BAD_CAST "housesystem",
BAD_CAST enum_value->value_nick
);
g_type_class_unref(house_system_class);
if (ag_chart_get_note(chart)) {
xmlNewChild(
root_node,
NULL,
BAD_CAST "note",
BAD_CAST ag_chart_get_note(chart)
);
}
return doc;
}
void
ag_chart_save_to_file(AgChart *chart, GFile *file, GError **err)
{
xmlChar *content = NULL;
int length;
2013-09-18 09:22:23 +00:00
xmlDocPtr save_doc = create_save_doc(chart);
xmlDocDumpFormatMemoryEnc(save_doc, &content, &length, "UTF-8", 1);
g_file_replace_contents(
file,
(const gchar *)content,
length,
NULL,
FALSE,
G_FILE_CREATE_NONE,
NULL,
NULL,
err
);
2013-09-18 09:22:23 +00:00
xmlFreeDoc(save_doc);
}
gint
ag_chart_sort_planets_by_position(GswePlanetData *planet1,
GswePlanetData *planet2)
{
gdouble pos1,
pos2;
pos1 = gswe_planet_data_get_position(planet1);
pos2 = gswe_planet_data_get_position(planet2);
if (pos1 == pos2) {
return 0;
} else if (pos1 < pos2) {
return -1;
} else {
return 1;
}
}
2013-09-19 17:56:25 +00:00
gchar *
ag_chart_create_svg(
AgChart *chart,
gsize *length,
gboolean rendering,
GError **err)
2013-09-17 22:29:13 +00:00
{
xmlDocPtr doc = create_save_doc(chart),
xslt_doc,
svg_doc;
xmlNodePtr root_node = NULL,
ascmcs_node = NULL,
houses_node = NULL,
bodies_node = NULL,
aspects_node = NULL,
antiscia_node = NULL,
node = NULL;
gchar *value,
*save_content = NULL,
**params;
const gchar *xslt_content;
GList *houses,
*house,
*planet,
*aspect,
*antiscion,
*sorted_planets;
2013-10-03 22:16:55 +00:00
GswePlanetData *planet_data;
GsweAspectData *aspect_data;
GEnumClass *planets_class,
*aspects_class,
*antiscia_class;
2013-10-03 22:16:55 +00:00
gint save_length;
xsltStylesheetPtr xslt_proc;
locale_t current_locale;
GBytes *xslt_data;
gsize xslt_length;
gdouble asc_position,
prev_position;
gboolean first;
guint dist;
gdouble first_pos;
2013-09-17 22:29:13 +00:00
root_node = xmlDocGetRootElement(doc);
// gswe_moment_get_house_cusps() also calculates ascmcs data, so call it
// this early
2013-09-17 22:29:13 +00:00
houses = gswe_moment_get_house_cusps(GSWE_MOMENT(chart), NULL);
// Begin <ascmcs> node
2013-09-19 17:56:25 +00:00
g_debug("Generating theoretical points table");
2013-09-17 22:29:13 +00:00
ascmcs_node = xmlNewChild(root_node, NULL, BAD_CAST "ascmcs", NULL);
node = xmlNewChild(ascmcs_node, NULL, BAD_CAST "ascendant", NULL);
planet_data = gswe_moment_get_planet(
GSWE_MOMENT(chart),
GSWE_PLANET_ASCENDANT,
NULL
);
asc_position = gswe_planet_data_get_position(planet_data);
value = g_malloc0(12);
g_ascii_dtostr(value, 12, asc_position);
2013-09-17 22:29:13 +00:00
xmlNewProp(node, BAD_CAST "degree_ut", BAD_CAST value);
g_free(value);
node = xmlNewChild(ascmcs_node, NULL, BAD_CAST "mc", NULL);
planet_data = gswe_moment_get_planet(
GSWE_MOMENT(chart),
GSWE_PLANET_MC,
NULL
);
value = g_malloc0(12);
2013-10-03 22:16:55 +00:00
g_ascii_dtostr(value, 12, gswe_planet_data_get_position(planet_data));
2013-09-17 22:29:13 +00:00
xmlNewProp(node, BAD_CAST "degree_ut", BAD_CAST value);
g_free(value);
node = xmlNewChild(ascmcs_node, NULL, BAD_CAST "vertex", NULL);
planet_data = gswe_moment_get_planet(
GSWE_MOMENT(chart),
GSWE_PLANET_VERTEX,
NULL
);
value = g_malloc0(12);
2013-10-03 22:16:55 +00:00
g_ascii_dtostr(value, 12, gswe_planet_data_get_position(planet_data));
2013-09-17 22:29:13 +00:00
xmlNewProp(node, BAD_CAST "degree_ut", BAD_CAST value);
g_free(value);
// Begin <houses> node
2013-09-19 17:56:25 +00:00
g_debug("Generating houses table");
2013-09-17 22:29:13 +00:00
houses_node = xmlNewChild(root_node, NULL, BAD_CAST "houses", NULL);
for (house = houses; house; house = g_list_next(house)) {
GsweHouseData *house_data = house->data;
node = xmlNewChild(houses_node, NULL, BAD_CAST "house", NULL);
value = g_malloc0(3);
2013-10-03 22:16:55 +00:00
g_ascii_dtostr(value, 3, gswe_house_data_get_house(house_data));
2013-09-17 22:29:13 +00:00
xmlNewProp(node, BAD_CAST "number", BAD_CAST value);
g_free(value);
value = g_malloc0(12);
g_ascii_dtostr(
value, 12,
gswe_house_data_get_cusp_position(house_data)
);
2013-09-17 22:29:13 +00:00
xmlNewProp(node, BAD_CAST "degree", BAD_CAST value);
g_free(value);
}
// Begin <bodies> node
2013-09-19 17:56:25 +00:00
g_debug("Generating bodies table");
2013-09-17 22:29:13 +00:00
bodies_node = xmlNewChild(root_node, NULL, BAD_CAST "bodies", NULL);
2013-09-18 20:31:14 +00:00
planets_class = g_type_class_ref(GSWE_TYPE_PLANET);
sorted_planets = g_list_sort(
g_list_copy(gswe_moment_get_all_planets(GSWE_MOMENT(chart))),
(GCompareFunc)ag_chart_sort_planets_by_position
);
2013-09-17 22:29:13 +00:00
for (
planet = sorted_planets,
dist = 0,
prev_position = -360.0,
first = TRUE;
planet;
planet = g_list_next(planet)
) {
2013-09-17 22:29:13 +00:00
planet_data = planet->data;
2013-09-18 20:31:14 +00:00
GEnumValue *enum_value;
gdouble position;
2013-09-17 22:29:13 +00:00
if (
(gswe_planet_data_get_planet(planet_data) == GSWE_PLANET_ASCENDANT)
|| (gswe_planet_data_get_planet(planet_data) == GSWE_PLANET_MC)
|| (gswe_planet_data_get_planet(planet_data) == GSWE_PLANET_VERTEX)
) {
2013-09-17 22:29:13 +00:00
continue;
}
position = gswe_planet_data_get_position(planet_data);
if (first) {
dist = 0;
first = FALSE;
first_pos = position;
} else if (fabs(prev_position - first_pos) >= 5.0) {
first_pos = position;
dist = 0;
} else if (fabs(prev_position - position) < 5.0) {
dist++;
} else {
first_pos = position;
dist = 0;
}
prev_position = position;
2013-09-17 22:29:13 +00:00
node = xmlNewChild(bodies_node, NULL, BAD_CAST "body", NULL);
enum_value = g_enum_get_value(
G_ENUM_CLASS(planets_class),
gswe_planet_data_get_planet(planet_data)
);
xmlNewProp(node, BAD_CAST "name", BAD_CAST enum_value->value_nick);
2013-09-17 22:29:13 +00:00
value = g_malloc0(12);
2013-10-03 22:16:55 +00:00
g_ascii_dtostr(value, 12, gswe_planet_data_get_position(planet_data));
2013-09-17 22:29:13 +00:00
xmlNewProp(node, BAD_CAST "degree", BAD_CAST value);
g_free(value);
xmlNewProp(
node,
BAD_CAST "retrograde",
BAD_CAST (
gswe_planet_data_get_retrograde(planet_data)
? "True"
: "False"
)
);
value = g_strdup_printf("%d", dist);
xmlNewProp(node, BAD_CAST "dist", BAD_CAST value);
2013-09-17 22:29:13 +00:00
g_free(value);
}
2013-09-18 20:31:14 +00:00
// Begin <aspects> node
2013-09-19 17:56:25 +00:00
g_debug("Generating aspects table");
2013-09-18 20:31:14 +00:00
aspects_node = xmlNewChild(root_node, NULL, BAD_CAST "aspects", NULL);
aspects_class = g_type_class_ref(GSWE_TYPE_ASPECT);
for (
aspect = gswe_moment_get_all_aspects(GSWE_MOMENT(chart));
aspect;
aspect = g_list_next(aspect)
) {
2013-10-03 22:16:55 +00:00
GswePlanetData *planet_data;
2014-06-24 07:38:49 +00:00
GEnumValue *enum_value;
2013-09-18 20:31:14 +00:00
aspect_data = aspect->data;
2013-10-03 22:16:55 +00:00
if (gswe_aspect_data_get_aspect(aspect_data) == GSWE_ASPECT_NONE) {
2013-09-18 20:31:14 +00:00
continue;
}
node = xmlNewChild(aspects_node, NULL, BAD_CAST "aspect", NULL);
2013-10-03 22:16:55 +00:00
planet_data = gswe_aspect_data_get_planet1(aspect_data);
enum_value = g_enum_get_value(
G_ENUM_CLASS(planets_class),
gswe_planet_data_get_planet(planet_data)
);
xmlNewProp(node, BAD_CAST "body1", BAD_CAST enum_value->value_nick);
2013-09-18 20:31:14 +00:00
2013-10-03 22:16:55 +00:00
planet_data = gswe_aspect_data_get_planet2(aspect_data);
enum_value = g_enum_get_value(
G_ENUM_CLASS(planets_class),
gswe_planet_data_get_planet(planet_data)
);
xmlNewProp(node, BAD_CAST "body2", BAD_CAST enum_value->value_nick);
2013-09-18 20:31:14 +00:00
enum_value = g_enum_get_value(
G_ENUM_CLASS(aspects_class),
gswe_aspect_data_get_aspect(aspect_data)
);
2014-08-29 10:46:58 +00:00
xmlNewProp(node, BAD_CAST "type", BAD_CAST enum_value->value_nick);
2013-09-18 20:31:14 +00:00
}
g_type_class_unref(aspects_class);
// Begin <antiscia> node
2013-09-19 17:56:25 +00:00
g_debug("Generating antiscia table");
antiscia_node = xmlNewChild(root_node, NULL, BAD_CAST "antiscia", NULL);
2013-09-18 20:31:14 +00:00
antiscia_class = g_type_class_ref(GSWE_TYPE_ANTISCION_AXIS);
for (
antiscion = gswe_moment_get_all_antiscia(GSWE_MOMENT(chart));
antiscion;
antiscion = g_list_next(antiscion)
) {
2014-06-24 07:38:49 +00:00
GswePlanetData *planet_data;
2013-09-18 20:31:14 +00:00
GsweAntiscionData *antiscion_data = antiscion->data;
GEnumValue *enum_value;
2013-09-18 20:31:14 +00:00
if (gswe_antiscion_data_get_axis(
antiscion_data) == GSWE_ANTISCION_AXIS_NONE
) {
2013-09-18 20:31:14 +00:00
continue;
}
node = xmlNewChild(antiscia_node, NULL, BAD_CAST "antiscia", NULL);
2013-10-03 22:16:55 +00:00
planet_data = gswe_antiscion_data_get_planet1(antiscion_data);
enum_value = g_enum_get_value(
G_ENUM_CLASS(planets_class),
gswe_planet_data_get_planet(planet_data)
);
xmlNewProp(node, BAD_CAST "body1", BAD_CAST enum_value->value_nick);
2013-09-18 20:31:14 +00:00
2013-10-03 22:16:55 +00:00
planet_data = gswe_antiscion_data_get_planet2(antiscion_data);
enum_value = g_enum_get_value(
G_ENUM_CLASS(planets_class),
gswe_planet_data_get_planet(planet_data)
);
xmlNewProp(node, BAD_CAST "body2", BAD_CAST enum_value->value_nick);
2013-09-18 20:31:14 +00:00
enum_value = g_enum_get_value(
G_ENUM_CLASS(antiscia_class),
gswe_antiscion_data_get_axis(antiscion_data)
);
xmlNewProp(node, BAD_CAST "axis", BAD_CAST enum_value->value_nick);
2013-09-18 20:31:14 +00:00
}
g_type_class_unref(planets_class);
2013-09-19 17:56:25 +00:00
// Now, doc contains the generated XML tree
xslt_data = g_resources_lookup_data(
"/eu/polonkai/gergely/Astrognome/ui/chart-default.xsl",
G_RESOURCE_LOOKUP_FLAGS_NONE,
NULL
);
xslt_content = g_bytes_get_data(xslt_data, &xslt_length);
if ((xslt_doc = xmlReadMemory(
xslt_content,
xslt_length,
"file://" PKGDATADIR "/astrognome",
"UTF-8",
0
)) == NULL) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"Built in style sheet can not be parsed as a stylesheet file."
);
2013-09-19 17:56:25 +00:00
xmlFreeDoc(doc);
return NULL;
}
2013-09-20 07:58:31 +00:00
#if LIBXML_VERSION >= 20603
xmlXIncludeProcessFlags(xslt_doc, XSLT_PARSE_OPTIONS);
#else
xmlXIncludeProcess(xslt_doc);
#endif
2013-09-19 17:56:25 +00:00
if ((xslt_proc = xsltParseStylesheetDoc(xslt_doc)) == NULL) {
g_set_error(
err,
AG_CHART_ERROR, AG_CHART_ERROR_CORRUPT_FILE,
"Built in style sheet can not be parsed as a stylesheet file."
);
2013-09-19 17:56:25 +00:00
xmlFreeDoc(xslt_doc);
xmlFreeDoc(doc);
return NULL;
}
params = g_new0(gchar *, 3);
params[0] = "rendering";
params[1] = (rendering) ? "'yes'" : "'no'";
// libxml2 messes up the output, as it prints decimal floating point
// numbers in a localized format. It is not good in locales that use a
// character for decimal separator other than a dot. So let's just use the
// C locale until the SVG is generated.
current_locale = uselocale(newlocale(LC_ALL, "C", 0));
svg_doc = xsltApplyStylesheet(xslt_proc, doc, (const char **)params);
uselocale(current_locale);
2013-09-19 17:56:25 +00:00
xsltFreeStylesheet(xslt_proc);
2013-09-17 22:29:13 +00:00
xmlFreeDoc(doc);
g_free(params);
2013-09-19 17:56:25 +00:00
// Now, svg_doc contains the generated SVG file
xmlDocDumpFormatMemoryEnc(
svg_doc,
(xmlChar **)&save_content,
&save_length,
"UTF-8",
1
);
2013-09-19 17:56:25 +00:00
xmlFreeDoc(svg_doc);
if (length != NULL) {
*length = save_length;
}
2013-09-19 17:56:25 +00:00
return save_content;
2013-09-17 22:29:13 +00:00
}
2014-06-15 08:00:07 +00:00
GList *
ag_chart_get_planets(AgChart *chart)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
return priv->planet_list;
2014-06-15 08:00:07 +00:00
}
2014-06-27 14:52:52 +00:00
void
ag_chart_export_svg_to_file(AgChart *chart, GFile *file, GError **err)
{
gchar *svg;
gsize length;
if ((svg = ag_chart_create_svg(chart, &length, TRUE, err)) == NULL) {
2014-06-27 14:52:52 +00:00
return;
}
g_file_replace_contents(
file,
(const gchar *)svg,
length,
NULL,
FALSE,
G_FILE_CREATE_NONE,
NULL,
NULL,
err
);
2014-06-27 14:52:52 +00:00
}
void
ag_chart_set_note(AgChart *chart, const gchar *note)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
priv->note = g_strdup(note);
2014-08-11 11:21:26 +00:00
g_object_notify_by_pspec(G_OBJECT(chart), properties[PROP_NOTE]);
}
const gchar *
ag_chart_get_note(AgChart *chart)
{
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
return priv->note;
}
AgDbChartSave *
ag_chart_get_db_save(AgChart *chart, gint db_id)
{
GsweCoordinates *coords;
AgChartPrivate *priv = ag_chart_get_instance_private(chart);
AgDbChartSave *save_data = g_new0(AgDbChartSave, 1);
GsweTimestamp *timestamp = gswe_moment_get_timestamp(GSWE_MOMENT(chart));
GEnumClass *house_system_class;
GEnumValue *house_system_enum;
save_data->db_id = db_id;
save_data->name = g_strdup(priv->name);
save_data->country = g_strdup(priv->country);
save_data->city = g_strdup(priv->city);
coords = gswe_moment_get_coordinates(GSWE_MOMENT(chart));
save_data->longitude = coords->longitude;
save_data->latitude = coords->latitude;
save_data->altitude = coords->altitude;
g_free(coords);
save_data->year = gswe_timestamp_get_gregorian_year(
timestamp,
NULL
);
save_data->month = gswe_timestamp_get_gregorian_month(
timestamp,
NULL
);
save_data->day = gswe_timestamp_get_gregorian_day(timestamp, NULL);
save_data->hour = gswe_timestamp_get_gregorian_hour(
timestamp,
NULL
);
save_data->minute = gswe_timestamp_get_gregorian_minute(
timestamp,
NULL
);
save_data->second = gswe_timestamp_get_gregorian_second(
timestamp,
NULL
);
save_data->timezone = gswe_timestamp_get_gregorian_timezone(timestamp);
house_system_class = g_type_class_ref(GSWE_TYPE_HOUSE_SYSTEM);
house_system_enum = g_enum_get_value(
house_system_class,
gswe_moment_get_house_system(GSWE_MOMENT(chart))
);
save_data->house_system = g_strdup(house_system_enum->value_nick);
g_type_class_unref(house_system_class);
save_data->note = g_strdup(priv->note);
return save_data;
}