xed/pluma/pluma-app.c

/*
 * pluma-app.c
 * This file is part of pluma
 *
 * Copyright (C) 2005-2006 - Paolo Maggi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Modified by the pluma Team, 2005. See the AUTHORS file for a
 * list of people on the pluma Team.
 * See the ChangeLog files for a list of changes.
 *
 * $Id$
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>
#include <unistd.h>

#include <glib/gi18n.h>

#include "pluma-app.h"
#include "pluma-prefs-manager-app.h"
#include "pluma-commands.h"
#include "pluma-notebook.h"
#include "pluma-debug.h"
#include "pluma-utils.h"
#include "pluma-enum-types.h"
#include "pluma-dirs.h"

#ifdef OS_OSX
#include <ige-mac-integration.h>
#endif

#define PLUMA_PAGE_SETUP_FILE		"pluma-page-setup"
#define PLUMA_PRINT_SETTINGS_FILE	"pluma-print-settings"

#define PLUMA_APP_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), PLUMA_TYPE_APP, PlumaAppPrivate))

/* Properties */
enum
{
	PROP_0,
	PROP_LOCKDOWN
};

struct _PlumaAppPrivate
{
	GList	          *windows;
	PlumaWindow       *active_window;

	PlumaLockdownMask  lockdown;

	GtkPageSetup      *page_setup;
	GtkPrintSettings  *print_settings;
};

G_DEFINE_TYPE(PlumaApp, pluma_app, G_TYPE_OBJECT)

static void
pluma_app_finalize (GObject *object)
{
	PlumaApp *app = PLUMA_APP (object);

	g_list_free (app->priv->windows);

	if (app->priv->page_setup)
		g_object_unref (app->priv->page_setup);
	if (app->priv->print_settings)
		g_object_unref (app->priv->print_settings);

	G_OBJECT_CLASS (pluma_app_parent_class)->finalize (object);
}

static void
pluma_app_get_property (GObject    *object,
			guint       prop_id,
			GValue     *value,
			GParamSpec *pspec)
{
	PlumaApp *app = PLUMA_APP (object);

	switch (prop_id)
	{
		case PROP_LOCKDOWN:
			g_value_set_flags (value, pluma_app_get_lockdown (app));
			break;
		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
			break;
	}
}

static void
pluma_app_class_init (PlumaAppClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	object_class->finalize = pluma_app_finalize;
	object_class->get_property = pluma_app_get_property;

	g_object_class_install_property (object_class,
					 PROP_LOCKDOWN,
					 g_param_spec_flags ("lockdown",
							     "Lockdown",
							     "The lockdown mask",
							     PLUMA_TYPE_LOCKDOWN_MASK,
							     0,
							     G_PARAM_READABLE |
							     G_PARAM_STATIC_STRINGS));

	g_type_class_add_private (object_class, sizeof(PlumaAppPrivate));
}

static gboolean
ensure_user_config_dir (void)
{
	gchar *config_dir;
	gboolean ret = TRUE;
	gint res;

	config_dir = pluma_dirs_get_user_config_dir ();
	if (config_dir == NULL)
	{
		g_warning ("Could not get config directory\n");
		return FALSE;
	}

	res = g_mkdir_with_parents (config_dir, 0755);
	if (res < 0)
	{
		g_warning ("Could not create config directory\n");
		ret = FALSE;
	}

	g_free (config_dir);

	return ret;
}

static void
load_accels (void)
{
	gchar *filename;

	filename = pluma_dirs_get_user_accels_file ();
	if (filename != NULL)
	{
		pluma_debug_message (DEBUG_APP, "Loading keybindings from %s\n", filename);
		gtk_accel_map_load (filename);
		g_free (filename);
	}
}

static void
save_accels (void)
{
	gchar *filename;

	filename = pluma_dirs_get_user_accels_file ();
	if (filename != NULL)
	{
		pluma_debug_message (DEBUG_APP, "Saving keybindings in %s\n", filename);
		gtk_accel_map_save (filename);
		g_free (filename);
	}
}

static gchar *
get_page_setup_file (void)
{
	gchar *config_dir;
	gchar *setup = NULL;

	config_dir = pluma_dirs_get_user_config_dir ();

	if (config_dir != NULL)
	{
		setup = g_build_filename (config_dir,
					  PLUMA_PAGE_SETUP_FILE,
					  NULL);
		g_free (config_dir);
	}

	return setup;
}

