# -*- coding: utf-8 -*-
# Copyright (C) 2009 Canonical
#
# Authors:
#  Michael Vogt
#
# 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; version 3.
#
# 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 Street, Fifth Floor, Boston, MA 02110-1301 USA

# order is import here, otherwise test/gtk3/test_purchase.py is unhappy
from gi.repository import GObject
from gi.repository import Gtk

import atexit
import collections
import dbus
import dbus.service
from dbus.mainloop.glib import DBusGMainLoop
DBusGMainLoop(set_as_default=True)

import gettext
import logging
import os
import re
import subprocess
import sys
import xapian
import glob

import webbrowser

from gettext import gettext as _

# purely to initialize the netstatus
import softwarecenter.netstatus
# make pyflakes shut up
softwarecenter.netstatus.NETWORK_STATE

# db imports
from softwarecenter.db.application import Application
from softwarecenter.db import DebFileApplication, DebFileOpenError
from softwarecenter.i18n import init_locale

# misc imports
from softwarecenter.plugin import PluginManager
from softwarecenter.paths import SOFTWARE_CENTER_PLUGIN_DIRS
from softwarecenter.enums import (
    AppActions,
    DB_SCHEMA_VERSION,
    Icons,
    MOUSE_EVENT_FORWARD_BUTTON,
    MOUSE_EVENT_BACK_BUTTON,
    PkgStates,
    SearchSeparators,
    SOFTWARE_CENTER_DEBUG_TABS,
    SOFTWARE_CENTER_NAME_KEYRING,
    SOFTWARE_CENTER_TOS_LINK,
    ViewPages,
)
from softwarecenter.utils import (
    clear_token_from_ubuntu_sso_sync,
    get_http_proxy_string_from_gsettings,
    wait_for_apt_cache_ready,
    ExecutionTime,
    is_unity_running,
)
from softwarecenter.ui.gtk3.utils import (
    get_sc_icon_theme,
    init_sc_css_provider,
)
from softwarecenter.version import VERSION
from softwarecenter.db.database import StoreDatabase
try:
    from aptd_gtk3 import InstallBackendUI
    InstallBackendUI  # pyflakes
except:
    from softwarecenter.backend.installbackend import InstallBackendUI

# ui imports
import softwarecenter.ui.gtk3.dialogs.deauthorize_dialog as deauthorize_dialog
import softwarecenter.ui.gtk3.dialogs as dialogs

from softwarecenter.ui.gtk3.SimpleGtkbuilderApp import SimpleGtkbuilderApp
from softwarecenter.ui.gtk3.panes.installedpane import InstalledPane
from softwarecenter.ui.gtk3.panes.availablepane import AvailablePane
from softwarecenter.ui.gtk3.panes.historypane import HistoryPane
from softwarecenter.ui.gtk3.panes.globalpane import GlobalPane
from softwarecenter.ui.gtk3.panes.pendingpane import PendingPane
from softwarecenter.ui.gtk3.session.appmanager import (
    ApplicationManager,
    get_appmanager,
    )
from softwarecenter.ui.gtk3.session.viewmanager import (
    ViewManager,
    get_viewmanager,
    )
from softwarecenter.ui.gtk3.widgets.recommendations import (
    RecommendationsOptInDialog)

from softwarecenter.config import get_config
from softwarecenter.backend import get_install_backend
from softwarecenter.backend.login_sso import get_sso_backend
from softwarecenter.backend.recagent import RecommenderAgent

from softwarecenter.backend.channel import AllInstalledChannel
from softwarecenter.backend.reviews import get_review_loader, UsefulnessCache
from softwarecenter.backend.oneconfhandler import (
    get_oneconf_handler,
    is_oneconf_available,
)
from softwarecenter.distro import get_distro
from softwarecenter.db.pkginfo import get_pkg_info


from gi.repository import Gdk

LOG = logging.getLogger(__name__)
PACKAGE_PREFIX = 'apt:'
# "apt:///" is a valid prefix for 'apt:pkgname' in alt+F2 in gnome
PACKAGE_PREFIX_REGEX = re.compile('^%s(?:/{2,3})*' % PACKAGE_PREFIX)
SEARCH_PREFIX = 'search:'


# py3 compat
def callable(func):
    return isinstance(func, collections.Callable)


def parse_packages_args(packages):
    search_text = ''
    app = None

    # avoid treating strings as sequences ('foo' should not be 'f', 'o', 'o')
    if isinstance(packages, basestring):
        packages = (packages,)

    if not isinstance(packages, collections.Iterable):
        LOG.warning('show_available_packages: argument is not an iterable %r',
            packages)
        return search_text, app

    items = []  # make a copy of the given sequence
    for arg in packages:
        # support both "pkg1 pkg" and "pkg1,pkg2" (and "pkg1,pkg2 pkg3")
        if "," in arg:
            items.extend(arg.split(SearchSeparators.PACKAGE))
        else:
            items.append(arg)

    if len(items) > 0:
        # allow s-c to be called with a search term
        if items[0].startswith(SEARCH_PREFIX):
            # remove the initial search prefix
            items[0] = items[0].replace(SEARCH_PREFIX, '', 1)
            search_text = SearchSeparators.REGULAR.join(items)
        else:
            # strip away the initial apt: prefix, if present
            items[0] = re.sub(PACKAGE_PREFIX_REGEX, '', items[0])
            if len(items) > 1:
                # turn multiple packages into a search with "," as separator
                search_text = SearchSeparators.PACKAGE.join(items)

    if not search_text and len(items) == 1:
        request = items[0]
        # are we dealing with a path?
        if os.path.exists(request) and not os.path.isdir(request):
            if not request.startswith('/'):
                # we may have been given a relative path
                request = os.path.abspath(request)
            # will raise DebOpenFileError if request is invalid
            app = DebFileApplication(request)
        else:
            # package from archive
            # if there is a "/" in the string consider it as tuple
            # of (pkgname, appname) for exact matching (used by
            # e.g. unity
            (pkgname, sep, appname) = request.partition("/")
            if pkgname or appname:
                app = Application(appname, pkgname)
            else:
                LOG.warning('show_available_packages: received %r but '
                    'can not build an Application from it.', request)

    return search_text, app


