Updated Czech translation.

[evince.git] / shell / ev-window.c

diff --git a/shell/ev-window.c b/shell/ev-window.c
index 9c94528ea02ab44a2e712e5d27cf052e28e187d1..532aa4e4aef3d40e99454b554ec3abe9c28210c3 100644 (file)
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -94,6 +94,8 @@
 
 #include <string.h>
 
 
 #include <string.h>
 

+char *xdg_user_dir_lookup (char *type);
+

 typedef enum {
        PAGE_MODE_DOCUMENT,
        PAGE_MODE_PASSWORD
 typedef enum {
        PAGE_MODE_DOCUMENT,
        PAGE_MODE_PASSWORD


@@ -604,6 +606,16 @@ update_sizing_buttons (EvWindow *window)
        }
 }
 
        }
 }
 

+/**
+ * ev_window_is_empty:
+ * @ev_window: The instance of the #EvWindow.
+ *
+ * It does look if there is any document loaded or if there is any job to load
+ * a document.
+ *
+ * Returns: %TRUE if there isn't any document loaded or any any documente to be
+ *          loaded, %FALSE in other case.
+ */

 gboolean
 ev_window_is_empty (const EvWindow *ev_window)
 {
 gboolean
 ev_window_is_empty (const EvWindow *ev_window)
 {


@@ -898,8 +910,14 @@ setup_size_from_metadata (EvWindow *window)
         if (window->priv->page_cache &&
            ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
            ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {
         if (window->priv->page_cache &&
            ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
            ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {

+               

                gint document_width;
                gint document_height;
                gint document_width;
                gint document_height;

+               
+               GdkScreen *screen;
+               
+               gint request_width;
+               gint request_height;

 
                ev_page_cache_get_max_width (window->priv->page_cache, 
                                             0, 1.0,
 
                ev_page_cache_get_max_width (window->priv->page_cache, 
                                             0, 1.0,


@@ -908,9 +926,19 @@ setup_size_from_metadata (EvWindow *window)
                                             0, 1.0,
                                             &document_height);                 
                
                                             0, 1.0,
                                             &document_height);                 
                

+               request_width = g_value_get_double (&width_ratio) * document_width;
+               request_height = g_value_get_double (&height_ratio) * document_height;
+               
+               screen = gtk_window_get_screen (GTK_WINDOW (window));
+               
+               if (screen) {
+                       request_width = MIN (request_width, gdk_screen_get_width (screen));
+                       request_height = MIN (request_width, gdk_screen_get_height (screen));
+               }
+                               

                gtk_window_resize (GTK_WINDOW (window),
                gtk_window_resize (GTK_WINDOW (window),

-                                  g_value_get_double (&width_ratio) * document_width,
-                                  g_value_get_double (&height_ratio) * document_height);
+                                  request_width,
+                                  request_height);

                g_value_unset (&width_ratio);
                g_value_unset (&height_ratio);
        }
                g_value_unset (&width_ratio);
                g_value_unset (&height_ratio);
        }


@@ -1322,12 +1350,27 @@ ev_window_load_job_cb  (EvJobLoad *job,
        return;
 }
 
        return;
 }
 

+/**
+ * ev_window_get_uri:
+ * @ev_window: The instance of the #EvWindow.
+ *
+ * It returns the uri of the document showed in the #EvWindow.
+ *
+ * Returns: the uri of the document showed in the #EvWindow.
+ */

 const char *
 ev_window_get_uri (EvWindow *ev_window)
 {
        return ev_window->priv->uri;
 }
 
 const char *
 ev_window_get_uri (EvWindow *ev_window)
 {
        return ev_window->priv->uri;
 }
 

+/**
+ * ev_window_close_dialogs:
+ * @ev_window: The window where dialogs will be closed.
+ *
+ * It looks for password, print and properties dialogs and closes them and
+ * frees them from memory. If there is any print job it does free it too.
+ */

 static void
 ev_window_close_dialogs (EvWindow *ev_window)
 {
 static void
 ev_window_close_dialogs (EvWindow *ev_window)
 {


@@ -1494,6 +1537,13 @@ ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
                gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
                                          window->priv->uri);
        }
                gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
                                          window->priv->uri);
        }

+       else {
+               char *folder;
+               folder = xdg_user_dir_lookup ("DOCUMENTS");
+               gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
+                                                    folder);
+               free (folder);
+       }

        
        g_signal_connect (chooser, "response",
                          G_CALLBACK (file_open_dialog_response_cb),
        
        g_signal_connect (chooser, "response",
                          G_CALLBACK (file_open_dialog_response_cb),


@@ -1923,6 +1973,7 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
        GtkWidget *fc;
        gchar *base_name;
        gchar *file_name;
        GtkWidget *fc;
        gchar *base_name;
        gchar *file_name;

+       gchar *folder;

 
        fc = gtk_file_chooser_dialog_new (
                _("Save a Copy"),
 
        fc = gtk_file_chooser_dialog_new (
                _("Save a Copy"),


@@ -1937,10 +1988,13 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window)
        gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (fc), TRUE);    
        file_name = gnome_vfs_format_uri_for_display (ev_window->priv->uri);
        base_name = g_path_get_basename (file_name);
        gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (fc), TRUE);    
        file_name = gnome_vfs_format_uri_for_display (ev_window->priv->uri);
        base_name = g_path_get_basename (file_name);

+        folder = xdg_user_dir_lookup ("DOCUMENTS");

        gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);
        gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);

