gaupol/agents/close.py

Source code for module gaupol.agents.close from file gaupol/agents/close.py.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
# -*- coding: utf-8 -*-

# Copyright (C) 2005 Osmo Salomaa
#
# 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 3 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, see <http://www.gnu.org/licenses/>.

"""Closing pages and quitting Gaupol."""

import aeidon
import gaupol
import os
_ = aeidon.i18n._

from gi.repository import Gtk


class CloseAgent(aeidon.Delegate):

    """Closing pages and quitting Gaupol."""

    @aeidon.deco.export
    def close(self, page, confirm=True):
        """
        Close `page` after asking to save its documents.

        If `confirm` is ``False`` do not ask to save documents.
        Raise :exc:`gaupol.Default` if asked to save, but cancelled
        and `page` was not closed.
        """
        if confirm:
            self._confirm_close(page)
        if not page in self.pages: return
        index = self.pages.index(page)
        if self.notebook.get_current_page() == index:
            self.notebook.next_page()
        self.notebook.remove_page(index)
        self.pages.remove(page)
        self.update_gui()
        self.emit("page-closed", page)

    @aeidon.deco.export
    def close_all(self, confirm=True):
        """
        Close all pages after asking to save their documents.

        If `confirm` is ``False`` do not ask to save documents.
        Raise :exc:`gaupol.Default` if asked to save, but cancelled
        and not all pages are closed.
        """
        nconfirm = sum((len(self._need_confirmation(x)) for x in self.pages))
        if confirm and nconfirm > 1:
            return self._confirm_close_multiple(tuple(self.pages))
        while self.pages:
            self.close(self.pages[-1], confirm=confirm)

    def _confirm_close(self, page):
        """
        Close `page` after asking to save its documents.

        Raise :exc:`gaupol.Default` if cancelled and `page` not closed.
        """
        docs = self._need_confirmation(page)
        if len(docs) > 1:
            return self._confirm_close_multiple((page,))
        if aeidon.documents.MAIN in docs:
            return self._confirm_close_main(page)
        if aeidon.documents.TRAN in docs:
            return self._confirm_close_translation(page)

    def _confirm_close_main(self, page):
        """
        Close `page` after asking to save its main document.

        Raise :exc:`gaupol.Default` if cancelled and `page` not closed.
        """
        title = _('Save changes to main document "{}" before closing?')
        title = title.format(page.get_main_basename())
        message = _("If you don't save, changes will be permanently lost.")
        dialog = gaupol.WarningDialog(self.window, title, message)
        dialog.add_button(_("Close _Without Saving"), Gtk.ResponseType.NO)
        dialog.add_button(_("_Cancel"), Gtk.ResponseType.CANCEL)
        dialog.add_button(_("_Save"), Gtk.ResponseType.YES)
        dialog.set_default_response(Gtk.ResponseType.YES)
        response = gaupol.util.flash_dialog(dialog)
        if not response in (Gtk.ResponseType.YES, Gtk.ResponseType.NO):
            raise gaupol.Default
        if response == Gtk.ResponseType.YES:
            self.save_main(page)

    def _confirm_close_multiple(self, pages):
        """
        Close `pages` after asking to save their documents.

        Raise :exc:`gaupol.Default` if cancelled and `pages` not closed.
        """
        dialog = gaupol.MultiCloseDialog(self.window, self, pages)
        response = gaupol.util.flash_dialog(dialog)
        if not response in (Gtk.ResponseType.YES, Gtk.ResponseType.NO):
            raise gaupol.Default

    def _confirm_close_translation(self, page):
        """
        Close `page` after asking to save its translation document.

        Raise :exc:`gaupol.Default` if cancelled and page not closed.
        """
        title = _('Save changes to translation document "{}" before closing?')
        title = title.format(page.get_translation_basename())
        message = _("If you don't save, changes will be permanently lost.")
        dialog = gaupol.WarningDialog(self.window, title, message)
        dialog.add_button(_("Close _Without Saving"), Gtk.ResponseType.NO)
        dialog.add_button(_("_Cancel"), Gtk.ResponseType.CANCEL)
        dialog.add_button(_("_Save"), Gtk.ResponseType.YES)
        dialog.set_default_response(Gtk.ResponseType.YES)
        response = gaupol.util.flash_dialog(dialog)
        if not response in (Gtk.ResponseType.YES, Gtk.ResponseType.NO):
            raise gaupol.Default
        if response == Gtk.ResponseType.YES:
            self.save_translation(page)

    def _need_confirmation(self, page):
        """Return documents in `page` with unsaved changes."""
        docs = []
        if page.project.main_changed:
            docs.append(aeidon.documents.MAIN)
        elif page.project.main_file is not None:
            if not os.path.isfile(page.project.main_file.path):
                docs.append(aeidon.documents.MAIN)
        if page.project.tran_changed:
            docs.append(aeidon.documents.TRAN)
        elif page.project.tran_file is not None:
            if not os.path.isfile(page.project.tran_file.path):
                docs.append(aeidon.documents.TRAN)
        return tuple(docs)

    @aeidon.deco.export
    @aeidon.deco.silent(gaupol.Default)
    def _on_close_all_projects_activate(self, *args):
        """Close all open projects."""
        self.close_all()

    @aeidon.deco.export
    @aeidon.deco.silent(gaupol.Default)
    def _on_close_project_activate(self, *args):
        """Close project."""
        self.close(self.get_current_page())

    @aeidon.deco.export
    @aeidon.deco.silent(gaupol.Default)
    def _on_page_close_request(self, page, *args):
        """Close project."""
        self.close(page)

    @aeidon.deco.export
    @aeidon.deco.silent(gaupol.Default)
    def _on_quit_activate(self, *args):
        """Quit Gaupol."""
        self.quit()

    @aeidon.deco.export
    @aeidon.deco.silent(gaupol.Default)
    def _on_window_delete_event(self, *args):
        """Quit Gaupol."""
        self.quit()
        return True

    @aeidon.deco.export
    def quit(self, confirm=True):
        """
        Quit Gaupol.

        If `confirm` is ``False`` do not ask to save documents.
        Raise :exc:`gaupol.Default` if asked to save, but cancelled.
        """
        self.emit("quit")
        nconfirm = sum((len(self._need_confirmation(x)) for x in self.pages))
        if confirm and nconfirm > 1:
            self._confirm_close_multiple(tuple(self.pages))
        elif confirm:
            for page in self.pages:
                if self._need_confirmation(page):
                    self._confirm_close(page)
        self.extension_manager.teardown_extensions()
        self._save_window_geometry()
        try:
            Gtk.main_quit()
            raise SystemExit(0)
        except RuntimeError:
            raise SystemExit(1)

    def _save_window_geometry(self):
        """Save the geometry of application and output windows."""
        if not gaupol.conf.application_window.maximized:
            conf = gaupol.conf.application_window
            conf.size = list(self.window.get_size())
            conf.position = list(self.window.get_position())
        self.output_window.save_geometry()