Merge lp:~elementary-apps/granite/saved-state into lp:~elementary-pantheon/granite/granite

[Raphael Isemann]

The current system of the saved-state logic is currently done by each app on their own, and the result is either half-implemented, wrong-implemented, not-implemented or twice-implemented processes for syncing the window-state to the gsettings-backend.

This branch adds a simple API extension to Granite that allows to sync a specified window to a single specified gsettings-key.

To test this branch i implemented a useage of this API in Terminal: https://code.launchpad.net/~elementary-apps/pantheon-terminal/new-saved-state/

[Rico Tzschichholz (ricotz)]

This is what is suppose to be achieved with the following:

http://valadoc.org/#!api=gio-2.0/GLib.Settings.bind
http://valadoc.org/#!api=gio-2.0/GLib.Settings.bind_with_mapping
http://valadoc.org/#!api=gio-2.0/GLib.Settings.bind_writable

Besides that "SavedState" is not really descriptive enough since only Gtk.Windows are supported

review: Needs Information

[Raphael Isemann (teemperor)]

SavedState is not a good description. We want that it takes care of saving/restoring the window-geometry over long durations, so we could name it "PersistentWindowManager"? I'm open for suggestions. We probably also want to rename the key from "saved-state" to something like "saved-geometry".

I'm not sure what you mean with "This is what is suppose to be achieved with the following: ..."? That we should have one Variant that we bind to a GSettings-key?

[David Gomes (davidgomes)]

Wouldn't it be better to have our own Granite.Window, instead of a wrapper class like you made? I mean, if it is doable, of course.

[Raphael Isemann (teemperor)]

Sounds reasonable and would solve the naming problem.

So it would be just using Granite.Window that has a property for a gsettings-path where it would save its geometry.

[Akshay Shekher (voldyman)]

hmm, my idea was of storing and restoring windows state from applications that use Granite.Application transparently.

Gtk.Application has signals for window_added and window_removed, we could use those signals to get the dimensions of the windows when they were closed and restore when the same window is opened again.

I haven't thought enough about this so it is open for debate.

[xapantu (xapantu)]

I also think this must be done more transparently. Maybe a set_main_window call or whatever would be required, but that should be all. Creating a new object and calling several functions for such a simple task is not very good. Besides, as Rico said, it would be better to bind the properties, else that will make a lot of code for nothing.

review: Disapprove

Unmerged revisions

783. By Raphael Isemann on 2014-08-25

Added support for maximized_fullscreen and fixed the saving of the window-state to the dconf-base (before we used the wrong method with the same name from Gtk.Widget instead of Gdk.Window). Also moved the methods to the upper part of the class and expanded documentation a bit.

782. By Raphael Isemann on 2014-08-25

Fixed saved-state parsing and fixed setting the window-size

781. By Raphael Isemann on 2014-08-25

We moved to a single key now as the backend

780. By Raphael Isemann on 2014-08-25

Added SavedState class

=== modified file 'lib/CMakeLists.txt'
--- lib/CMakeLists.txt	2014-01-18 21:47:46 +0000
+++ lib/CMakeLists.txt	2014-08-25 14:36:17 +0000
@@ -12,6 +12,7 @@
     Drawing/Utilities.vala
     GtkPatch/AboutDialog.vala
     Services/Settings.vala
+    Services/SavedState.vala
     Services/Logger.vala
     Services/Paths.vala
     Services/System.vala
@@ -114,4 +115,4 @@
 if (INTROSPECTION_FOUND)
     include (GObjectIntrospectionMacros)
     add_target_gir (${PKG_NAME} ${PKG_GIR_NAME} ${PKG_NAME}.h "${VALA_C}" "${DEPS_CFLAGS}" ${API_VERSION} ${GI_PKG_DEPS})
-endif ()
 \ No newline at end of file
+endif ()
 