static void
load_page_setup (PlumaApp *app)
{
	gchar *filename;
	GError *error = NULL;

	g_return_if_fail (app->priv->page_setup == NULL);

	filename = get_page_setup_file ();

	app->priv->page_setup = gtk_page_setup_new_from_file (filename,
							      &error);
	if (error)
	{
		/* Ignore file not found error */
		if (error->domain != G_FILE_ERROR ||
		    error->code != G_FILE_ERROR_NOENT)
		{
			g_warning ("%s", error->message);
		}

		g_error_free (error);
	}

	g_free (filename);

	/* fall back to default settings */
	if (app->priv->page_setup == NULL)
		app->priv->page_setup = gtk_page_setup_new ();
}

static void
save_page_setup (PlumaApp *app)
{
	gchar *filename;
	GError *error = NULL;

	if (app->priv->page_setup == NULL)
		return;

	filename = get_page_setup_file ();

	gtk_page_setup_to_file (app->priv->page_setup,
				filename,
				&error);
	if (error)
	{
		g_warning ("%s", error->message);
		g_error_free (error);
	}

	g_free (filename);
}

static gchar *
get_print_settings_file (void)
{
	gchar *config_dir;
	gchar *settings = NULL;

	config_dir = pluma_dirs_get_user_config_dir ();

	if (config_dir != NULL)
	{
		settings = g_build_filename (config_dir,
					     PLUMA_PRINT_SETTINGS_FILE,
					     NULL);
		g_free (config_dir);
	}

	return settings;
}

static void
load_print_settings (PlumaApp *app)
{
	gchar *filename;
	GError *error = NULL;

	g_return_if_fail (app->priv->print_settings == NULL);

	filename = get_print_settings_file ();

	app->priv->print_settings = gtk_print_settings_new_from_file (filename,
								      &error);
	if (error)
	{
		/* Ignore file not found error */
		if (error->domain != G_FILE_ERROR ||
		    error->code != G_FILE_ERROR_NOENT)
		{
			g_warning ("%s", error->message);
		}

		g_error_free (error);
	}

	g_free (filename);

	/* fall back to default settings */
	if (app->priv->print_settings == NULL)
		app->priv->print_settings = gtk_print_settings_new ();
}

static void
save_print_settings (PlumaApp *app)
{
	gchar *filename;
	GError *error = NULL;

	if (app->priv->print_settings == NULL)
		return;

	filename = get_print_settings_file ();

	gtk_print_settings_to_file (app->priv->print_settings,
				    filename,
				    &error);
	if (error)
	{
		g_warning ("%s", error->message);
		g_error_free (error);
	}

	g_free (filename);
}

static void
pluma_app_init (PlumaApp *app)
{
	app->priv = PLUMA_APP_GET_PRIVATE (app);

	load_accels ();

	/* initial lockdown state */
	app->priv->lockdown = pluma_prefs_manager_get_lockdown ();
}

static void
app_weak_notify (gpointer data,
		 GObject *where_the_app_was)
{
	gtk_main_quit ();
}

/**
 * pluma_app_get_default:
 *
 * Returns the #PlumaApp object. This object is a singleton and
 * represents the running pluma instance.
 *
 * Return value: the #PlumaApp pointer
 */
PlumaApp *
pluma_app_get_default (void)
{
	static PlumaApp *app = NULL;

	if (app != NULL)
		return app;

	app = PLUMA_APP (g_object_new (PLUMA_TYPE_APP, NULL));

	g_object_add_weak_pointer (G_OBJECT (app),
				   (gpointer) &app);
	g_object_weak_ref (G_OBJECT (app),
			   app_weak_notify,
			   NULL);

	return app;
}

static void
set_active_window (PlumaApp    *app,
                   PlumaWindow *window)
{
	app->priv->active_window = window;
}

static gboolean
window_focus_in_event (PlumaWindow   *window,
		       GdkEventFocus *event,
		       PlumaApp      *app)
{
	/* updates active_view and active_child when a new toplevel receives focus */
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), FALSE);

	set_active_window (app, window);

	return FALSE;
}

static gboolean
window_delete_event (PlumaWindow *window,
                     GdkEvent    *event,
                     PlumaApp    *app)
{
	PlumaWindowState ws;

	ws = pluma_window_get_state (window);

	if (ws &
	    (PLUMA_WINDOW_STATE_SAVING |
	     PLUMA_WINDOW_STATE_PRINTING |
	     PLUMA_WINDOW_STATE_SAVING_SESSION))
	    	return TRUE;

	_pluma_cmd_file_quit (NULL, window);

	/* Do not destroy the window */
	return TRUE;
}

