path: root/siv.c

#include <gtk/gtk.h>
#include <glade/glade.h>
#include <glib/gprintf.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "siv.h"

#define _(a) a

struct App
{
    int n_windows;

    GHashTable *meta_data;
}; 

void
app_show_warning (GtkWidget *parent_window,
		  const gchar *secondary,
		  const gchar *format,
		  ...)
{
    va_list args;
    char *message;
    GtkWidget *dialog;
    
    va_start (args, format);
    g_vasprintf (&message, format, args);
    va_end (args);
    
    dialog = gtk_message_dialog_new_with_markup (
	parent_window ? GTK_WINDOW (parent_window) : NULL,
	GTK_DIALOG_DESTROY_WITH_PARENT,
	GTK_MESSAGE_WARNING,
	GTK_BUTTONS_OK, message);

    if (secondary)
    {
	gtk_message_dialog_format_secondary_markup (
	    dialog, "%s", secondary);
    }
    
    g_free (message);
    
    gtk_window_set_title (GTK_WINDOW (dialog), APPLICATION_NAME " Warning");
    
    gtk_dialog_run (GTK_DIALOG (dialog));
    gtk_widget_destroy (dialog);
}

void
app_show_could_not_open (GtkWidget  *parent_window,
			 int	     n_files,
			 gchar     **files)
{
    const char *header = NULL;
    GString *text;
    int i;
    
    if (n_files == 0)
    {
	return;
    }
    else if (n_files == 1)
    {
	header = "<b>Could not open this file:</b>";
    }
    else
    {
	header = "<b>Could not open these files:</b>";
    }

    text = g_string_new (header);
    
    for (i = 0; i < n_files; ++i)
	g_string_append_printf (text, "\n%s", files[i]);
    
    app_show_warning (NULL, NULL, "%s", text->str);

    g_string_free (text, TRUE);
}

void
app_register_window (App *app, SivWindow *window)
{
    ++app->n_windows;
}

void
app_unregister_window (App *app, SivWindow *window)
{
    if (--app->n_windows == 0)
	gtk_main_quit ();
}

static gchar *
encode (const char *filename)
{
    GString *result = g_string_new (NULL);
    int i;

    for (i = 0; filename[i] != '\0'; ++i)
    {
	char c = filename[i];
	
	if (!g_ascii_isprint (c) || c == '@' || c == '[' || c == ']')
	    g_string_append_printf (result, "@%x", c);
	else
	    g_string_append_c (result, c);
    }

    return g_string_free (result, FALSE);
}

MetaData *
app_get_meta_data (App            *app,
		   const char     *file)
{
    char *encoded = encode (file);
    MetaData *data = g_hash_table_lookup (app->meta_data, encoded);

    g_free (encoded);

    return data;
}

static gchar *
make_filename (void)
{
    return g_build_filename (
	g_get_home_dir(), ".gnome2", "siv.metadata", NULL);
}

static void
foreach (gpointer key, gpointer value, gpointer user_data)
{
    gchar *filename = key;
    MetaData *meta = value;
    GKeyFile *key_file = user_data;

    g_key_file_set_integer (key_file, filename, "window_x", meta->window_x);
    g_key_file_set_integer (key_file, filename, "window_y", meta->window_y);
    g_key_file_set_integer (key_file, filename, "window_width", meta->window_width);
    g_key_file_set_integer (key_file, filename, "window_height", meta->window_height);
    g_key_file_set_integer (key_file, filename, "background", meta->background);
    g_key_file_set_integer (key_file, filename, "smooth_image", meta->smooth_image);
    g_key_file_set_integer (key_file, filename, "zoom_level", meta->zoom_level);
    g_key_file_set_integer (key_file, filename, "hadj", meta->hadj);
    g_key_file_set_integer (key_file, filename, "vadj", meta->vadj);
}

void
app_set_meta_data (App            *app,
		   const char     *filename,
		   int             window_x,
		   int             window_y,
		   int             window_width,
		   int             window_height,
		   gboolean        smooth_image,
		   BackgroundType  background,
		   int             zoom_level,
		   int             vadj,
		   int             hadj)
{
    GKeyFile *keyfile = g_key_file_new ();
    char *encoded = encode (filename);
    MetaData *data = g_hash_table_lookup (app->meta_data, encoded);
    char *key_filename = make_filename();
    char *output;

    if (!data)
    {
	data = g_new0 (MetaData, 1);

	g_hash_table_insert (app->meta_data, g_strdup (encoded), data);
    }

    data->window_x = window_x;
    data->window_y = window_y;
    data->window_width = window_width;
    data->window_height = window_height;
    data->background = background;
    data->smooth_image = smooth_image;
    data->zoom_level = zoom_level;
    data->hadj = hadj;
    data->vadj = vadj;

    g_hash_table_foreach (app->meta_data, foreach, keyfile);

    output = g_key_file_to_data (keyfile, NULL, NULL);
    if (output)
    {
	g_file_set_contents (key_filename, output, -1, NULL);
	g_free (output);
    }

    g_key_file_free (keyfile);
    g_free (key_filename);
    g_free (encoded);
}


static gboolean
get_int (GKeyFile *keyfile, const char *group, const char *key, int *result)
{
    GError *err = NULL;
    int d;

    d = g_key_file_get_integer (keyfile, group, key, &err);

    if (err)
    {
	g_error_free (err);
	return FALSE;
    }

    if (result)
	*result = d;

    return TRUE;
}