class SoftwarecenterDbusController(dbus.service.Object):
    """
    This is a helper to provide the SoftwarecenterIFace

    It provides only a bringToFront method that takes
    additional arguments about what packages to show
    """
    def __init__(self, parent, bus_name,
                 object_path='/com/ubuntu/Softwarecenter'):
        dbus.service.Object.__init__(self, bus_name, object_path)
        self.parent = parent

    def stop(self):
        """ stop the dbus controller and remove from the bus """
        self.remove_from_connection()

    @dbus.service.method('com.ubuntu.SoftwarecenterIFace')
    def bringToFront(self, args):
        if args != 'nothing-to-show':
            self.parent.show_available_packages(args)
        self.parent.window_main.present()
        return True

    @dbus.service.method('com.ubuntu.SoftwarecenterIFace')
    def triggerDatabaseReopen(self):
        self.parent.db.emit("reopen")

    @dbus.service.method('com.ubuntu.SoftwarecenterIFace')
    def triggerCacheReload(self):
        self.parent.cache.emit("cache-ready")


class SoftwareCenterAppGtk3(SimpleGtkbuilderApp):

    WEBLINK_URL = "http://apt.ubuntu.com/p/%s"

    # the size of the icon for dialogs
    APP_ICON_SIZE = Gtk.IconSize.DIALOG

    START_DBUS = True

    def __init__(self, datadir, xapian_base_path, options, args=None):
        self.dbusControler = None
        if self.START_DBUS:
            # setup dbus and exit if there is another instance already running
            self.setup_dbus_or_bring_other_instance_to_front(args)

        self.datadir = datadir
        super(SoftwareCenterAppGtk3, self).__init__(
                                     datadir + "/ui/gtk3/SoftwareCenter.ui",
                                     "software-center")
        gettext.bindtextdomain("software-center", "/usr/share/locale")
        gettext.textdomain("software-center")

        init_locale()

        if SOFTWARE_CENTER_DEBUG_TABS:
            self.notebook_view.set_show_tabs(True)

        # distro specific stuff
        self.distro = get_distro()

        # setup proxy
        self._setup_proxy_initially()

        # Disable software-properties if it does not exist
        if not os.path.exists("/usr/bin/software-properties-gtk"):
            self.menuitem_software_sources.set_sensitive(False)

        with ExecutionTime("opening the pkginfo"):
            # a main iteration friendly apt cache
            self.cache = get_pkg_info()
            # cache is opened later in run()
            self.cache.connect("cache-broken", self._on_apt_cache_broken)

        with ExecutionTime("opening the xapiandb"):
            pathname = os.path.join(xapian_base_path, "xapian")
            self._use_axi = not options.disable_apt_xapian_index
            try:
                self.db = StoreDatabase(pathname, self.cache)
                self.db.open(use_axi=self._use_axi)
                if self.db.schema_version() != DB_SCHEMA_VERSION:
                    LOG.warn("database format '%s' expected, but got '%s'" % (
                            DB_SCHEMA_VERSION, self.db.schema_version()))
                    if os.access(pathname, os.W_OK):
                        self._rebuild_and_reopen_local_db(pathname)
            except xapian.DatabaseOpeningError:
                # Couldn't use that folder as a database
                # This may be because we are in a bzr checkout and that
                #   folder is empty. If the folder is empty, and we can find
                #   the script that does population, populate a database in it.
                if os.path.isdir(pathname) and not os.listdir(pathname):
                    self._rebuild_and_reopen_local_db(pathname)
            except xapian.DatabaseCorruptError:
                LOG.exception("xapian open failed")
                dialogs.error(None,
                              _("Sorry, can not open the software database"),
                              _("Please re-install the 'software-center' "
                                "package."))
                # FIXME: force rebuild by providing a dbus service for this
                sys.exit(1)

        # additional icons come from app-install-data
        with ExecutionTime("building the icon cache"):
            self.icons = get_sc_icon_theme(self.datadir)

        # backend
        with ExecutionTime("creating the backend"):
            self.backend = get_install_backend()
            self.backend.ui = InstallBackendUI()
            self.backend.connect("transaction-finished",
                self._on_transaction_finished)
            self.backend.connect("channels-changed", self.on_channels_changed)

        # high level app management
        with ExecutionTime("get the app-manager"):
            self.app_manager = ApplicationManager(self.db, self.backend,
                self.icons)

        # misc state
        self._block_menuitem_view = False

        # for use when viewing previous purchases
        self.scagent = None
        self.sso = None
        self.available_for_me_query = None

        Gtk.Window.set_default_icon_name("softwarecenter")

        # inhibit the error-bell, Bug #846138...
        settings = Gtk.Settings.get_default()
        settings.set_property("gtk-error-bell", False)

        # initial css loading
        init_sc_css_provider(self.window_main,
                             settings,
                             Gdk.Screen.get_default(),
                             datadir)

        # wire up the css provider to reconfigure on theme-changes
        self.window_main.connect("style-updated",
                                 self._on_style_updated,
                                 init_sc_css_provider,
                                 settings,
                                 Gdk.Screen.get_default(),
                                 datadir)

        # register view manager and create view panes/widgets
        with ExecutionTime("ViewManager"):
            self.view_manager = ViewManager(self.notebook_view, options)

        with ExecutionTime("building panes"):
            self.global_pane = GlobalPane(self.view_manager, self.datadir,
                self.db, self.cache, self.icons)
            self.vbox1.pack_start(self.global_pane, False, False, 0)
            self.vbox1.reorder_child(self.global_pane, 1)

            # start with the toolbar buttons insensitive and don't make them
            # sensitive until the panel elements are ready
            self.global_pane.view_switcher.set_sensitive(False)

            # available pane
            self.available_pane = AvailablePane(self.cache,
                                                self.db,
                                                self.distro,
                                                self.icons,
                                                self.datadir,
                                                self.navhistory_back_action,
                                                self.navhistory_forward_action)
            self.available_pane.connect("available-pane-created",
                self.on_available_pane_created)
            self.view_manager.register(self.available_pane,
                ViewPages.AVAILABLE)

            # installed pane (view not fully initialized at this point)
            self.installed_pane = InstalledPane(self.cache,
                                                self.db,
                                                self.distro,
                                                self.icons,
                                                self.datadir)
            self.installed_pane.connect("installed-pane-created",
                self.on_installed_pane_created)
            self.view_manager.register(self.installed_pane,
                ViewPages.INSTALLED)

            # history pane (not fully loaded at this point)
            self.history_pane = HistoryPane(self.cache,
                                            self.db,
                                            self.distro,
                                            self.icons,
                                            self.datadir)
            self.view_manager.register(self.history_pane, ViewPages.HISTORY)

            # pending pane
            self.pending_pane = PendingPane(self.icons)
            self.view_manager.register(self.pending_pane, ViewPages.PENDING)

        # TRANSLATORS: this is the help menuitem label,
        # e.g. Ubuntu Software Center _Help
        self.menuitem_help.set_label(_("%s _Help") %
            self.distro.get_app_name())

        # specify the smallest allowable window size
        self.window_main.set_size_request(730, 470)

        # reviews
        with ExecutionTime("create review loader"):
            self.review_loader = get_review_loader(self.cache, self.db)
            # FIXME: add some kind of throttle, I-M-S here
            self.review_loader.refresh_review_stats(
                self.on_review_stats_loaded)
            #load usefulness votes from server when app starts
            self.useful_cache = UsefulnessCache(True)
            self.setup_database_rebuilding_listener()

        with ExecutionTime("create plugin manager"):
            # open plugin manager and load plugins
            self.plugin_manager = PluginManager(self,
                SOFTWARE_CENTER_PLUGIN_DIRS)
            self.plugin_manager.load_plugins()

        # setup window name and about information (needs branding)
        name = self.distro.get_app_name()
        self.window_main.set_title(name)
        self.aboutdialog.set_program_name(name)
        about_description = self.distro.get_app_description()
        self.aboutdialog.set_comments(about_description)

        # about dialog
        self.aboutdialog.connect("response", lambda dialog, rid: dialog.hide())
        self.aboutdialog.connect("delete_event",
            lambda w, e: self.aboutdialog.hide_on_delete())

        # restore state
        self.config = get_config()
        self.restore_state()

        # Adapt menu entries
        self.menuitem_view_supported_only.set_label(
            self.distro.get_supported_filter_name())

        # this will be set sensitive once a the availablepane is available
        self.menuitem_recommendations.set_sensitive(False)

        if not self.distro.DEVELOPER_URL:
            self.menu_help.remove(self.separator_developer)
            self.menu_help.remove(self.menuitem_developer)

        # Check if oneconf is available
        och = is_oneconf_available()
        if not och:
            self.menu_file.remove(self.menuitem_sync_between_computers)

        # restore the state of the add to launcher menu item, or remove the
        # menu item if Unity is not currently running
        if is_unity_running():
            self.menuitem_add_to_launcher.set_active(
                                self.available_pane.add_to_launcher_enabled)
        else:
            self.menu_view.remove(self.add_to_launcher_separator)
            self.menu_view.remove(self.menuitem_add_to_launcher)

        # run s-c-agent update
        if options.disable_buy or not self.distro.PURCHASE_APP_URL:
            self.menu_file.remove(self.menuitem_reinstall_purchases)
            if not (options.enable_lp or och):
                self.menu_file.remove(self.separator_login)
        else:
            # running the agent will trigger a db reload so we do it later
            GObject.timeout_add_seconds(3, self._run_software_center_agent)

        # keep the cache clean
        GObject.timeout_add_seconds(15, self._run_expunge_cache_helper)

        # check to see if a new recommendations profile upload is
        # needed and upload if necessary
        GObject.timeout_add_seconds(45, self._upload_recommendations_profile)

        # TODO: Remove the following two lines once we have remove repository
        #       support in aptdaemon (see LP: #723911)
        self.menu_file.remove(self.menuitem_deauthorize_computer)

        # keep track of the current active pane
        self.active_pane = self.available_pane
        self.window_main.connect("realize", self.on_realize)

        # launchpad integration help, its ok if that fails
        try:
            from gi.repository import LaunchpadIntegration
            LaunchpadIntegration.set_sourcepackagename("software-center")
            LaunchpadIntegration.add_items(self.menu_help, 3, True, False)
        except Exception, e:
            LOG.debug("launchpad integration error: '%s'" % e)

    # helper
    def _run_software_center_agent(self):
        """ helper that triggers the update-software-center-agent helper """
        sc_agent_update = os.path.join(
            self.datadir, "update-software-center-agent")
        (pid, stdin, stdout, stderr) = GObject.spawn_async(
            [sc_agent_update, "--datadir", self.datadir],
            flags=GObject.SPAWN_DO_NOT_REAP_CHILD)
        GObject.child_watch_add(
            pid, self._on_update_software_center_agent_finished)

    def _run_expunge_cache_helper(self):
        """ helper that expires the piston-mini-client cache """
        sc_expunge_cache = os.path.join(
            self.datadir, "expunge-cache.py")
        (pid, stdin, stdout, stderr) = GObject.spawn_async(
            [sc_expunge_cache,
             "--by-unsuccessful-http-states",
             softwarecenter.paths.SOFTWARE_CENTER_CACHE_DIR,
             ])

    def _rebuild_and_reopen_local_db(self, pathname):
        """ helper that rebuilds a db and reopens it """
        from softwarecenter.db.update import rebuild_database
        LOG.info("building local database")
        # debian_sources is a bit misnamed, it will look for annotated
        # desktop files in /usr/share/app-install - enabling this on
        # non-debian systems will do no harm
        debian_sources = True
        # the appstream sources, enabling this on non-appstream systems
        # will do no harm
        appstream_sources = True
        rebuild_database(pathname, debian_sources, appstream_sources)
        self.db = StoreDatabase(pathname, self.cache)
        self.db.open(use_axi=self._use_axi)

    def _setup_proxy_initially(self):
        from gi.repository import Gio
        self._setup_proxy()
        self._gsettings = Gio.Settings.new("org.gnome.system.proxy.http")
        self._gsettings.connect("changed", self._setup_proxy)

    def _setup_proxy(self, setting=None, key=None):
        try:
            proxy = get_http_proxy_string_from_gsettings()
            LOG.info("setting up proxy '%s'" % proxy)
            if proxy:
                os.environ["http_proxy"] = proxy
            else:
                os.environ.pop("http_proxy", None)
        except Exception as e:
            # if no gnome settings are installed, do not mess with
            # http_proxy
            LOG.warn("could not get proxy settings '%s'" % e)
            pass

    # callbacks
    def on_realize(self, widget):
        pass

    def on_available_pane_created(self, widget):
        self.available_pane.searchentry.grab_focus()
        self._update_recommendations_menuitem(
                        opted_in=self._get_recommender_agent().is_opted_in())
        # connect a signal to monitor the recommendations opt-in state and
        # persist the recommendations uuid on an opt-in
        self.available_pane.cat_view.recommended_for_you_panel.connect(
                        "recommendations-opt-in",
                        self._on_recommendations_opt_in)
        self.available_pane.cat_view.recommended_for_you_panel.connect(
                        "recommendations-opt-out",
                        self._on_recommendations_opt_out)
        self.menuitem_recommendations.set_sensitive(True)
        # set the main toolbar buttons sensitive
        self.global_pane.view_switcher.set_sensitive(True)

    def on_installed_pane_created(self, widget):
        # set the main toolbar buttons sensitive
        self.global_pane.view_switcher.set_sensitive(True)

    def _on_recommendations_opt_in(self, rec_panel):
        self._update_recommendations_menuitem(opted_in=True)

    def _on_recommendations_opt_out(self, rec_panel):
        self._update_recommendations_menuitem(opted_in=False)

    def _update_recommendations_menuitem(self, opted_in):
        if opted_in:
            self.menuitem_recommendations.set_label(
                                            _(u"Turn Off Recommendations"))
        else:
            self.menuitem_recommendations.set_label(
                                            _(u"Turn On Recommendations…"))

    @wait_for_apt_cache_ready
    def _upload_recommendations_profile(self):
        recommender_agent = self._get_recommender_agent()
        if recommender_agent.is_opted_in():
            recommender_agent.post_submit_profile(self.db)

    def _get_recommender_agent(self):
        if not hasattr(self, "_recommender_agent"):
            self._recommender_agent = RecommenderAgent()
        return self._recommender_agent

    def _on_update_software_center_agent_finished(self, pid, condition):
        LOG.info("software-center-agent finished with status %i" %
            os.WEXITSTATUS(condition))
        if os.WEXITSTATUS(condition) == 0:
            self.db.reopen()

    def on_review_stats_loaded(self, reviews):
        LOG.debug("on_review_stats_loaded: '%s'" % len(reviews))

    def destroy(self):
        """Destroy this instance and every used resource."""
        self.window_main.destroy()

        # remove global instances of Managers
        self.app_manager.destroy()
        self.view_manager.destroy()

        if self.dbusControler is not None:
            # ensure that the dbus controller is really gone
            self.dbusControler.stop()

    def close_app(self):
        """ perform tasks like save-state etc when the application is
            exited
        """
        # this may happen during the early initialization
        # when "app.run()" was called but has not finished seting up the
        # stuff yet, in this case its ok to just exit
        if Gtk.main_level() == 0:
            LOG.info("closing before the regular main loop was run")
            sys.exit(0)
        # this is the case when it regularly runs
        if hasattr(self, "glaunchpad"):
            self.glaunchpad.shutdown()
        self.save_state()
        self.destroy()

        # this will not throw exceptions in pygi but "only" log via g_critical
        # to the terminal but it might in the future so we add a handler here
        try:
            Gtk.main_quit()
        except:
            LOG.exception("Gtk.main_quit failed")
        # exit here explictely to ensure that no further gtk event loops or
        # threads run and cause havoc on exit (LP: #914393)
        sys.exit(0)

    def on_window_main_key_press_event(self, widget, event):
        """ Define all the accelerator keys here - slightly messy, but the ones
            defined in the menu don't seem to work.. """

        # close
        if ((event.keyval == Gdk.keyval_from_name("w") or
             event.keyval == Gdk.keyval_from_name("q")) and
            event.state == Gdk.ModifierType.CONTROL_MASK):
            self.menuitem_close.activate()

        # undo/redo
        if (event.keyval == Gdk.keyval_from_name("z") and
            event.state == Gdk.ModifierType.CONTROL_MASK):
            self.menuitem_edit.activate()
            if self.menuitem_undo.get_sensitive():
                self.menuitem_undo.activate()

        if (event.keyval == Gdk.keyval_from_name("Z") and
            event.state == (Gdk.ModifierType.SHIFT_MASK |
            Gdk.ModifierType.CONTROL_MASK)):
            self.menuitem_edit.activate()
            if self.menuitem_redo.get_sensitive():
                self.menuitem_redo.activate()

        # cut/copy/paste
        if (event.keyval == Gdk.keyval_from_name("x") and
            event.state == Gdk.ModifierType.CONTROL_MASK):
            self.menuitem_edit.activate()
            if self.menuitem_cut.get_sensitive():
                self.menuitem_cut.activate()

        if (event.keyval == Gdk.keyval_from_name("c") and
            event.state == Gdk.ModifierType.CONTROL_MASK):
            self.menuitem_edit.activate()
            if self.menuitem_copy.get_sensitive():
                self.menuitem_copy.activate()

        # copy web link
        if (event.keyval == Gdk.keyval_from_name("C") and
            event.state == (Gdk.ModifierType.SHIFT_MASK |
            Gdk.ModifierType.CONTROL_MASK)):
            self.menuitem_edit.activate()
            if self.menuitem_copy_web_link.get_sensitive():
                self.menuitem_copy_web_link.activate()

        # select all
        if (event.keyval == Gdk.keyval_from_name("a") and
            event.state == Gdk.ModifierType.CONTROL_MASK):
            self.menuitem_edit.activate()
            if self.menuitem_select_all.get_sensitive():
                self.menuitem_select_all.activate()

        # search
        if (event.keyval == Gdk.keyval_from_name("f") and
            event.state == Gdk.ModifierType.CONTROL_MASK):
            self.menuitem_edit.activate()
            if self.menuitem_search.get_sensitive():
                self.menuitem_search.activate()

        # back
        if ((event.keyval == Gdk.keyval_from_name("bracketleft") and
             event.state == Gdk.ModifierType.CONTROL_MASK) or
            ((event.keyval == Gdk.keyval_from_name("Left") or
              event.keyval == Gdk.keyval_from_name("KP_Left")) and
             event.state == Gdk.ModifierType.MOD1_MASK)):
            # using the backspace key to navigate back has been disabled as it
            # has started to show dodgy side effects which I can't figure how
            # to deal with
            self.menuitem_view.activate()
            if self.menuitem_go_back.get_sensitive():
                self.menuitem_go_back.activate()

        # forward
        if ((event.keyval == Gdk.keyval_from_name("bracketright") and
             event.state == Gdk.ModifierType.CONTROL_MASK) or
            ((event.keyval == Gdk.keyval_from_name("Right") or
              event.keyval == Gdk.keyval_from_name("KP_Right")) and
             event.state == Gdk.ModifierType.MOD1_MASK)):
            self.menuitem_view.activate()
            if self.menuitem_go_forward.get_sensitive():
                self.menuitem_go_forward.activate()

    def on_window_main_button_press_event(self, widget, event):
        """
        Implement back/forward navigation via mouse navigation keys using
        the same button codes as used in Nautilus.
        """
        if event.button == MOUSE_EVENT_BACK_BUTTON:
            self.menuitem_view.activate()
            if self.menuitem_go_back.get_sensitive():
                self.menuitem_go_back.activate()
        elif event.button == MOUSE_EVENT_FORWARD_BUTTON:
            self.menuitem_view.activate()
            if self.menuitem_go_forward.get_sensitive():
                self.menuitem_go_forward.activate()

    def _on_lp_login(self, lp, token):
        self._lp_login_successful = True
        private_archives = self.glaunchpad.get_subscribed_archives()
        channel_manager = self.view_switcher.get_model().channel_manager
        channel_manager.feed_in_private_sources_list_entries(
            private_archives)

    def _on_sso_login(self, sso, oauth_result):
        self._sso_login_successful = True
        # appmanager needs to know about the oauth token for the reinstall
        # previous purchases add_license_key call
        self.app_manager.oauth_token = oauth_result
        self.scagent.query_available_for_me()

    def _on_style_updated(self, widget, init_css_callback, *args):
        init_css_callback(widget, *args)

    def _available_for_me_result(self, scagent, result_list):
        #print "available_for_me_result", result_list
        from softwarecenter.db.update import (
            add_from_purchased_but_needs_reinstall_data)
        available = add_from_purchased_but_needs_reinstall_data(result_list,
            self.db, self.cache)
        self.available_for_me_query = available
        self.available_pane.on_previous_purchases_activated(available)

    def get_icon_filename(self, iconname, iconsize):
        iconinfo = self.icons.lookup_icon(iconname, iconsize, 0)
        if not iconinfo:
            iconinfo = self.icons.lookup_icon(Icons.MISSING_APP_ICON,
                iconsize, 0)
        return iconinfo.get_filename()

    # File Menu
    def on_menu_file_activate(self, menuitem):
        """Enable/disable install/remove"""
        LOG.debug("on_menu_file_activate")

        # reset it all
        self.menuitem_install.set_sensitive(False)
        self.menuitem_remove.set_sensitive(False)

        # get our active pane
        vm = get_viewmanager()
        if vm is None:
            return False
        self.active_pane = vm.get_view_widget(vm.get_active_view())
        if self.active_pane is None:
            return False

        # determine the current app
        app = self.active_pane.get_current_app()
        if not app:
            return False

        # wait for the cache to become ready (if needed)
        if not self.cache.ready:
            GObject.timeout_add(
                100, lambda: self.on_menu_file_activate(menuitem))
            return False

        # update menu items
        pkg_state = None
        error = None
        # FIXME:  Use a Gtk.Action for the Install/Remove/Buy/Add Source/Update
        #         Now action so that all UI controls (menu item, applist view
        #         button and appdetails view button) are managed centrally:
        #         button text, button sensitivity, and callback method
        # FIXME:  Add buy support here by implementing the above
        appdetails = app.get_details(self.db)
        if appdetails:
            pkg_state = appdetails.pkg_state
            error = appdetails.error
        if (app.pkgname in
            self.active_pane.app_view.tree_view._action_block_list):
            return False
        elif (pkg_state == PkgStates.UPGRADABLE or
            pkg_state == PkgStates.REINSTALLABLE and not error):
            self.menuitem_install.set_sensitive(True)
            self.menuitem_remove.set_sensitive(True)
        elif pkg_state == PkgStates.INSTALLED:
            self.menuitem_remove.set_sensitive(True)
        elif pkg_state == PkgStates.UNINSTALLED and not error:
            self.menuitem_install.set_sensitive(True)
        elif (not pkg_state and
              not self.active_pane.is_category_view_showing() and
              app.pkgname in self.cache and
              not app.pkgname in
              self.active_pane.app_view.tree_view._action_block_list and
              not error):
            # when does this happen?
            pkg = self.cache[app.pkgname]
            installed = bool(pkg.installed)
            self.menuitem_install.set_sensitive(not installed)
            self.menuitem_remove.set_sensitive(installed)
        # return False to ensure that a possible GObject.timeout_add ends
        return False

    def on_menuitem_launchpad_private_ppas_activate(self, menuitem):
        from backend.launchpad import GLaunchpad
        self.glaunchpad = GLaunchpad()
        self.glaunchpad.connect("login-successful", self._on_lp_login)
        from view.logindialog import LoginDialog
        d = LoginDialog(self.glaunchpad, self.datadir, parent=self.window_main)
        d.login()

    def _create_dbus_sso(self):
        # see bug #773214 for the rationale, do not translate the appname
        #appname = _("Ubuntu Software Center")
        appname = SOFTWARE_CENTER_NAME_KEYRING
        help_text = _("To reinstall previous purchases, sign in to the "
            "Ubuntu Single Sign-On account you used to pay for them.")
        #window = self.window_main.get_window()
        #xid = self.get_window().xid
        xid = 0
        self.sso = get_sso_backend(xid,
                                   appname,
                                   help_text)
        self.sso.connect("login-successful", self._on_sso_login)

    def _login_via_dbus_sso(self):
        self._create_dbus_sso()
        self.sso.login()

    def _create_scagent_if_needed(self):
        if not self.scagent:
            from softwarecenter.backend.scagent import SoftwareCenterAgent
            self.scagent = SoftwareCenterAgent()
            self.scagent.connect("available-for-me",
                                 self._available_for_me_result)

    def on_menuitem_recommendations_activate(self, menu_item):
        rec_panel = self.available_pane.cat_view.recommended_for_you_panel
        if self._get_recommender_agent().is_opted_in():
            rec_panel.opt_out_of_recommendations_service()
        else:
            # build and show the opt-in dialog
            opt_in_dialog = RecommendationsOptInDialog(self.icons)
            res = opt_in_dialog.run()
            opt_in_dialog.destroy()
            if res == Gtk.ResponseType.YES:
                rec_panel.opt_in_to_recommendations_service()

    def on_menuitem_reinstall_purchases_activate(self, menuitem):
        self.view_manager.set_active_view(ViewPages.AVAILABLE)
        self.view_manager.search_entry.clear_with_no_signal()
        if self.available_for_me_query:
            # we already have the list of available items, so just show it
            # (no need for spinner here)
            self.available_pane.on_previous_purchases_activated(
                    self.available_for_me_query)
        else:
            # show spinner as this may take some time
            self.available_pane.show_appview_spinner()
            # fetch the list of available items and show it
            self._create_scagent_if_needed()
            self._login_via_dbus_sso()

    def on_menuitem_deauthorize_computer_activate(self, menuitem):

        # FIXME: need Ubuntu SSO username here
        # account_name = get_person_from_config()
        account_name = None

        # get a list of installed purchased packages
        installed_purchases = self.db.get_installed_purchased_packages()

        # display the deauthorize computer dialog
        deauthorize = deauthorize_dialog.deauthorize_computer(None,
            self.datadir, self.db, self.icons, account_name,
            installed_purchases)
        if deauthorize:
            # clear the ubuntu SSO token for this account
            # FIXME: as this is a sync call it maybe slow so we should
            #        probably provide a async() version of this as well
            clear_token_from_ubuntu_sso_sync(SOFTWARE_CENTER_NAME_KEYRING)

            # uninstall the list of purchased packages
            # TODO: do we need to check for dependencies and show a removal
            # dialog for that case?  seems not since these are purchased apps
            for pkgname in installed_purchases:
                app = Application(pkgname=pkgname)
                appdetails = app.get_details(self.db)
                self.backend.remove(app, appdetails.icon)

            # TODO: remove the corresponding private PPA sources
            # FIXME: this should really be done using aptdaemon, update this
            #        if/when remove repository support is added to aptdaemon
            # (private-ppa.launchpad.net_commercial-ppa-uploaders*)
            purchased_sources = glob.glob("/etc/apt/sources.list.d/"
                "private-ppa.launchpad.net_commercial-ppa-uploaders*")
            for source in purchased_sources:
                print("source: %s" % source)

    def on_menuitem_sync_between_computers_activate(self, menuitem):
        if self.view_manager.get_active_view() != ViewPages.INSTALLED:
            pane = self.view_manager.set_active_view(ViewPages.INSTALLED)
            state = pane.state.copy()
            state.channel = AllInstalledChannel()
            page = None
            self.view_manager.display_page(pane, page, state)
            self.installed_pane.refresh_apps()
        get_oneconf_handler().sync_between_computers(True)

    def on_menuitem_install_activate(self, menuitem):
        app = self.active_pane.get_current_app()
        get_appmanager().request_action(app, [], [], AppActions.INSTALL)

    def on_menuitem_remove_activate(self, menuitem):
        app = self.active_pane.get_current_app()
        get_appmanager().request_action(app, [], [], AppActions.REMOVE)

    def on_menuitem_close_activate(self, widget):
        self.close_app()

    def on_window_main_delete_event(self, widget, event):
        self.close_app()