static void
window_destroy (PlumaWindow *window,
		PlumaApp    *app)
{
	app->priv->windows = g_list_remove (app->priv->windows,
					    window);

	if (window == app->priv->active_window)
	{
		set_active_window (app, app->priv->windows != NULL ? app->priv->windows->data : NULL);
	}

/* CHECK: I don't think we have to disconnect this function, since windows
   is being destroyed */
/*
	g_signal_handlers_disconnect_by_func (window,
					      G_CALLBACK (window_focus_in_event),
					      app);
	g_signal_handlers_disconnect_by_func (window,
					      G_CALLBACK (window_destroy),
					      app);
*/
	if (app->priv->windows == NULL)
	{
#ifdef OS_OSX
		if (!GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "pluma-is-quitting-all")))
		{
			/* Create hidden proxy window on OS X to handle the menu */
			pluma_app_create_window (app, NULL);
			return;
		}
#endif
		/* Last window is gone... save some settings and exit */
		ensure_user_config_dir ();

		save_accels ();
		save_page_setup (app);
		save_print_settings (app);

		g_object_unref (app);
	}
}

/* Generates a unique string for a window role */
static gchar *
gen_role (void)
{
	GTimeVal result;
	static gint serial;

	g_get_current_time (&result);

	return g_strdup_printf ("pluma-window-%ld-%ld-%d-%s",
				result.tv_sec,
				result.tv_usec,
				serial++,
				g_get_host_name ());
}

static PlumaWindow *
pluma_app_create_window_real (PlumaApp    *app,
			      gboolean     set_geometry,
			      const gchar *role)
{
	PlumaWindow *window;

	pluma_debug (DEBUG_APP);

	/*
	 * We need to be careful here, there is a race condition:
	 * when another pluma is launched it checks active_window,
	 * so we must do our best to ensure that active_window
	 * is never NULL when at least a window exists.
	 */
	if (app->priv->windows == NULL)
	{
		window = g_object_new (PLUMA_TYPE_WINDOW, NULL);
		set_active_window (app, window);
	}
	else
	{
		window = g_object_new (PLUMA_TYPE_WINDOW, NULL);
	}

	app->priv->windows = g_list_prepend (app->priv->windows,
					     window);

	pluma_debug_message (DEBUG_APP, "Window created");

	if (role != NULL)
	{
		gtk_window_set_role (GTK_WINDOW (window), role);
	}
	else
	{
		gchar *newrole;

		newrole = gen_role ();
		gtk_window_set_role (GTK_WINDOW (window), newrole);
		g_free (newrole);
	}

	if (set_geometry)
	{
		GdkWindowState state;
		gint w, h;

		state = pluma_prefs_manager_get_window_state ();

		if ((state & GDK_WINDOW_STATE_MAXIMIZED) != 0)
		{
			pluma_prefs_manager_get_default_window_size (&w, &h);
			gtk_window_set_default_size (GTK_WINDOW (window), w, h);
			gtk_window_maximize (GTK_WINDOW (window));
		}
		else
		{
			pluma_prefs_manager_get_window_size (&w, &h);
			gtk_window_set_default_size (GTK_WINDOW (window), w, h);
			gtk_window_unmaximize (GTK_WINDOW (window));
		}

		if ((state & GDK_WINDOW_STATE_STICKY ) != 0)
			gtk_window_stick (GTK_WINDOW (window));
		else
			gtk_window_unstick (GTK_WINDOW (window));
	}

	g_signal_connect (window,
			  "focus_in_event",
			  G_CALLBACK (window_focus_in_event),
			  app);
	g_signal_connect (window,
			  "delete_event",
			  G_CALLBACK (window_delete_event),
			  app);
	g_signal_connect (window,
			  "destroy",
			  G_CALLBACK (window_destroy),
			  app);

	return window;
}

/**
 * pluma_app_create_window:
 * @app: the #PlumaApp
 *
 * Create a new #PlumaWindow part of @app.
 *
 * Return value: the new #PlumaWindow
 */
PlumaWindow *
pluma_app_create_window (PlumaApp  *app,
			 GdkScreen *screen)
{
	PlumaWindow *window;

	window = pluma_app_create_window_real (app, TRUE, NULL);

	if (screen != NULL)
		gtk_window_set_screen (GTK_WINDOW (window), screen);

	return window;
}

