#!/usr/bin/python3

# This file is part of the Bodhi Linux Web Browser Manager.
#
# Bodhi Web Browser Manager 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.
#
# The Web Browser Manager 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 Bodhi OS Web Browser Manager.
# If not, see <http://www.gnu.org/licenses/>.

# (c) Bodhi Linux Team (2022-2023
# (c) Feren Team 2015-2020 <ferenosdev@outlook.com>
# (c) AZorin 2010-2015 <azorin@zoringroup.com>
# (c) Zorink 2010 <zorink@zoringroup.com>
#
# Easily install and uninstall web browsers on a GTK based system.
# This is free software made available under the GNU public license.
"""
The Web Browser Manager is a GUI application designed to simplify the
installation and removal of popular web browsers, including those that are not
readily available by default from the repository.
"""
import os
import subprocess
import json
from threading import Thread

import gi

gi.require_version('Gtk', '3.0')  # noqa: E402
from gi.repository import Gtk, GdkPixbuf, GLib  # pylint: disable=C0413

# globals
applogo = "/usr/share/pixmaps/browser-manager.svg"
fixed = Gtk.Fixed()
browser_data = '/usr/lib/browser-manager/browser-data.json'
#    Icons
imgbr = '/usr/share/browser-manager/Brave.png'
imgcr = '/usr/share/browser-manager/Chrome.png'
imgch = '/usr/share/browser-manager/Chromium.png'
imgfa = '/usr/share/browser-manager/Falkon.png'
imgfx = '/usr/share/browser-manager/Firefox.png'
imgop = '/usr/share/browser-manager/Opera.png'
imgpm = '/usr/share/browser-manager/Palemoon.png'
imgsj = '/usr/share/browser-manager/Slimjet.png'
imgvi = '/usr/share/browser-manager/Vivaldi.png'
imgwf = '/usr/share/browser-manager/Waterfox.png'

#    Booleans
binbr = os.path.isfile("/usr/bin/brave-browser")
bincr = os.path.isfile("/usr/bin/google-chrome")
binch = os.path.isfile("/usr/bin/chromium")
binfa = os.path.isfile("/usr/bin/falkon")
binfx = os.path.isfile("/usr/bin/firefox")
binop = os.path.isfile("/usr/bin/opera")
binpm = os.path.isfile("/usr/lib/palemoon/palemoon")
binsj = os.path.isfile("/usr/bin/flashpeak-slimjet")
binvi = os.path.isfile("/usr/bin/vivaldi")
binwf = os.path.isfile("/usr/bin/waterfox-g")


# pylint: disable=too-few-public-methods
class BrowserManagerManager():
    """ Execute the Install or uninstall shell script."""

    def __init__(self, browsername, option, bmself):
        script = "/usr/lib/browser-manager/" + browsername + "/" + option
        try:
            subprocess.run(script, capture_output=False, check=True)
        except subprocess.CalledProcessError:
            # Not using may remove exception block
            pass
        BrowserManager.on_refresh(bmself)