# Edit Menu
    def on_menu_edit_activate(self, menuitem):
        """
        Check whether the search field is focused and if so, focus some items
        """
        edit_menu_items = [self.menuitem_undo,
                           self.menuitem_redo,
                           self.menuitem_cut,
                           self.menuitem_copy,
                           self.menuitem_copy_web_link,
                           self.menuitem_paste,
                           self.menuitem_delete,
                           self.menuitem_select_all,
                           self.menuitem_search]
        for item in edit_menu_items:
            item.set_sensitive(False)

        # get our active pane
        vm = get_viewmanager()
        if vm is None:
            return False
        self.active_pane = vm.get_view_widget(vm.get_active_view())

        if (self.active_pane and
            self.active_pane.searchentry and
            self.active_pane.searchentry.get_visible()):
            # undo, redo, cut, copy, paste, delete, select_all sensitive
            # if searchentry is focused (and other more specific conditions)
            if self.active_pane.searchentry.is_focus():
                if len(self.active_pane.searchentry._undo_stack) > 1:
                    self.menuitem_undo.set_sensitive(True)
                if len(self.active_pane.searchentry._redo_stack) > 0:
                    self.menuitem_redo.set_sensitive(True)
                bounds = self.active_pane.searchentry.get_selection_bounds()
                if bounds:
                    self.menuitem_cut.set_sensitive(True)
                    self.menuitem_copy.set_sensitive(True)
                self.menuitem_paste.set_sensitive(True)
                if self.active_pane.searchentry.get_text():
                    self.menuitem_delete.set_sensitive(True)
                    self.menuitem_select_all.set_sensitive(True)
            # search sensitive if searchentry is not focused
            else:
                self.menuitem_search.set_sensitive(True)

        # weblink
        if self.active_pane:
            app = self.active_pane.get_current_app()
            if app and app.pkgname:
                self.menuitem_copy_web_link.set_sensitive(True)

        # details view
        if (self.active_pane and
            self.active_pane.is_app_details_view_showing()):

            self.menuitem_select_all.set_sensitive(True)
            desc = self.active_pane.app_details_view.desc

            if desc.get_selected_text():
                self.menuitem_copy.set_sensitive(True)

    def on_menuitem_undo_activate(self, menuitem):
        self.active_pane.searchentry.undo()

    def on_menuitem_redo_activate(self, menuitem):
        self.active_pane.searchentry.redo()

    def on_menuitem_cut_activate(self, menuitem):
        self.active_pane.searchentry.cut_clipboard()

    def on_menuitem_copy_activate(self, menuitem):
        if (self.active_pane and
            self.active_pane.is_app_details_view_showing()):

            self.active_pane.app_details_view.desc.copy_clipboard()

        elif self.active_pane:
            self.active_pane.searchentry.copy_clipboard()

    def on_menuitem_paste_activate(self, menuitem):
        self.active_pane.searchentry.paste_clipboard()

    def on_menuitem_delete_activate(self, menuitem):
        self.active_pane.searchentry.set_text("")

    def on_menuitem_select_all_activate(self, menuitem):
        if (self.active_pane and
            self.active_pane.is_app_details_view_showing()):

            self.active_pane.app_details_view.desc.select_all()
            self.active_pane.app_details_view.desc.grab_focus()

        elif self.active_pane:
            self.active_pane.searchentry.select_region(0, -1)

    def on_menuitem_copy_web_link_activate(self, menuitem):
        app = self.active_pane.get_current_app()
        if app:
            display = Gdk.Display.get_default()
            selection = Gdk.Atom.intern("CLIPBOARD", False)
            clipboard = Gtk.Clipboard.get_for_display(display, selection)
            clipboard.set_text(self.WEBLINK_URL % app.pkgname, -1)

    def on_menuitem_search_activate(self, widget):
        if self.active_pane:
            self.active_pane.searchentry.grab_focus()
            self.active_pane.searchentry.select_region(0, -1)

    def on_menuitem_software_sources_activate(self, widget):
        # run software-properties-gtk
        window = self.window_main.get_window()
        if hasattr(window, 'xid'):
            xid = window.xid
        else:
            xid = 0

        p = subprocess.Popen(
            ["/usr/bin/software-properties-gtk",
             "-n",
             "-t", str(xid)])
        # Monitor the subprocess regularly
        GObject.timeout_add(100, self._poll_software_sources_subprocess, p)

    def _poll_software_sources_subprocess(self, popen):
        ret = popen.poll()
        if ret is None:
            # Keep monitoring
            return True
        # A return code of 1 means that the sources have changed
        if ret == 1:
            self.run_update_cache()
        # Stop monitoring
        return False

