path: root/browser.py

# Copyright (C) 2006, Red Hat, Inc.
# Copyright (C) 2007, One Laptop Per Child
# Copyright (C) 2009, Tomeu Vizoso, Simon Schampijer
#
# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import os
import time
from gettext import gettext as _

from gi.repository import GObject, Gtk, Pango, WebKit

from sugar3 import env
from sugar3.activity import activity
from sugar3.graphics import style
from sugar3.graphics.icon import Icon

import sessionstore
from palettes import ContentInvoker
from sessionhistory import HistoryListener
from widgets import BrowserNotebook

_ZOOM_AMOUNT = 0.1
if os.path.isfile('/usr/share/library-common/index.html'):
    _HOMEPAGE_PATH = '/usr/share/library-common/index.html'
else:
    _HOMEPAGE_PATH = os.path.join(activity.get_bundle_path(),
                                        "data/index.html")

_UNTITLED_TEXT = _('Untitled')


class TabbedView(BrowserNotebook):
    __gtype_name__ = 'TabbedView'

    __gsignals__ = {
        'focus-url-entry': (GObject.SignalFlags.RUN_FIRST,
                            None,
                            ([])),
    }

    def __init__(self):
        BrowserNotebook.__init__(self)

        self.props.show_border = False
        self.props.scrollable = True

        # Use xpcom to turn off "offline mode" detection, which disables
        # access to localhost for no good reason.  (Trac #6250.)
        #io_service2 = io_service_class.getService(interfaces.nsIIOService2)
        #io_service2.manageOfflineStatus = False

        self.connect('size-allocate', self.__size_allocate_cb)
        self.connect('page-added', self.__page_added_cb)
        self.connect('page-removed', self.__page_removed_cb)

        self.add_tab()
        self._update_closing_buttons()
        self._update_tab_sizes()

    def __size_allocate_cb(self, widget, allocation):
        self._update_tab_sizes()

    def __page_added_cb(self, notebook, child, pagenum):
        self._update_closing_buttons()
        self._update_tab_sizes()

    def __page_removed_cb(self, notebook, child, pagenum):
        self._update_closing_buttons()
        self._update_tab_sizes()

    def __new_tab_cb(self, browser, url):
        new_browser = self.add_tab(next_to_current=True)
        new_browser.load_uri(url)
        new_browser.grab_focus()

    def add_tab(self, next_to_current=False):
        browser = Browser()
        browser.connect('new-tab', self.__new_tab_cb)

        if next_to_current:
            self._insert_tab_next(browser)
        else:
            self._append_tab(browser)
        self.emit('focus-url-entry')
        browser.load_uri('about:blank')
        return browser

    def _insert_tab_next(self, browser):
        scrolledwindow = Gtk.ScrolledWindow()
        scrolledwindow.show()
        scrolledwindow.add(browser)

        label = TabLabel(browser, scrolledwindow)
        label.connect('tab-close', self.__tab_close_cb)

        next_index = self.get_current_page() + 1
        self.insert_page(scrolledwindow, label, next_index)
        browser.show()
        self.set_current_page(next_index)

    def _append_tab(self, browser):
        scrolledwindow = Gtk.ScrolledWindow()
        scrolledwindow.show()
        scrolledwindow.add(browser)

        label = TabLabel(browser, scrolledwindow)
        label.connect('tab-close', self.__tab_close_cb)

        self.append_page(scrolledwindow, label)
        browser.show()
        self.set_current_page(-1)

    def on_add_tab(self, gobject):
        self.add_tab()

    def __tab_close_cb(self, label, browser_window):
        self.remove_page(self.page_num(browser_window))
        browser_window.destroy()

    def _update_tab_sizes(self):
        """Update tab widths based in the amount of tabs."""

        n_pages = self.get_n_pages()
        canvas_size = self.get_allocation()
        #overlap_size = self.style_get('tab-overlap') * n_pages - 1
        overlap_size = 0 #FIXME
        allowed_size = canvas_size.width - overlap_size

        tab_new_size = int(allowed_size * 1.0 / (n_pages + 1))
        # Four tabs ensured:
        tab_max_size = int(allowed_size * 1.0 / (5))
        # Eight tabs ensured:
        tab_min_size = int(allowed_size * 1.0 / (9))

        if tab_new_size < tab_min_size:
            tab_new_size = tab_min_size
        elif tab_new_size > tab_max_size:
            tab_new_size = tab_max_size

        for page_idx in range(n_pages):
            page = self.get_nth_page(page_idx)
            label = self.get_tab_label(page)
            label.update_size(tab_new_size)

    def _update_closing_buttons(self):
        """Prevent closing the last tab."""
        first_page = self.get_nth_page(0)
        first_label = self.get_tab_label(first_page)
        if self.get_n_pages() == 0:
            return
        elif self.get_n_pages() == 1:
            first_label.hide_close_button()
        else:
            first_label.show_close_button()

    def load_homepage(self):
        browser = self.current_browser
        browser.load_uri('file://' + _HOMEPAGE_PATH)

    def _get_current_browser(self):
        return self.get_nth_page(self.get_current_page()).get_child()

    current_browser = GObject.property(type=object,
                                       getter=_get_current_browser)

    def get_session(self):
        tab_sessions = []
        for index in xrange(0, self.get_n_pages()):
            window_browser = self.get_nth_page(index)
            browser = window_browser.get_child()
            tab_sessions.append(sessionstore.get_session(browser))
        return tab_sessions

    def set_session(self, tab_sessions):
        if tab_sessions and isinstance(tab_sessions[0], dict):
            # Old format, no tabs
            tab_sessions = [tab_sessions]

        while self.get_n_pages():
            self.remove_page(self.get_n_pages() - 1)

        for tab_session in tab_sessions:
            browser = Browser()
            browser.connect('new-tab', self.__new_tab_cb)
            self._append_tab(browser)
            sessionstore.set_session(browser, tab_session)