/*
 * Same as _create_window, but doesn't set the geometry.
 * The session manager takes care of it. Used in mate-session.
 */
PlumaWindow *
_pluma_app_restore_window (PlumaApp    *app,
			   const gchar *role)
{
	PlumaWindow *window;

	window = pluma_app_create_window_real (app, FALSE, role);

	return window;
}

/**
 * pluma_app_get_windows:
 * @app: the #PlumaApp
 *
 * Returns all the windows currently present in #PlumaApp.
 *
 * Return value: the list of #PlumaWindows objects. The list
 * should not be freed
 */
const GList *
pluma_app_get_windows (PlumaApp *app)
{
	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	return app->priv->windows;
}

/**
 * pluma_app_get_active_window:
 * @app: the #PlumaApp
 *
 * Retrives the #PlumaWindow currently active.
 *
 * Return value: the active #PlumaWindow
 */
PlumaWindow *
pluma_app_get_active_window (PlumaApp *app)
{
	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	/* make sure our active window is always realized:
	 * this is needed on startup if we launch two pluma fast
	 * enough that the second instance comes up before the
	 * first one shows its window.
	 */
	if (!GTK_WIDGET_REALIZED (GTK_WIDGET (app->priv->active_window)))
		gtk_widget_realize (GTK_WIDGET (app->priv->active_window));

	return app->priv->active_window;
}

static gboolean
is_in_viewport (PlumaWindow  *window,
		GdkScreen    *screen,
		gint          workspace,
		gint          viewport_x,
		gint          viewport_y)
{
	GdkScreen *s;
	GdkDisplay *display;
	GdkWindow *gdkwindow;
	const gchar *cur_name;
	const gchar *name;
	gint cur_n;
	gint n;
	gint ws;
	gint sc_width, sc_height;
	gint x, y, width, height;
	gint vp_x, vp_y;

	/* Check for screen and display match */
	display = gdk_screen_get_display (screen);
	cur_name = gdk_display_get_name (display);
	cur_n = gdk_screen_get_number (screen);

	s = gtk_window_get_screen (GTK_WINDOW (window));
	display = gdk_screen_get_display (s);
	name = gdk_display_get_name (display);
	n = gdk_screen_get_number (s);

	if (strcmp (cur_name, name) != 0 || cur_n != n)
		return FALSE;

	/* Check for workspace match */
	ws = pluma_utils_get_window_workspace (GTK_WINDOW (window));
	if (ws != workspace && ws != PLUMA_ALL_WORKSPACES)
		return FALSE;

	/* Check for viewport match */
	gdkwindow = gtk_widget_get_window (GTK_WIDGET (window));
	gdk_window_get_position (gdkwindow, &x, &y);

	#if GTK_CHECK_VERSION(3, 0, 0)
		width = gdk_window_get_width(gdkwindow);
		height = gdk_window_get_height(gdkwindow);
	#else
		gdk_drawable_get_size(gdkwindow, &width, &height);
	#endif

	pluma_utils_get_current_viewport (screen, &vp_x, &vp_y);
	x += vp_x;
	y += vp_y;

	sc_width = gdk_screen_get_width (screen);
	sc_height = gdk_screen_get_height (screen);

	return x + width * .25 >= viewport_x &&
	       x + width * .75 <= viewport_x + sc_width &&
	       y  >= viewport_y &&
	       y + height <= viewport_y + sc_height;
}

/**
 * _pluma_app_get_window_in_viewport
 * @app: the #PlumaApp
 * @screen: the #GdkScreen
 * @workspace: the workspace number
 * @viewport_x: the viewport horizontal origin
 * @viewport_y: the viewport vertical origin
 *
 * Since a workspace can be larger than the screen, it is divided into several
 * equal parts called viewports. This function retrives the #PlumaWindow in
 * the given viewport of the given workspace.
 *
 * Return value: the #PlumaWindow in the given viewport of the given workspace.
 */
PlumaWindow *
_pluma_app_get_window_in_viewport (PlumaApp  *app,
				   GdkScreen *screen,
				   gint       workspace,
				   gint       viewport_x,
				   gint       viewport_y)
{
	PlumaWindow *window;

	GList *l;

	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	/* first try if the active window */
	window = app->priv->active_window;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	if (is_in_viewport (window, screen, workspace, viewport_x, viewport_y))
		return window;

	/* otherwise try to see if there is a window on this workspace */
	for (l = app->priv->windows; l != NULL; l = l->next)
	{
		window = l->data;

		if (is_in_viewport (window, screen, workspace, viewport_x, viewport_y))
			return window;
	}

	/* no window on this workspace... create a new one */
	return pluma_app_create_window (app, screen);
}