=== added file 'lib/Services/SavedState.vala'
--- lib/Services/SavedState.vala	1970-01-01 00:00:00 +0000
+++ lib/Services/SavedState.vala	2014-08-25 14:36:17 +0000
@@ -0,0 +1,227 @@
+/***
+    Copyright (C) 2014 Raphael Isemann <[e-mail]>
+
+    This program or library is free software; you can redistribute it
+    and/or modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 3 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General
+    Public License along with this library; if not, write to the
+    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301 USA.
+***/
+
+namespace Granite.Services {
+
+    /**
+     + The SavedState class provides a synchronizing mechanism between
+     * the properties of a Gtk.Window and a gsettings-schema for saving
+     * those properties.
+     *
+     * The only action in your code is creating a SavedState-object, the rest is
+     * handled by this class:
+     * {{{
+     *    new SavedState (my_app_window, "org.example.myapp");
+     * }}}
+     *
+     * Note that you should use this code between the show_all () and the end of
+     * your UI-setup phase to prevent unwanted side-effects.
+     *
+     * You also need a proper saved-state key in your schema with the name "saved-state"
+     * and with the type '(iiiiu)'
+     * where the types represent in the order of listing:
+     * x-coordinate of the window (the value -1 means centered window),
+     * y-coordinate of the window (the value -1 means centered window),
+     * width of the window,
+     * height of the window,
+     * state of the window (0 = Normal, 1 = Maximized, 2 = Fullscreen).
+     *
+     * This is an example-of such an gsettings-key in your myapp.gschema.xml:
+     *
+     * {{{
+     * ...
+     * <key name="saved-state" type="(iiiiu)">
+     *     <default>(-1,-1,700,500,0)</default>
+     *     <summary>The saved state of the window.</summary>
+     *     <description>The saved width of the window. The values represent in the respective order:
+     *      x-coordinate of the window (the value -1 means centered window),y-coordinate of the window (the value -1 means centered window),
+     *      width of the window, height of the window, state of the window (0 = Normal, 1 = Maximized, 2 = Fullscreen).</description>
+     * </key>
+     * ...
+     * }}}
+     *
+     */
+    public class SavedState {
+
+        SavedStateBackend backend;
+        Gtk.Window window;
+
+        /**
+         * Connects the given window to the saved-state in the given schema.
+         * All window-contents should haven been be added when this constructor
+         * is called.
+
+         * @param key_name The key for the gsettings-field that should contain
+         *                  the saved-state. Default is "saved-state".
+         */
+        public SavedState (Gtk.Window window, string schema, string key_name = "saved-state") {
+            backend = new SavedStateBackend (schema, key_name);
+            this.window = window;
+            window.delete_event.connect (() => {
+                update_backend ();
+                return false;
+            });
+
+            // we update the window directly at the end of this constructor
+            update_window ();
+        }
+
+        /**
+         * Updates the saved-state backend. You only need to call this method
+         * if you expect that the app could quit without proper shutting down
+         * the UI. This class will otherwise automatically call this function
+         * when the window is deleted.
+         */
+        public void update_backend () {
+            backend.state = get_window_state ();
+
+            int width, height;
+            window.get_size (out width, out height);
+            backend.width = width;
+            backend.height = height;
+
+            int window_x, window_y;
+            window.get_position (out window_x, out window_y);
+            backend.x = window_x;
+            backend.y = window_y;
+
+            backend.write ();
+        }
+
+        /**
+         * Updates the window with the values from the saved-state.
+         * We keep this method private as saved-state is not supposed to react
+         * to during-runtime changes to the gsettings-backend.
+         */
+        private void update_window () {
+
+            window.set_size_request (backend.width, backend.height);
+
+            if (backend.x != -1 && backend.y != -1) {
+                window.move (backend.x, backend.y);
+            }
+
+            if (backend.state == WindowState.MAXIMIZED
+                || backend.state == WindowState.MAXIMIZED_FULLSCREEN) {
+                if (get_window_state () != WindowState.MAXIMIZED) {
+                    window.maximize ();
+                }
+            }
+            if (backend.state == WindowState.FULLSCREEN
+                || backend.state == WindowState.MAXIMIZED_FULLSCREEN) {
+                if (get_window_state () != WindowState.FULLSCREEN) {
+                    window.fullscreen ();
+                }
+            }
+            if (backend.state == WindowState.NORMAL) {
+                // In case the window is maximized or in fullscreen-mode
+                // we bring it back as a normal window
+                if (get_window_state () == WindowState.FULLSCREEN) {
+                    window.unfullscreen ();
+                } else if (get_window_state () == WindowState.MAXIMIZED) {
+                    window.unmaximize ();
+                }
+            }
+        }
+
+        private enum WindowState {
+            NORMAL = 0,
+            MAXIMIZED = 1,
+            FULLSCREEN = 2,
+            MAXIMIZED_FULLSCREEN = 3
+        }
+
+        private WindowState get_window_state () {
+            Gdk.Window gdk_window = window.get_window ();
+            if ((gdk_window.get_state () & Gdk.WindowState.MAXIMIZED) != 0) {
+                if ((gdk_window.get_state () & Gdk.WindowState.FULLSCREEN) != 0) {
+                    return WindowState.MAXIMIZED_FULLSCREEN;
+                } else {
+                    return WindowState.MAXIMIZED;
+                }
+            } else if ((gdk_window.get_state () & Gdk.WindowState.FULLSCREEN) != 0) {
+                return WindowState.FULLSCREEN;
+            } else {
+                return WindowState.NORMAL;
+            }
+        }
+
+        /**
+         * Helper class to pass values to the gsettings-backend.
+         */
+        private class SavedStateBackend : Object{
+
+            public int x { get; set; }
+            public int y { get; set; }
+            public int width { get; set; }
+            public int height { get; set; }
+            public WindowState state { get; set; }
+
+            GLib.Settings settings;
+
+            public string key_name;
+
+            /**
+             * Writes the values to the gsettings-backend.
+             */
+            public void write () {
+                GLib.Variant v_x = new GLib.Variant.int32 (x);
+                GLib.Variant v_y = new GLib.Variant.int32 (y);
+                GLib.Variant v_width = new GLib.Variant.int32 (width);
+                GLib.Variant v_height = new GLib.Variant.int32 (height);
+                GLib.Variant v_state = new GLib.Variant.uint32 ((uint32) state);
+                message (state.to_string ());
+                // Tuple that contains the whole saved-state
+                GLib.Variant tuple = new GLib.Variant.tuple ({v_x, v_y, v_width, v_height, v_state});
+                settings.set_value (key_name, tuple);
+            }
+
+            private void read () {
+                GLib.Variant saved_state = settings.get_value (key_name);
+                int out_x, out_y, out_w, out_h;
+                uint out_state;
+                saved_state.get ("(iiiiu)",
+                            out out_x,
+                            out out_y,
+                            out out_w,
+                            out out_h,
+                            out out_state);
+
+                // Check that we got a valid enum-value
+                if (out_state > 3)
+                    out_state = 0;
+
+                x = out_x;
+                y = out_y;
+                width = out_w;
+                height = out_h;
+                state = (WindowState) out_state;
+
+            }
+
+            public SavedStateBackend (string schema, string key_name) {
+                this.key_name = key_name;
+                settings = new GLib.Settings (schema);
+                read ();
+            }
+        }
+
+    }
+
+}