class TabLabel(Gtk.HBox):
    __gtype_name__ = 'TabLabel'

    __gsignals__ = {
        'tab-close': (GObject.SignalFlags.RUN_FIRST,
                      None,
                      ([object])),
    }

    def __init__(self, browser, browser_window):
        GObject.GObject.__init__(self)

        self._browser = browser
        self._browser_window = browser_window
        self._browser.connect('notify::title', self.__title_changed_cb)

        self._label = Gtk.Label(label=_UNTITLED_TEXT)
        self._label.set_ellipsize(Pango.EllipsizeMode.END)
        self._label.set_alignment(0, 0.5)
        self.pack_start(self._label, True, True, 0)
        self._label.show()

        close_tab_icon = Icon(icon_name='browse-close-tab')
        button = Gtk.Button()
        button.props.relief = Gtk.ReliefStyle.NONE
        button.props.focus_on_click = False
        icon_box = Gtk.HBox()
        icon_box.pack_start(close_tab_icon, True, False, 0)
        button.add(icon_box)
        button.connect('clicked', self.__button_clicked_cb)
        button.set_name('browse-tab-close')
        self.pack_start(button, False, True, 0)
        close_tab_icon.show()
        icon_box.show()
        button.show()
        self._close_button = button

    def update_size(self, size):
        self.set_size_request(size, -1)

    def hide_close_button(self):
        self._close_button.hide()

    def show_close_button(self):
        self._close_button.show()

    def __button_clicked_cb(self, button):
        self.emit('tab-close', self._browser_window)

    def __title_changed_cb(self, widget, param):
        if widget.props.title:
            self._label.set_text(widget.props.title)
        else:
            self._label.set_text(_UNTITLED_TEXT)


class Browser(WebKit.WebView):
    __gtype_name__ = 'Browser'

    __gsignals__ = {
        'new-tab': (GObject.SignalFlags.RUN_FIRST,
                    None,
                    ([str])),
    }

    def __init__(self):
        WebKit.WebView.__init__(self)

    def open_new_tab(self, url):
        self.emit('new-tab', url)


class PopupDialog(Gtk.Window):
    def __init__(self):
        GObject.GObject.__init__(self)

        self.set_type_hint(Gdk.WindowTypeHint.DIALOG)

        border = style.GRID_CELL_SIZE
        self.set_default_size(Gdk.Screen.width() - border * 2,
                              Gdk.Screen.height() - border * 2)

        self.view = WebView()
        self.view.connect('notify::visibility', self.__notify_visibility_cb)
        self.add(self.view)
        self.view.realize()

    def __notify_visibility_cb(self, web_view, pspec):
        if self.view.props.visibility:
            self.view.show()
            self.show()