+        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc), folder);

        g_free (file_name);
        g_free (base_name);
        g_free (file_name);
        g_free (base_name);

-
+        free (folder);
+        

        g_signal_connect (fc, "response",
                          G_CALLBACK (file_save_dialog_response_cb),
                          ev_window);
        g_signal_connect (fc, "response",
                          G_CALLBACK (file_save_dialog_response_cb),
                          ev_window);


@@ -4059,7 +4113,7 @@ static const GtkActionEntry entries[] = {
        { "FileOpen", GTK_STOCK_OPEN, N_("_Open..."), "<control>O",
          N_("Open an existing document"),
          G_CALLBACK (ev_window_cmd_file_open) },
        { "FileOpen", GTK_STOCK_OPEN, N_("_Open..."), "<control>O",
          N_("Open an existing document"),
          G_CALLBACK (ev_window_cmd_file_open) },

-       { "FileOpenCopy", NULL, N_("Open a _Copy"), NULL,
+       { "FileOpenCopy", NULL, N_("Op_en a Copy"), NULL,

          N_("Open a copy of the current document in a new window"),
          G_CALLBACK (ev_window_cmd_file_open_copy) },
                { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "<control>S",
          N_("Open a copy of the current document in a new window"),
          G_CALLBACK (ev_window_cmd_file_open_copy) },
                { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "<control>S",


@@ -4487,10 +4541,45 @@ launch_action (EvWindow *window, EvLinkAction *action)
           allowing to launch executables is a good idea though. -- marco */
 }
 
           allowing to launch executables is a good idea though. -- marco */
 }
 

+static gboolean
+uri_is_valid (const gchar *uri)
+{
+       gchar *p = (gchar *) uri;
+       
+       if (!p || !g_ascii_isalpha (*p))
+               return FALSE;
+       
+       p++;
+       while (g_ascii_isalnum (*p))
+               p++;
+
+       return (g_ascii_strncasecmp (p, "://", strlen ("://")) == 0);
+}
+

 static void
 launch_external_uri (EvWindow *window, EvLinkAction *action)
 {
 static void
 launch_external_uri (EvWindow *window, EvLinkAction *action)
 {

-       gnome_vfs_url_show (ev_link_action_get_uri (action));
+       const gchar *uri = ev_link_action_get_uri (action);
+       
+       if (!uri_is_valid (uri)) {
+               GtkWidget *dialog;
+
+               dialog = gtk_message_dialog_new (GTK_WINDOW (window),
+                                                GTK_DIALOG_DESTROY_WITH_PARENT,
+                                                GTK_MESSAGE_ERROR,
+                                                GTK_BUTTONS_CLOSE,
+                                                _("Unable to open external link"));
+               gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+                                                         _("Invalid URI: “%s”"), uri);
+               g_signal_connect (dialog, "response",
+                                 G_CALLBACK (gtk_widget_destroy),
+                                 NULL);
+               gtk_widget_show (dialog);
+
+               return;
+       }
+       
+       gnome_vfs_url_show (uri);

 }
 
 static void
 }
 
 static void


@@ -5123,6 +5212,13 @@ ev_window_init (EvWindow *ev_window)
        ev_window_setup_action_sensitivity (ev_window);
 }
 
        ev_window_setup_action_sensitivity (ev_window);
 }
 

+/**
+ * ev_window_new:
+ *
+ * Creates a #GtkWidget that represents the window.
+ *
+ * Returns: the #GtkWidget that represents the window.
+ */

 GtkWidget *
 ev_window_new (void)
 {
 GtkWidget *
 ev_window_new (void)
 {