static GHashTable *
load_meta_data (void)
{
    GKeyFile *keyfile;
    char *filename;
    GHashTable *result;

    keyfile = g_key_file_new ();
    filename = make_filename();

    result = g_hash_table_new (g_str_hash, g_str_equal);
    
    if (g_key_file_load_from_file (keyfile, filename, G_KEY_FILE_NONE, NULL))
    {
	gsize n_groups;
	char **groups = g_key_file_get_groups (keyfile, &n_groups);
	int i;

	for (i = 0; i < n_groups; ++i)
	{
	    MetaData *data = g_new0 (MetaData, 1);
	    char *group = groups[i];
	    int b;
	    
	    if (!get_int (keyfile, group, "window_x", &(data->window_x)))
		data->window_x = 0;
	    
	    if (!get_int (keyfile, group, "window_y", &(data->window_y)))
		data->window_y = 0;
	    
	    if (!get_int (keyfile, group, "window_width", &(data->window_width)))
		data->window_width = 0;
	    
	    if (!get_int (keyfile, group, "window_height", &(data->window_height)))
		data->window_height = 0;
	    
	    if (!get_int (keyfile, group, "background", &b))
		data->background = BG_NONE;
	    else
		data->background = b;
	    
	    if (data->background >= BG_LAST || data->background < BG_FIRST)
		data->background = BG_NONE;
	    
	    if (!get_int (keyfile, group, "smooth_image", &(data->smooth_image)))
		data->smooth_image = TRUE;
	    
	    if (!get_int (keyfile, group, "zoom_level", &(data->zoom_level)))
		data->zoom_level = 0;

	    if (!get_int (keyfile, group, "vadj", &(data->vadj)))
		data->vadj = 0;

	    if (!get_int (keyfile, group, "hadj", &(data->hadj)))
		data->hadj = 0;
	    
	    g_hash_table_insert (result, g_strdup (group), data);
	}
	
	g_strfreev (groups);
    }

    g_free (filename);    
    g_key_file_free (keyfile);
    
    return result;
}

static void
app_new (int argc, char **argv)
{
    GList *filenames = NULL;
    GList *list;
    App *app;
    int i;
    GPtrArray *err_files = g_ptr_array_new ();

    for (i = 1; i < argc; ++i)
    {
	char *option = argv[i];
	char *name;

	if (strcmp (option, "--version") == 0	||
	    strcmp (option, "-v") == 0)
	{
	    g_print ("%s %s\n", APPLICATION_NAME, PACKAGE_VERSION);
	    
	    exit (1);
	    return;
	}

	if (g_path_is_absolute (option))
	{
	    name = g_strdup (option);
	}
	else
	{
	    name = g_build_filename (g_get_current_dir(), option, NULL);
	}

	filenames = g_list_prepend (filenames, name);
    }

    app = g_new0 (App, 1);
	
    filenames = g_list_reverse (filenames);
    
    app->meta_data = load_meta_data ();

    /* When a window is created, it increases the app->n_windows counter;
     * when it is destroyed it decreases it. The problem is if the first
     * window fails to load the file, it will cause the counter to reach
     * zero, which will cause the application to exit.
     *
     * So set it to 1 here and decrement it after loading all the files to
     * prevent that from happening.
     */
    app->n_windows = 1;
    
    if (filenames)
    {
	int i;

	i = 0;
	for (list = filenames; list != NULL; list = list->next)
	{
	    SivWindow *window;
	    GError *err = NULL;
	    char *filename = list->data;

	    /* Don't open more than 32 windows */
	    if (++i > 32)
		break;
	    
	    window = window_new (app);
	    
	    if (!window_load_file (window, list->data, &err))
	    {
		g_ptr_array_add (err_files, g_strdup (filename));
		g_error_free (err);
		
		window_free (window);
	    }
	    else
	    {
		window_show (window, GDK_CURRENT_TIME);
	    }
	}

	for (list = filenames; list != NULL; list = list->next)
	    g_free (list->data);
	
	g_list_free (filenames);
    }
    else
    {
	window_show (window_new (app), GDK_CURRENT_TIME);
    }

    app_show_could_not_open (NULL, err_files->len, (char **)err_files->pdata);

    g_ptr_array_foreach (err_files, (GFunc)g_free, NULL);
    g_ptr_array_free (err_files, TRUE);

    if (app->n_windows == 1)
	exit (1);
    else
	--app->n_windows;
}

int
main (int    argc,
      char **argv)
{
    /* Disable gslice, since it
     *
     *  - confuses valgrind
     *  - caches too much memory
     *  - hides memory access bugs
     *  - is not faster than malloc
     *
     * Note that g_slice_set_config() is broken in some versions of
     * GLib (and 'declared internal' according to Tim), so we use the
     * environment variable instead.
     */
    if (!getenv ("G_SLICE"))
	putenv ("G_SLICE=always_malloc");
    
    gtk_init (&argc, &argv);

    if (!g_file_test (GLADE_FILE, G_FILE_TEST_EXISTS))
    {
	app_show_warning (
	    NULL,
	    "<i>Running \"make install\" may solve this problem.</i>",
	    "<b>"APPLICATION_NAME
	    " was not compiled or installed correctly.</b>");
	
	return FALSE;
    }

    app_new (argc, argv);

    gtk_main ();
    
    return 0;
}