# Copyright (C) 2007, Red Hat, Inc.
# Copyright (C) 2009, Aleksey Lim, Sayamindu Dasgupta
#
# This 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 2 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., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.

"""
STABLE.
"""

import gi
gi.require_version('GdkX11', '3.0')

from gi.repository import GObject
from gi.repository import GLib
from gi.repository import Gdk
from gi.repository import GdkX11
from gi.repository import Gtk

from sugar3.graphics.icon import Icon
from sugar3.graphics import palettegroup
from sugar3.graphics import style


_UNFULLSCREEN_BUTTON_VISIBILITY_TIMEOUT = 2


class UnfullscreenButton(Gtk.Window):
    """
    A ready-made "Unfullscreen" button.

    The type of button used by :class:`sugar3.graphics.window.Window` to exit
    fullscreen mode when in fullscreen mode.
    """

    def __init__(self):
        Gtk.Window.__init__(self)

        self.set_decorated(False)
        self.set_resizable(False)
        self.set_type_hint(Gdk.WindowTypeHint.DIALOG)

        self.set_border_width(0)

        self.props.accept_focus = False

        # Setup estimate of width, height
        valid_, w, h = Gtk.icon_size_lookup(Gtk.IconSize.LARGE_TOOLBAR)
        self._width = w
        self._height = h

        screen = self.get_screen()
        screen.connect('size-changed', self._screen_size_changed_cb)

        self._button = Gtk.Button()
        self._button.set_relief(Gtk.ReliefStyle.NONE)

        self._icon = Icon(icon_name='view-return',
                          pixel_size=style.STANDARD_ICON_SIZE)
        self._icon.show()
        self._button.add(self._icon)

        self._button.show()
        self.add(self._button)

    def connect_button_clicked(self, cb):
        self._button.connect('clicked', cb)

    def _reposition(self):
        x = Gdk.Screen.width() - self._width
        self.move(x, 0)

    def do_get_preferred_width(self):
        minimum, natural = Gtk.Window.do_get_preferred_width(self)
        self._width = minimum
        self._reposition()
        return minimum, natural

    def _screen_size_changed_cb(self, screen):
        self._reposition()