# View Menu
    def on_menu_view_activate(self, menuitem):
        vm = get_viewmanager()
        if vm is None:
            self.menuitem_view_all.set_sensitive(False)
            self.menuitem_view_supported_only.set_sensitive(False)
            self.menuitem_go_back.set_sensitive(False)
            self.menuitem_go_forward.set_sensitive(False)
            return False

        left_sensitive = vm.back_forward.left.get_sensitive()
        self.menuitem_go_back.set_sensitive(left_sensitive)
        right_sensitive = vm.back_forward.right.get_sensitive()
        self.menuitem_go_forward.set_sensitive(right_sensitive)

        self.menuitem_view.blocked = True

        # get our active pane
        self.active_pane = vm.get_view_widget(vm.get_active_view())
        if (self.active_pane and
            self.active_pane == self.available_pane or
            self.active_pane == self.installed_pane):
            self.menuitem_view_all.set_sensitive(True)
            self.menuitem_view_supported_only.set_sensitive(True)

            from softwarecenter.db.appfilter import get_global_filter
            supported_only = get_global_filter().supported_only
            self.menuitem_view_all.set_active(not supported_only)
            self.menuitem_view_supported_only.set_active(supported_only)
        else:
            self.menuitem_view_all.set_sensitive(False)
            self.menuitem_view_supported_only.set_sensitive(False)

        self.menuitem_view.blocked = False

    def on_menuitem_view_all_activate(self, widget):
        if self.menuitem_view.blocked:
            return
        from softwarecenter.db.appfilter import get_global_filter
        if get_global_filter().supported_only == True:
            get_global_filter().supported_only = False

            self.available_pane.refresh_apps()
            try:
                self.installed_pane.refresh_apps()
            except:  # may not be initialised
                pass

    def on_menuitem_view_supported_only_activate(self, widget):
        if self.menuitem_view.blocked:
            return
        from softwarecenter.db.appfilter import get_global_filter
        if get_global_filter().supported_only == False:
            get_global_filter().supported_only = True

            self.available_pane.refresh_apps()
            try:
                self.installed_pane.refresh_apps()
            except:  # may not be initialised
                pass

            # navigate up if the details page is no longer available
            #~ ap = self.active_pane
            #~ if (ap and ap.is_app_details_view_showing and
                #~ ap.app_details_view.app and
                #~ not self.distro.is_supported(self.cache, None,
                #~ ap.app_details_view.app.pkgname)):
                #~ if len(ap.app_view.get_model()) == 0:
                    #~ ap.navigation_bar.navigate_up_twice()
                #~ else:
                    #~ ap.navigation_bar.navigate_up()
                #~ ap.on_application_selected(None, None)

            #~ # navigate up if the list page is empty
            #~ elif (ap and ap.is_applist_view_showing() and
                #~ len(ap.app_view.get_model()) == 0):
                #~ ap.navigation_bar.navigate_up()
                #~ ap.on_application_selected(None, None)

    def on_navhistory_back_action_activate(self, navhistory_back_action=None):
        vm = get_viewmanager()
        vm.nav_back()

    def on_navhistory_forward_action_activate(self,
        navhistory_forward_action=None):
        vm = get_viewmanager()
        vm.nav_forward()

    def on_menuitem_add_to_launcher_toggled(self, menu_item):
        self.available_pane.add_to_launcher_enabled = menu_item.get_active()