# pylint: disable=too-many-instance-attributes, too-many-public-methods
class BrowserManager(Gtk.Window):
    """ The main GTK application window """
    with open(browser_data, 'r') as f:
        desc = json.load(f)

    def __init__(self):
        super().__init__()

        self.title = "Web Browser Manager"

        self.width = 796
        self.height = 440

        self.connect("destroy", self.on_destroy)

        self.init_gui()

    # pylint: disable=too-many-statements
    def init_gui(self):
        """ Initialize GUI window """
        self.set_title(self.title)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_size_request(self.width, self.height)

        #############################
        # Object Creation Functions #
        #############################

        # Program Labels
        def create_label(label_text, label_x, label_y):
            label = Gtk.Label()
            label.set_markup("<b>%s</b>" % label_text)
            label_width, label_height = label.get_layout().get_pixel_size()
            label_h = label_x + 37.5 - (0.5 * label_width)
            label.set_size_request(label_width, label_height)
            fixed.put(label, label_h, label_y)

            return label

        # Logo Buttons
        def about_button(icon_file, position, callback, tooltip):
            pixbuf = GdkPixbuf.Pixbuf.new_from_file(icon_file)
            resized_pixbuf = pixbuf.scale_simple(65, 65,
                                                 GdkPixbuf.InterpType.BILINEAR)
            image = Gtk.Image()
            image.set_from_pixbuf(resized_pixbuf)
            button = Gtk.Button()
            button.set_size_request(75, 75)
            button.add(image)
            fixed.put(button, *position)
            button.connect("clicked", callback)
            button.set_tooltip_text(tooltip)

            return button

        # Interface Main Buttons
        def int_button(label, position, callback, browser_name):
            button = Gtk.Button.new_with_label(label)
            button.connect("clicked", callback)
            button.set_size_request(87, 30)
            fixed.put(button, *position)
            button.set_tooltip_text("%s %s" % (label, browser_name))

            return button

        # Progress Bars
        def progressbar(position):
            pgb = Gtk.ProgressBar()
            fixed.put(pgb, *position)

            def update_progress():
                pgb.pulse()
                GLib.timeout_add(60, update_progress)

            update_progress()

            return pgb

        ############################
        # Browser Object Variables #
        ############################

        # Brave
        create_label("Brave", 43, 10)
        self.aboutbrave = about_button(imgbr, (43, 35), self.on_aboutbrave,
                                       "About Brave")
        self.statebrave = int_button(
            "Uninstall" if binbr else "Install", (40, 130),
            self.on_uninstbrave if binbr else self.on_instbrave, "Brave")
        self.br_pgb = progressbar((3, 131))

        # Google Chrome
        create_label("Chrome", 204, 10)
        self.aboutchrome = about_button(imgcr, (204, 35), self.on_aboutchrome,
                                        "About Chrome")
        self.statechrome = int_button(
            "Uninstall" if bincr else "Install", (201, 130),
            self.on_uninstchrome if bincr else self.on_instchrome, "Chrome")
        self.cr_pgb = progressbar((165, 131))

        # Chromium
        create_label("Chromium", 365, 10)
        self.aboutchromium = about_button(imgch, (365, 35),
                                          self.on_aboutchromium,
                                          "About Chromium")
        self.statechromium = int_button(
            "Uninstall" if binch else "Install", (360, 130),
            self.on_uninstchromium if binch else self.on_instchromium,
            "Chromium")
        self.ch_pgb = progressbar((325, 131))

        # Falkon
        create_label("Falkon", 526, 10)
        self.aboutfalkon = about_button(imgfa, (526, 35), self.on_aboutfalkon,
                                        "About Falkon")
        self.statefalkon = int_button(
            "Uninstall" if binfa else "Install", (521, 130),
            self.on_uninstfalkon if binfa else self.on_instfalkon, "Falkon")
        self.fa_pgb = progressbar((486, 131))

        # Firefox
        create_label("Firefox", 687, 10)
        self.aboutfirefox = about_button(imgfx, (687, 35), self.on_aboutfirefox,
                                         "About Firefox")
        self.statefirefox = int_button(
            "Uninstall" if binfx else "Install", (682, 130),
            self.on_uninstfirefox if binfx else self.on_instfirefox, "Firefox")
        self.fx_pgb = progressbar((647, 131))

        # Opera
        create_label("Opera", 46, 190)
        self.aboutopera = about_button(imgop, (46, 220), self.on_aboutopera,
                                       "About Opera")
        self.stateopera = int_button(
            "Uninstall" if binop else "Install", (41, 315),
            self.on_uninstopera if binop else self.on_instopera, "Opera")
        self.op_pgb = progressbar((6, 316))

        # Palemoon
        create_label("Palemoon", 207, 190)
        self.aboutpalemoon = about_button(imgpm, (207, 220),
                                          self.on_aboutpalemoon,
                                          "About Palemoon")
        self.statepalemoon = int_button(
            "Uninstall" if binpm else "Install", (202, 315),
            self.on_uninstpalemoon if binpm else self.on_instpalemoon,
            "Palemoon")
        self.pm_pgb = progressbar((167, 316))

        # Slimjet
        create_label("Slimjet", 368, 190)
        self.aboutslimjet = about_button(imgsj, (368, 220),
                                         self.on_aboutslimjet, "About Slimjet")
        self.stateslimjet = int_button(
            "Uninstall" if binsj else "Install", (363, 315),
            self.on_uninstslimjet if binsj else self.on_instslimjet, "Slimjet")
        self.sj_pgb = progressbar((328, 316))

        # Vivaldi
        create_label("Vivaldi", 529, 190)
        self.aboutvivaldi = about_button(imgvi, (529, 220),
                                         self.on_aboutvivaldi, "About Vivaldi")
        self.statevivaldi = int_button(
            "Uninstall" if binvi else "Install", (524, 315),
            self.on_uninstvivaldi if binvi else self.on_instvivaldi, "Vivaldi")
        self.vi_pgb = progressbar((489, 316))

        # Waterfox
        create_label("Waterfox", 690, 190)
        self.aboutwaterfox = about_button(imgwf, (690, 220),
                                          self.on_aboutwaterfox,
                                          "About Waterfox")
        self.statewaterfox = int_button(
            "Uninstall" if binwf else "Install", (685, 315),
            self.on_uninstwaterfox if binwf else self.on_instwaterfox,
            "Waterfox")
        self.wf_pgb = progressbar((650, 316))

        # General Window buttons
        self.closebtn = int_button("Close", (705, 400), self.on_destroy,
                                  "Window")
        self.aboutbtn = int_button("About", (10, 400), self.on_aboutbm,
                                   "Browser Manager")

        ######################################################
        # Packing everything, display everything and refresh #
        ######################################################

        self.add(fixed)
        self.show_all()
        self.on_refresh()

    ###############################
    # Defining the button actions #
    ###############################

    # pylint: disable=unused-argument, no-self-use
    def on_destroy(self, widget):
        """ Window close callback"""
        Gtk.main_quit()

    def begin_process(self):
        """ Set hide buttons when install is started"""
        self.statebrave.set_visible(False)
        self.statechrome.set_visible(False)
        self.statechromium.set_visible(False)
        self.statefirefox.set_visible(False)
        self.statefalkon.set_visible(False)
        self.stateopera.set_visible(False)
        self.statepalemoon.set_visible(False)
        self.stateslimjet.set_visible(False)
        self.statevivaldi.set_visible(False)
        self.statewaterfox.set_visible(False)
        self.closebtn.set_visible(False)

    def on_refresh_state(self):
        """ Ugly hack to address mislabeled state buttons"""
        global binbr, bincr, binch, binfa, binfx
        global binop, binpm, binsj, binvi, binwf

        #    Booleans
        binbr = os.path.isfile("/usr/bin/brave-browser")
        bincr = os.path.isfile("/usr/bin/google-chrome")
        binch = os.path.isfile("/usr/bin/chromium")
        binfa = os.path.isfile("/usr/bin/falkon")
        binfx = os.path.isfile("/usr/bin/firefox")
        binop = os.path.isfile("/usr/bin/opera")
        binpm = os.path.isfile("/usr/lib/palemoon/palemoon")
        binsj = os.path.isfile("/usr/bin/flashpeak-slimjet")
        binvi = os.path.isfile("/usr/bin/vivaldi")
        binwf = os.path.isfile("/usr/bin/waterfox-g")

        # Brave
        lb = self.statebrave.get_label()
        if binbr:
            if lb == "Install":
                self.statebrave.set_label("Uninstall")
                self.statebrave.disconnect_by_func(self.on_instbrave)
                self.statebrave.connect("clicked", self.on_uninstbrave)
        else:
            if lb == "Uninstall":
                self.statebrave.set_label("Install")
                self.statebrave.disconnect_by_func(self.on_uninstbrave)
                self.statebrave.connect("clicked", self.on_instbrave)

        # Google Chrome
        lb = self.statechrome.get_label()
        if bincr:
            if lb == "Install":
                self.statechrome.set_label("Uninstall")
                self.statechrome.disconnect_by_func(self.on_instchrome)
                self.statechrome.connect("clicked", self.on_uninstchrome)
        else:
            if lb == "Uninstall":
                self.statechrome.set_label("Install")
                self.statechrome.disconnect_by_func(self.on_uninstchrome)
                self.statechrome.connect("clicked", self.on_instchrome)

        # Chromium
        lb = self.statechromium.get_label()
        if binch:
            if lb == "Install":
                self.statechromium.set_label("Uninstall")
                self.statechromium.disconnect_by_func(self.on_instchromium)
                self.statechromium.connect("clicked", self.on_uninstchromium)
        else:
            if lb == "Uninstall":
                self.statechromium.set_label("Install")
                self.statechromium.disconnect_by_func(self.on_uninstchromium)
                self.statechromium.connect("clicked", self.on_instchromium)

        # Falkon
        lb = self.statefalkon.get_label()
        if binfa:
            if lb == "Install":
                self.statefalkon.set_label("Uninstall")
                self.statefalkon.disconnect_by_func(self.on_instfalkon)
                self.statefalkon.connect("clicked", self.on_uninstfalkon)
        else:
            if lb == "Uninstall":
                self.statefalkon.set_label("Install")
                self.statefalkon.disconnect_by_func(self.on_uninstfalkon)
                self.statefalkon.connect("clicked", self.on_instfalkon)

        # Firefox
        lb = self.statefirefox.get_label()
        if binfx:
            if lb == "Install":
                self.statefirefox.set_label("Uninstall")
                self.statefirefox.disconnect_by_func(self.on_instfirefox)
                self.statefirefox.connect("clicked", self.on_uninstfirefox)
        else:
            if lb == "Uninstall":
                self.statefirefox.set_label("Install")
                self.statefirefox.disconnect_by_func(self.on_uninstfirefox)
                self.statefirefox.connect("clicked", self.on_instfirefox)

        # Opera
        lb = self.stateopera.get_label()
        if binop:
            if lb == "Install":
                self.stateopera.set_label("Uninstall")
                self.stateopera.disconnect_by_func(self.on_instopera)
                self.stateopera.connect("clicked", self.on_uninstopera)
        else:
            if lb == "Uninstall":
                self.stateopera.set_label("Install")
                self.stateopera.disconnect_by_func(self.on_uninstopera)
                self.stateopera.connect("clicked", self.on_instopera)

        # Palemoon
        lb = self.statepalemoon.get_label()
        if binpm:
            if lb == "Install":
                self.statepalemoon.set_label("Uninstall")
                self.statepalemoon.disconnect_by_func(self.on_instpalemoon)
                self.statepalemoon.connect("clicked", self.on_uninstpalemoon)
        else:
            if lb == "Uninstall":
                self.statepalemoon.set_label("Install")
                self.statepalemoon.disconnect_by_func(self.on_uninstpalemoon)
                self.statepalemoon.connect("clicked", self.on_instpalemoon)

        # Slimjet
        lb = self.stateslimjet.get_label()
        if binsj:
            if lb == "Install":
                self.stateslimjet.set_label("Uninstall")
                self.stateslimjet.disconnect_by_func(self.on_instslimjet)
                self.stateslimjet.connect("clicked", self.on_uninstslimjet)
        else:
            if lb == "Uninstall":
                self.stateslimjet.set_label("Install")
                self.stateslimjet.disconnect_by_func(self.on_uninstslimjet)
                self.stateslimjet.connect("clicked", self.on_instslimjet)

        # Vivaldi
        lb = self.statevivaldi.get_label()
        if binvi:
            if lb == "Install":
                self.statevivaldi.set_label("Uninstall")
                self.statevivaldi.disconnect_by_func(self.on_instvivaldi)
                self.statevivaldi.connect("clicked", self.on_uninstvivaldi)
        else:
            if lb == "Uninstall":
                self.statevivaldi.set_label("Install")
                self.statevivaldi.disconnect_by_func(self.on_uninstvivaldi)
                self.statevivaldi.connect("clicked", self.on_instvivaldi)

        # Waterfox
        lb = self.statewaterfox.get_label()
        if binwf:
            if lb == "Install":
                self.statewaterfox.set_label("Uninstall")
                self.statewaterfox.disconnect_by_func(self.on_instwaterfox)
                self.statewaterfox.connect("clicked", self.on_uninstwaterfox)
        else:
            if lb == "Uninstall":
                self.statewaterfox.set_label("Install")
                self.statewaterfox.disconnect_by_func(self.on_uninstwaterfox)
                self.statewaterfox.connect("clicked", self.on_instwaterfox)

    def on_refresh(self):
        """ Reset the window to the starting state"""
        # Hide all the progress bars
        self.br_pgb.set_visible(False)
        self.cr_pgb.set_visible(False)
        self.ch_pgb.set_visible(False)
        self.fa_pgb.set_visible(False)
        self.fx_pgb.set_visible(False)
        self.op_pgb.set_visible(False)
        self.pm_pgb.set_visible(False)
        self.sj_pgb.set_visible(False)
        self.vi_pgb.set_visible(False)
        self.wf_pgb.set_visible(False)

        # Show the close button
        self.closebtn.set_visible(True)

        # Refresh Browser state
        self.on_refresh_state()

        # Set browser state buttons visible
        self.statebrave.set_visible(True)
        self.statechrome.set_visible(True)
        self.statechromium.set_visible(True)
        self.statefalkon.set_visible(True)
        self.statefirefox.set_visible(True)
        self.stateopera.set_visible(True)
        self.statepalemoon.set_visible(True)
        self.stateslimjet.set_visible(True)
        self.statevivaldi.set_visible(True)
        self.statewaterfox.set_visible(True)

    def on_instbrave(self, widget):
        """ Button callback"""
        self.begin_process()
        self.br_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("brave", "install", self))
        sh_script.start()

    def on_instchrome(self, widget):
        """ Button callback"""
        self.begin_process()
        self.cr_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("chrome", "install", self))
        sh_script.start()

    def on_instchromium(self, widget):
        """ Button callback"""
        self.begin_process()
        self.ch_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("chromium", "install", self))
        sh_script.start()

    def on_instfalkon(self, widget):
        """ Button callback"""
        self.begin_process()
        self.fa_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("falkon", "install", self))
        sh_script.start()

    def on_instfirefox(self, widget):
        """ Button callback"""
        self.begin_process()
        self.fx_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("firefox", "install", self))
        sh_script.start()

    def on_instopera(self, widget):
        """ Button callback"""
        self.begin_process()
        self.op_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("opera", "install", self))
        sh_script.start()

    def on_instpalemoon(self, widget):
        """ Button callback"""
        self.begin_process()
        self.pm_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("palemoon", "install", self))
        sh_script.start()

    def on_instslimjet(self, widget):
        """ Button callback"""
        self.begin_process()
        self.sj_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("slimjet", "install", self))
        sh_script.start()

    def on_instslimjet(self, widget):
        """ Button callback"""
        self.begin_process()
        self.sj_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("slimjet", "install", self))
        sh_script.start()

    def on_instvivaldi(self, widget):
        """ Button callback"""
        self.begin_process()
        self.vi_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("vivaldi", "install", self))
        sh_script.start()

    def on_instwaterfox(self, widget):
        """ Button callback"""
        self.begin_process()
        self.wf_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("waterfox", "install", self))
        sh_script.start()

    def on_uninstbrave(self, widget):
        """ Button callback"""
        self.begin_process()
        self.br_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("brave", "uninstall", self))
        sh_script.start()

    def on_uninstchrome(self, widget):
        """ Button callback"""
        self.begin_process()
        self.cr_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("chrome", "uninstall", self))
        sh_script.start()

    def on_uninstchromium(self, widget):
        """ Button callback"""
        self.begin_process()
        self.ch_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("chromium", "uninstall", self))
        sh_script.start()

    def on_uninstfalkon(self, widget):
        """ Button callback"""
        self.begin_process()
        self.fa_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("falkon", "uninstall", self))
        sh_script.start()

    def on_uninstfirefox(self, widget):
        """ Button callback"""
        self.begin_process()
        self.fx_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("firefox", "uninstall", self))
        sh_script.start()

    def on_uninstopera(self, widget):
        """ Button callback"""
        self.begin_process()
        self.op_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("opera", "uninstall", self))
        sh_script.start()

    def on_uninstpalemoon(self, widget):
        """ Button callback"""
        self.begin_process()
        self.pm_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("palemoon", "uninstall", self))
        sh_script.start()

    def on_uninstslimjet(self, widget):
        """ Button callback"""
        self.begin_process()
        self.sj_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("slimjet", "uninstall", self))
        sh_script.start()

    def on_uninstvivaldi(self, widget):
        """ Button callback"""
        self.begin_process()
        self.vi_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("vivaldi", "uninstall", self))
        sh_script.start()

    def on_uninstwaterfox(self, widget):
        """ Button callback"""
        self.begin_process()
        self.wf_pgb.set_visible(True)
        sh_script = Thread(target=BrowserManagerManager,
                           args=("waterfox", "uninstall", self))
        sh_script.start()

    def on_aboutbrave(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['brave'])
        dialog.run()
        dialog.destroy()

    def on_aboutchrome(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['chrome'])
        dialog.run()
        dialog.destroy()

    def on_aboutchromium(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['chromium'])
        dialog.run()
        dialog.destroy()

    def on_aboutfalkon(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['falkon'])
        dialog.run()
        dialog.destroy()

    def on_aboutfirefox(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['firefox'])
        dialog.run()
        dialog.destroy()

    def on_aboutopera(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['opera'])
        dialog.run()
        dialog.destroy()

    def on_aboutpalemoon(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['palemoon'])
        dialog.run()
        dialog.destroy()

    def on_aboutslimjet(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['slimjet'])
        dialog.run()
        dialog.destroy()

    def on_aboutvivaldi(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['vivaldi'])
        dialog.run()
        dialog.destroy()

    def on_aboutwaterfox(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['waterfox'])
        dialog.run()
        dialog.destroy()

    def on_aboutbm(self, widget):
        """ About callback"""
        dialog = Gtk.MessageDialog(parent = self, 
                                   flags = 0,
                                   message_type = Gtk.MessageType.INFO,
                                   buttons = Gtk.ButtonsType.OK,
                                   text = BrowserManager.desc['wbm'])
        dialog.run()
        dialog.destroy()


ex = BrowserManager()
Gtk.main()