class Window(Gtk.Window):
    """
    UI interface for activity Windows

    Windows are used as a container to display things that happen in an
    activity. They contain canvas content, alerts messages, a tray and a
    toolbar. Windows can either be in fullscreen or non-fullscreen mode.
    Note that the toolbar is hidden in fullscreen mode, while it is visible in
    non-fullscreen mode.
    """

    def __init__(self, **args):
        self._enable_fullscreen_mode = True

        GObject.GObject.__init__(self, **args)

        self.set_decorated(False)
        self.maximize()
        self.connect('realize', self.__window_realize_cb)
        self.connect_after('key-press-event', self.__key_press_cb)

        # OSK support: canvas auto panning based on input focus
        if GObject.signal_lookup('request-clear-area', Window) != 0 and \
                GObject.signal_lookup('unset-clear-area', Window) != 0:
            self.connect('size-allocate', self.__size_allocate_cb)
            self.connect('request-clear-area', self.__request_clear_area_cb)
            self.connect('unset-clear-area', self.__unset_clear_area_cb)
            self._clear_area_dy = 0

        self._toolbar_box = None
        self._alerts = []
        self._canvas = None
        self.tray = None

        self.__vbox = Gtk.VBox()
        self.__hbox = Gtk.HBox()
        self.__vbox.pack_start(self.__hbox, True, True, 0)
        self.__hbox.show()

        self.add_events(Gdk.EventMask.POINTER_MOTION_HINT_MASK |
                        Gdk.EventMask.POINTER_MOTION_MASK |
                        Gdk.EventMask.BUTTON_RELEASE_MASK |
                        Gdk.EventMask.TOUCH_MASK)
        self.connect('motion-notify-event', self.__motion_notify_cb)
        self.connect('button-release-event', self.__button_press_event_cb)

        self.add(self.__vbox)
        self.__vbox.show()

        self._is_fullscreen = False
        self._unfullscreen_button = UnfullscreenButton()
        self._unfullscreen_button.set_transient_for(self)
        self._unfullscreen_button.connect_button_clicked(
            self.__unfullscreen_button_clicked)
        self._unfullscreen_button_timeout_id = None

    def reveal(self):
        """
        Make window active.

        Brings the window to the top and makes it acive, even after invoking on
        response to non-gtk events (in contrast to present()).
        See bug #1423
        """
        window = self.get_window()
        if window is None:
            self.show()
            return
        timestamp = Gtk.get_current_event_time()
        if not timestamp:
            timestamp = GdkX11.x11_get_server_time(window)
        window.focus(timestamp)

    def is_fullscreen(self):
        """
        Check whether the window is fullscreen or not.

        Returns:
            bool: true if window is fullscreen, false otherwise
        """
        return self._is_fullscreen

    def fullscreen(self):
        """
        Make the window fullscreen and hide the toolbar.
        """
        palettegroup.popdown_all()
        if self._toolbar_box is not None:
            self._toolbar_box.hide()
        if self.tray is not None:
            self.tray.hide()

        self._is_fullscreen = True

        if self.props.enable_fullscreen_mode:
            self._unfullscreen_button.show()

            if self._unfullscreen_button_timeout_id is not None:
                GObject.source_remove(self._unfullscreen_button_timeout_id)
                self._unfullscreen_button_timeout_id = None

            self._unfullscreen_button_timeout_id = \
                GLib.timeout_add_seconds(
                    _UNFULLSCREEN_BUTTON_VISIBILITY_TIMEOUT,
                    self.__unfullscreen_button_timeout_cb)

    def unfullscreen(self):
        """
        Put the window in non-fullscreen mode and make the toolbar visible.
        """
        if self._toolbar_box is not None:
            self._toolbar_box.show()
        if self.tray is not None:
            self.tray.show()

        self._is_fullscreen = False

        if self.props.enable_fullscreen_mode:
            self._unfullscreen_button.hide()

            if self._unfullscreen_button_timeout_id:
                GObject.source_remove(self._unfullscreen_button_timeout_id)
                self._unfullscreen_button_timeout_id = None

    def set_canvas(self, canvas):
        """
        Set current canvas of the window.

        Args:
            canvas (:class:`Gtk.Widget`): the canvas to set as current
        """
        if self._canvas:
            self.__hbox.remove(self._canvas)

        if canvas:
            self.__hbox.pack_start(canvas, True, True, 0)

        self._canvas = canvas
        self.__vbox.set_focus_child(self._canvas)

    def get_canvas(self):
        """
        Get current canvas content of the window.

        Returns:
            Gtk.Widget: the current canvas of the window
        """
        return self._canvas

    canvas = property(get_canvas, set_canvas)

    def get_toolbar_box(self):
        """
        Return window's current toolbar.

        Returns:
            sugar3.graphics.toolbar_box.ToolbarBox: the current toolbar box of the window
        """
        return self._toolbar_box

    def set_toolbar_box(self, toolbar_box):
        """
        Set window's current toolbar.

        Args:
            toolbar_box (:class:`sugar3.graphics.toolbarbox.ToolbarBox`): the toolbar box to set as current
        """
        if self._toolbar_box:
            self.__vbox.remove(self._toolbar_box)

        if toolbar_box:
            self.__vbox.pack_start(toolbar_box, False, False, 0)
            self.__vbox.reorder_child(toolbar_box, 0)

        self._toolbar_box = toolbar_box

    toolbar_box = property(get_toolbar_box, set_toolbar_box)

    def set_tray(self, tray, position):
        """
        Set the window's current tray.

        Args:
            tray (:class:`sugar3.graphics.tray.HTray` or :class:`sugar3.graphics.tray.VTray`): the tray to set
            position (Gtk.PositionType constant): the edge to set the tray at
        """
        if self.tray:
            box = self.tray.get_parent()
            box.remove(self.tray)

        if position == Gtk.PositionType.LEFT:
            self.__hbox.pack_start(tray, False, False, 0)
        elif position == Gtk.PositionType.RIGHT:
            self.__hbox.pack_end(tray, False, False, 0)
        elif position == Gtk.PositionType.BOTTOM:
            self.__vbox.pack_end(tray, False, False, 0)

        self.tray = tray

    def add_alert(self, alert):
        """
        Add an alert message to the window.
        Add an alert to the window. Note that you do need to .show the alert
        to make it visible.

        Args:
            alert (:class:`sugar3.graphics.alert.Alert`): the alert to add
        """
        self._alerts.append(alert)
        if len(self._alerts) == 1:
            self.__vbox.pack_start(alert, False, False, 0)
            if self._toolbar_box is not None:
                self.__vbox.reorder_child(alert, 1)
            else:
                self.__vbox.reorder_child(alert, 0)

    def remove_alert(self, alert):
        """
        Remove an alert message from the window.

        Args:
            alert (:class:`sugar3.graphics.alert.Alert`): the alert to remove
        """
        if alert in self._alerts:
            self._alerts.remove(alert)
            # if the alert is the visible one on top of the queue
            if alert.get_parent() is not None:
                self.__vbox.remove(alert)
                if len(self._alerts) >= 1:
                    self.__vbox.pack_start(self._alerts[0], False, False, 0)
                    if self._toolbar_box is not None:
                        self.__vbox.reorder_child(self._alerts[0], 1)
                    else:
                        self.__vbox.reorder_child(self._alert[0], 0)

    def __window_realize_cb(self, window):
        group = Gtk.Window()
        group.realize()
        window.get_window().set_group(group.get_window())

    def __key_press_cb(self, widget, event):
        key = Gdk.keyval_name(event.keyval)
        if event.get_state() & Gdk.ModifierType.MOD1_MASK:
            if self.tray is not None and key == 'space':
                self.tray.props.visible = not self.tray.props.visible
                return True
        elif key == 'Escape' and self._is_fullscreen and \
                self.props.enable_fullscreen_mode:
            self.unfullscreen()
            return True
        return False

    def __unfullscreen_button_clicked(self, button):
        self.unfullscreen()

    def __button_press_event_cb(self, widget, event):
        self._show_unfullscreen_button()
        return False

    def __motion_notify_cb(self, widget, event):
        self._show_unfullscreen_button()
        return False

    def _show_unfullscreen_button(self):
        if self._is_fullscreen and self.props.enable_fullscreen_mode:
            if not self._unfullscreen_button.props.visible:
                self._unfullscreen_button.show()

            # Reset the timer
            if self._unfullscreen_button_timeout_id is not None:
                GObject.source_remove(self._unfullscreen_button_timeout_id)
                self._unfullscreen_button_timeout_id = None

            self._unfullscreen_button_timeout_id = \
                GLib.timeout_add_seconds(
                    _UNFULLSCREEN_BUTTON_VISIBILITY_TIMEOUT,
                    self.__unfullscreen_button_timeout_cb)

    def __unfullscreen_button_timeout_cb(self):
        self._unfullscreen_button.hide()
        self._unfullscreen_button_timeout_id = None
        return False

    def __request_clear_area_cb(self, activity, osk_rect, cursor_rect):
        self._clear_area_dy = cursor_rect.y + cursor_rect.height - osk_rect.y

        if self._clear_area_dy < 0:
            self._clear_area_dy = 0
            return False

        self.queue_resize()
        return True

    def __unset_clear_area_cb(self, activity, snap_back):
        self._clear_area_dy = 0
        self.queue_resize()
        return True

    def __size_allocate_cb(self, widget, allocation):
        self.set_allocation(allocation)
        allocation.y -= self._clear_area_dy
        self.__vbox.size_allocate(allocation)

    def set_enable_fullscreen_mode(self, enable_fullscreen_mode):
        """
        Set whether the window is allowed to enter fullscreen mode.

        Args:
            enable_fullscreen_mode (bool): the boolean to set `_enable_fullscreen_mode` to
        """
        self._enable_fullscreen_mode = enable_fullscreen_mode

    def get_enable_fullscreen_mode(self):
        """
        Return whether the window is allowed to enter fullscreen mode.

        Returns:
            bool: true if window is allowed to be fullscreen, false otherwise
        """
        return self._enable_fullscreen_mode

    enable_fullscreen_mode = GObject.property(
        type=object,
        setter=set_enable_fullscreen_mode,
        getter=get_enable_fullscreen_mode)