# Help Menu
    def on_menuitem_about_activate(self, widget):
        self.aboutdialog.set_version(VERSION)
        self.aboutdialog.set_transient_for(self.window_main)
        self.aboutdialog.show()

    def on_menuitem_help_activate(self, menuitem):
        # run browser
        (pid, stdin, stdout, stderr) = GObject.spawn_async(
            ["yelp", "ghelp:software-center"], flags=GObject.SPAWN_SEARCH_PATH)

    def on_menuitem_tos_activate(self, menuitem):
        webbrowser.open_new_tab(SOFTWARE_CENTER_TOS_LINK)

    def on_menuitem_developer_activate(self, menuitem):
        webbrowser.open(self.distro.DEVELOPER_URL)

    def _ask_and_repair_broken_cache(self):
        # wait until the window window is available
        if self.window_main.props.visible == False:
            GObject.timeout_add_seconds(1, self._ask_and_repair_broken_cache)
            return
        if dialogs.confirm_repair_broken_cache(self.window_main,
                                                      self.datadir):
            self.backend.fix_broken_depends()

    def _on_apt_cache_broken(self, aptcache):
        self._ask_and_repair_broken_cache()

    def _on_transaction_finished(self, backend, result):
        """ callback when an application install/remove transaction
            (or a cache reload) has finished
        """
        self.cache.open()

    def on_channels_changed(self, backend, res):
        """ callback when the set of software channels has changed """
        LOG.debug("on_channels_changed %s" % res)
        if res:
            # reopen the database, this will ensure that the right signals
            # are send and triggers "refresh_apps"
            # and refresh the displayed app in the details as well
            self.db.reopen()

    # helper

    def run_update_cache(self):
        """update the apt cache (e.g. after new sources where added """
        self.backend.reload()

    def update_app_list_view(self, channel=None):
        """Helper that updates the app view list """
        if self.active_pane is None:
            return
        if channel is None and self.active_pane.is_category_view_showing():
            return
        if channel:
            self.channel_pane.set_channel(channel)
            self.active_pane.refresh_apps()

    def _on_database_rebuilding_handler(self, is_rebuilding):
        LOG.debug("_on_database_rebuilding_handler %s" % is_rebuilding)
        self._database_is_rebuilding = is_rebuilding

        if is_rebuilding:
            pass
        else:
            # we need to reopen when the database finished updating
            self.db.reopen()

    def setup_database_rebuilding_listener(self):
        """
        Setup system bus listener for database rebuilding
        """
        self._database_is_rebuilding = False
        # get dbus
        try:
            bus = dbus.SystemBus()
        except:
            LOG.exception("could not get system bus")
            return
        # check if its currently rebuilding (most likely not, so we
        # just ignore errors from dbus because the interface
        try:
            proxy_obj = bus.get_object("com.ubuntu.Softwarecenter",
                                       "/com/ubuntu/Softwarecenter")
            iface = dbus.Interface(proxy_obj, "com.ubuntu.Softwarecenter")
            res = iface.IsRebuilding()
            self._on_database_rebuilding_handler(res)
        except Exception as e:
            LOG.debug(
                "query for the update-database exception '%s' (probably ok)" %
                e)

        # add signal handler
        bus.add_signal_receiver(self._on_database_rebuilding_handler,
                                "DatabaseRebuilding",
                                "com.ubuntu.Softwarecenter")

    def setup_dbus_or_bring_other_instance_to_front(self, args):
        """
        This sets up a dbus listener
        """
        try:
            bus = dbus.SessionBus()
        except:
            LOG.exception("could not initiate dbus")
            return
        # if there is another Softwarecenter running bring it to front
        # and exit, otherwise install the dbus controller
        try:
            proxy_obj = bus.get_object('com.ubuntu.Softwarecenter',
                                       '/com/ubuntu/Softwarecenter')
            iface = dbus.Interface(proxy_obj, 'com.ubuntu.SoftwarecenterIFace')
            if args:
                res = iface.bringToFront(args)
            else:
                # None can not be transported over dbus
                res = iface.bringToFront('nothing-to-show')
            # ensure that the running s-c is working
            if res is not True:
                LOG.info("found a running software-center on dbus, "
                         "reconnecting")
                sys.exit()
        except dbus.DBusException:
            bus_name = dbus.service.BusName('com.ubuntu.Softwarecenter', bus)
            self.dbusControler = SoftwarecenterDbusController(self, bus_name)

    @wait_for_apt_cache_ready
    def show_app(self, app):
        """Show 'app' in the installed pane if is installed.

        If 'app' is not installed, show it in the available pane.

        """
        if (app.pkgname in self.cache and self.cache[app.pkgname].installed):
            with ExecutionTime("installed_pane.init_view()"):
                self.installed_pane.init_view()
            with ExecutionTime("installed_pane.show_app()"):
                self.installed_pane.show_app(app)
        else:
            self.available_pane.init_view()
            self.available_pane.show_app(app)

    def show_available_packages(self, packages):
        """ Show packages given as arguments in the available_pane
            If the list of packages is only one element long show that,
            otherwise turn it into a comma seperated search
        """
        try:
            search_text, app = parse_packages_args(packages)
        except DebFileOpenError as e:
            LOG.exception("show_available_packages: can not open %r, error:",
                          packages)
            dialogs.error(None,
                          _("Error"),
                          _("The file “%s” could not be opened.") % e.path)
            search_text = app = None

        LOG.info('show_available_packages: search_text is %r, app is %r.',
                 search_text, app)

        if search_text:
            self.available_pane.init_view()
            self.available_pane.searchentry.set_text(search_text)
        elif app is not None:
            self.show_app(app)
        else:
            # normal startup, show the lobby (it will have a spinner when
            # its not ready yet) - it will also initialize the view
            self.view_manager.set_active_view(ViewPages.AVAILABLE)

    def restore_state(self):
        if self.config.has_option("general", "size"):
            (x, y) = self.config.get("general", "size").split(",")
            self.window_main.set_default_size(int(x), int(y))
        else:
            # on first launch, specify the default window size to take
            # advantage of the available screen real estate (but set a
            # reasonable limit in case of a crazy-huge monitor)
            screen_height = Gdk.Screen.height()
            screen_width = Gdk.Screen.width()
            self.window_main.set_default_size(
                                        min(int(.85 * screen_width), 1200),
                                        min(int(.85 * screen_height), 800))
        if (self.config.has_option("general", "maximized") and
            self.config.getboolean("general", "maximized")):
            self.window_main.maximize()
        if self.config.has_option("general", "add_to_launcher"):
            self.available_pane.add_to_launcher_enabled = (
                    self.config.getboolean(
                    "general",
                    "add_to_launcher"))
        else:
            # initial default state is to add to launcher, per spec
            self.available_pane.add_to_launcher_enabled = True

    def save_state(self):
        LOG.debug("save_state")
        # this happens on a delete event, we explicitely save_state() there
        window = self.window_main.get_window()
        if window is None:
            return
        maximized = window.get_state() & Gdk.WindowState.MAXIMIZED
        if maximized:
            self.config.set("general", "maximized", "True")
        else:
            self.config.set("general", "maximized", "False")
            # size only matters when non-maximized
            size = self.window_main.get_size()
            self.config.set("general", "size", "%s, %s" % (size[0], size[1]))
        if self.available_pane.add_to_launcher_enabled:
            self.config.set("general", "add_to_launcher", "True")
        else:
            self.config.set("general", "add_to_launcher", "False")
        # store the recommender values
        self.config.set("general",
                        "recommender_uuid",
                        self._get_recommender_agent().recommender_uuid)
        self.config.set("general",
                        "recommender_profile_id",
                        self._get_recommender_agent().recommender_profile_id)
        self.config.write()

    def run(self, args):
        # show window as early as possible
        self.window_main.show_all()

        # delay cache open
        GObject.timeout_add(1, self.cache.open)

        # support both "pkg1 pkg" and "pkg1,pkg2" (and pkg1,pkg2 pkg3)
        if args:
            for (i, arg) in enumerate(args[:]):
                if "," in arg:
                    args.extend(arg.split(","))
                    del args[i]

        # FIXME: make this more predictable and less random
        # show args when the app is ready
        self.show_available_packages(args)

        atexit.register(self.save_state)