/**
 * pluma_app_get_documents:
 * @app: the #PlumaApp
 *
 * Returns all the documents currently open in #PlumaApp.
 *
 * Return value: a newly allocated list of #PlumaDocument objects
 */
GList *
pluma_app_get_documents	(PlumaApp *app)
{
	GList *res = NULL;
	GList *windows;

	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	windows = app->priv->windows;

	while (windows != NULL)
	{
		res = g_list_concat (res,
				     pluma_window_get_documents (PLUMA_WINDOW (windows->data)));

		windows = g_list_next (windows);
	}

	return res;
}

/**
 * pluma_app_get_views:
 * @app: the #PlumaApp
 *
 * Returns all the views currently present in #PlumaApp.
 *
 * Return value: a newly allocated list of #PlumaView objects
 */
GList *
pluma_app_get_views (PlumaApp *app)
{
	GList *res = NULL;
	GList *windows;

	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	windows = app->priv->windows;

	while (windows != NULL)
	{
		res = g_list_concat (res,
				     pluma_window_get_views (PLUMA_WINDOW (windows->data)));

		windows = g_list_next (windows);
	}

	return res;
}

/**
 * pluma_app_get_lockdown:
 * @app: a #PlumaApp
 *
 * Gets the lockdown mask (see #PlumaLockdownMask) for the application.
 * The lockdown mask determines which functions are locked down using
 * the MATE-wise lockdown MateConf keys.
 **/
PlumaLockdownMask
pluma_app_get_lockdown (PlumaApp *app)
{
	g_return_val_if_fail (PLUMA_IS_APP (app), PLUMA_LOCKDOWN_ALL);

	return app->priv->lockdown;
}

static void
app_lockdown_changed (PlumaApp *app)
{
	GList *l;

	for (l = app->priv->windows; l != NULL; l = l->next)
		_pluma_window_set_lockdown (PLUMA_WINDOW (l->data),
					    app->priv->lockdown);

	g_object_notify (G_OBJECT (app), "lockdown");
}

void
_pluma_app_set_lockdown (PlumaApp          *app,
			 PlumaLockdownMask  lockdown)
{
	g_return_if_fail (PLUMA_IS_APP (app));

	app->priv->lockdown = lockdown;

	app_lockdown_changed (app);
}

void
_pluma_app_set_lockdown_bit (PlumaApp          *app,
			     PlumaLockdownMask  bit,
			     gboolean           value)
{
	g_return_if_fail (PLUMA_IS_APP (app));

	if (value)
		app->priv->lockdown |= bit;
	else
		app->priv->lockdown &= ~bit;

	app_lockdown_changed (app);
}

/* Returns a copy */
GtkPageSetup *
_pluma_app_get_default_page_setup (PlumaApp *app)
{
	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	if (app->priv->page_setup == NULL)
		load_page_setup (app);

	return gtk_page_setup_copy (app->priv->page_setup);
}

void
_pluma_app_set_default_page_setup (PlumaApp     *app,
				   GtkPageSetup *page_setup)
{
	g_return_if_fail (PLUMA_IS_APP (app));
	g_return_if_fail (GTK_IS_PAGE_SETUP (page_setup));

	if (app->priv->page_setup != NULL)
		g_object_unref (app->priv->page_setup);

	app->priv->page_setup = g_object_ref (page_setup);
}

/* Returns a copy */
GtkPrintSettings *
_pluma_app_get_default_print_settings (PlumaApp *app)
{
	g_return_val_if_fail (PLUMA_IS_APP (app), NULL);

	if (app->priv->print_settings == NULL)
		load_print_settings (app);

	return gtk_print_settings_copy (app->priv->print_settings);
}

void
_pluma_app_set_default_print_settings (PlumaApp         *app,
				       GtkPrintSettings *settings)
{
	g_return_if_fail (PLUMA_IS_APP (app));
	g_return_if_fail (GTK_IS_PRINT_SETTINGS (settings));

	if (app->priv->print_settings != NULL)
		g_object_unref (app->priv->print_settings);

	app->priv->print_settings = g_object_ref (settings);
}