#!/bin/python

# -*- coding: utf-8 -*-

#

# Copyright (C) 2010-2015 Red Hat, Inc.

#

# Authors:

# Thomas Woerner <twoerner@redhat.com>

#

# 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, see <http://www.gnu.org/licenses/>.

#

import sys

from PyQt5 import QtGui, QtCore, QtWidgets

import gi

gi.require_version('Notify', '0.7')

from gi.repository import Notify

import os

from dbus.mainloop.pyqt5 import DBusQtMainLoop

import functools

from firewall import config

from firewall.core.fw_nm import nm_is_imported, nm_get_zone_of_connection, \

                                nm_set_zone_of_connection, \

                                nm_get_dbus_interface, \

                                nm_get_connections

from firewall.core.watcher import Watcher

from firewall.client import FirewallClient

import slip.dbus

import dbus

import signal

import gettext

gettext.textdomain(config.DOMAIN)

_ = gettext.gettext

PATH = [ ]

for p in os.getenv("PATH").split(":"):

    if p not in PATH:

        PATH.append(p)

def search_app(app):

    for p in PATH:

        _app = "%s/%s" % (p, app)

        if os.path.exists(_app):

            return _app

    return None

NM_CONNECTION_EDITOR = ""

for binary in [ "/usr/bin/nm-connection-editor",

                    "/bin/nm-connection-editor",

                "/usr/bin/kde5-nm-connection-editor",

                    "/bin/kde5-nm-connection-editor",

                "/usr/bin/kde-nm-connection-editor",

                    "/bin/kde-nm-connection-editor" ]:

    if os.path.exists(binary):

        NM_CONNECTION_EDITOR = binary

        break

PY2 = sys.version < '3'

def escape(text):

    text = text.replace('&', '&')

    text = text.replace('>', '>')

    text = text.replace('<', '<')

    return text

def fromUTF8(text):

    if PY2 and QtCore.QT_VERSION < 0x050000:

        return QtCore.QString.fromUtf8(text)

    return text

# ZoneInterfaceEditor #########################################################

class ZoneInterfaceEditor(QtWidgets.QDialog):

    def __init__(self, fw, interface, zone):

        self.fw = fw

        self.interface = interface

        self.zone = None

        self.title = _("Select zone for interface '%s'") % self.interface

        QtWidgets.QDialog.__init__(self)

        self.create_ui(zone)

    def create_ui(self, zone):

        self.setWindowTitle(fromUTF8(escape(self.title)))

        self.rejected.connect(self.hide)

        self.resize(100, 50)

        vbox = QtWidgets.QVBoxLayout()

        vbox.setSpacing(6)

        label = QtWidgets.QLabel(fromUTF8(escape(self.title)))

        vbox.addWidget(label)

        self.combo = QtWidgets.QComboBox()

        self.fill_zone_combo()

        vbox.addWidget(self.combo)

        buttonBox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Ok

                                           | QtWidgets.QDialogButtonBox.Cancel)

        self.ok_button = buttonBox.button(QtWidgets.QDialogButtonBox.Ok)

        buttonBox.accepted.connect(self.ok)

        buttonBox.rejected.connect(self.hide)

        vbox.addWidget(buttonBox)

        self.ok_button.setDisabled(True)

        self.combo.activated.connect(self.combo_changed)

        self.setLayout(vbox)

        self.set_zone(zone)

    def combo_changed(self):

        self.ok_button.setDisabled(self.get_zone() == self.zone)

    def set_zone(self, zone):

        self.zone = zone

        if zone == "":

            self.combo.setCurrentIndex(self.combo.findText(

                escape(_("Default Zone"))))

        else:

            self.combo.setCurrentIndex(self.combo.findText(self.zone))

        self.combo_changed()

    def get_zone(self):

        text = str(self.combo.currentText())

        if text == escape(_("Default Zone")):

            text = ""

        return text

    def fill_zone_combo(self):

        self.combo.clear()

        self.combo.addItem(fromUTF8(escape(_("Default Zone"))))

        for z in self.fw.getZones():

            self.combo.addItem(z)

    def zones_changed(self):

        zone = self.get_zone()

        self.fill_zone_combo()

        self.set_zone(zone)

    def ok(self):

        self.fw.changeZoneOfInterface(self.get_zone(), self.interface)

        self.hide()

# ZoneConnectionEditor ########################################################

class ZoneConnectionEditor(ZoneInterfaceEditor):

    def __init__(self, fw, connection, connection_name, zone):

        self.fw = fw

        self.connection = connection

        self.connection_name = connection_name

        self.zone = None

        self.title = _("Select zone for connection '%s'") % self.connection_name

        QtWidgets.QDialog.__init__(self)

        self.create_ui(zone)

    def ok(self):

        # apply changes

        try:

            nm_set_zone_of_connection(self.get_zone(), self.connection)

        except Exception:

            text = _("Failed to set zone {zone} for connection {connection_name}")

            QtWidgets.QMessageBox.warning(None, fromUTF8(escape(self.title)),

                                      escape(text.format(

                                          zone=self.get_zone(),

                                          connection_name=self.connection_name)))

        self.hide()

# ZoneSourceEditor ############################################################

class ZoneSourceEditor(ZoneInterfaceEditor):

    def __init__(self, fw, source, zone):

        self.fw = fw

        self.source = source

        self.zone = None

        self.title = _("Select zone for source '%s'") % self.source

        QtWidgets.QDialog.__init__(self)

        self.create_ui(zone)

    def ok(self):

        self.fw.changeZoneOfSource(self.get_zone(), self.source)

        self.hide()

# ShieldsEditor #########################################################

class ShieldsEditor(QtWidgets.QDialog):

    def __init__(self, fw, settings, shields_up, shields_down):

        self.fw = fw

        self.settings = settings

        self.shields_up = shields_up

        self.shields_down = shields_down

        self.title = _("Configure Shields Up/Down Zones")

        QtWidgets.QDialog.__init__(self)

        self.create_ui()

    def create_ui(self):

        self.setWindowTitle(fromUTF8(escape(self.title)))

        self.rejected.connect(self.hide)

        vbox = QtWidgets.QVBoxLayout()

        vbox.setSpacing(6)

        label = QtWidgets.QLabel(fromUTF8(escape(

            _("Here you can select the zones used for Shields Up and "

              "Shields Down."))))

        label.setWordWrap(True)

        vbox.addWidget(label)

        label = QtWidgets.QLabel(fromUTF8(escape(

            _("This feature is useful for people using the default zones "

              "mostly. For users, that are changing zones of connections, it "

              "might be of limited use."))))

        label.setWordWrap(True)

        vbox.addWidget(label)

        grid = QtWidgets.QGridLayout()

        grid.setSpacing(6)

        label = QtWidgets.QLabel(fromUTF8(escape(_("Shields Up Zone:"))))

        label.setWordWrap(True)

        grid.addWidget(label, 0, 0, 1, 1)

        self.shields_up_combo = QtWidgets.QComboBox()

        #self.fill_combo(self.shields_up_combo)

        #self.set_shields_up(self.shields_up)

        grid.addWidget(self.shields_up_combo, 0, 1, 1, 1)

        button = QtWidgets.QPushButton(_("Reset To Default"))

        button.clicked.connect(self.reset_shields_up)

        grid.addWidget(button, 0, 2, 1, 1)

        label = QtWidgets.QLabel(fromUTF8(escape(_("Shields Down Zone:"))))

        label.setWordWrap(True)

        grid.addWidget(label, 1, 0, 1, 1)

        self.shields_down_combo = QtWidgets.QComboBox()

        #self.fill_combo(self.shields_down_combo)

        #self.set_shields_down(self.shields_down)

        grid.addWidget(self.shields_down_combo, 1, 1, 1, 1)

        button = QtWidgets.QPushButton(_("Reset To Default"))

        button.clicked.connect(self.reset_shields_down)

        grid.addWidget(button, 1, 2, 1, 1)

        vbox.addLayout(grid)

        buttonBox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Ok

                                           | QtWidgets.QDialogButtonBox.Cancel)

        self.ok_button = buttonBox.button(QtWidgets.QDialogButtonBox.Ok)

        buttonBox.accepted.connect(self.ok)

        buttonBox.rejected.connect(self.hide)

        vbox.addWidget(buttonBox)

        self.ok_button.setDisabled(True)

        self.shields_up_combo.activated.connect(self.shields_combo_changed)

        self.shields_down_combo.activated.connect(self.shields_combo_changed)

        self.setLayout(vbox)

    def shields_combo_changed(self):

        self.ok_button.setDisabled(

            self.get_shields_up() == self.shields_up and \

            self.get_shields_down() == self.shields_down)

    def set_shields_up(self, zone):

        self.shields_up = zone

        if self.shields_up_combo.count() > 0:

            self.shields_up_combo.setCurrentIndex(

                self.shields_up_combo.findText(self.shields_up))

        self.shields_combo_changed()

    def set_shields_down(self, zone):

        self.shields_down = zone

        if self.shields_down_combo.count() > 0:

            self.shields_down_combo.setCurrentIndex(

                self.shields_down_combo.findText(self.shields_down))

        self.shields_combo_changed()

    def reset_shields_up(self):

        self.set_shields_up(self.shields_up)

        # remove user key to get fallback again

        self.settings.remove("shields-up")

    def reset_shields_down(self):

        self.set_shields_down(self.shields_down)

        # remove user key to get fallback again

        self.settings.remove("shields-down")

    def get_shields_up(self):

        return str(self.shields_up_combo.currentText())

    def get_shields_down(self):

        return str(self.shields_down_combo.currentText())

    def zones_changed(self):

        up_zone = self.shields_up

        if self.get_shields_up():

            up_zone = self.get_shields_up()

        down_zone = self.shields_down

        if self.get_shields_down():

            down_zone = self.get_shields_down()

        for z in self.fw.getZones():

            self.shields_up_combo.addItem(z)

            self.shields_down_combo.addItem(z)

        self.set_shields_up(up_zone)

        self.set_shields_down(down_zone)

    def ok(self):

        if self.shields_up != self.get_shields_up():

            self.settings.setValue("shields-up", self.get_shields_up())

        if self.shields_down != self.get_shields_down():

            self.settings.setValue("shields-down", self.get_shields_down())

        self.settings.sync()

        self.hide()

# AboutDialog #################################################################

class AboutDialog(QtWidgets.QDialog):

    def __init__(self, name, icon, version, url, copyright, authors, license):

        QtWidgets.QDialog.__init__(self)

        self.setWindowIcon(icon)

        self.setWindowTitle(fromUTF8(escape(_("About %s" % name))))

        self.resize(500, 250)

        vbox = QtWidgets.QVBoxLayout()

        vbox.setSpacing(6)

        hbox = QtWidgets.QHBoxLayout()

        hbox.setSpacing(24)

        label = QtWidgets.QLabel()

        label.setPixmap(icon.pixmap(96))

        label.setMinimumSize(96, 96)

        label.setMaximumSize(96, 96)

        hbox.addWidget(label)

        vbox2 = QtWidgets.QVBoxLayout()

        vbox2.setSpacing(3)

        label = QtWidgets.QLabel(name)

        font = label.font()

        font.setPointSize(font.pointSize()*2)

        font.setBold(True)

        label.setFont(font)

        vbox2.addWidget(label)

        vbox2.addWidget(QtWidgets.QLabel(version))

        label = QtWidgets.QLabel("%s" % (url, url))

        label.setTextFormat(QtCore.Qt.RichText)

        label.setTextInteractionFlags(QtCore.Qt.TextBrowserInteraction)

        label.setOpenExternalLinks(True)

        vbox2.addWidget(label)

        vbox2.addWidget(QtWidgets.QLabel(copyright))

        hbox.addLayout(vbox2)

        vbox.addLayout(hbox)

        tabs = QtWidgets.QTabWidget()

        tabs.setStyleSheet("QTabWidget::tab { padding: 1px 1px 1px 1px; }")

        tab = QtWidgets.QWidget()

        vbox3 = QtWidgets.QVBoxLayout()

        textedit = QtWidgets.QPlainTextEdit()

        #textedit.setStyleSheet("QPlainTextEdit { border: 0; padding: 0; }")

        textedit.setReadOnly(True)

        textedit.setPlainText(fromUTF8("\n".join(authors)))

        vbox3.addWidget(textedit)

        tab.setLayout(vbox3)

        tabs.addTab(tab, fromUTF8(escape(_("Authors"))))

        tab = QtWidgets.QWidget()

        vbox3 = QtWidgets.QVBoxLayout()

        textedit = QtWidgets.QPlainTextEdit()

        #textedit.setStyleSheet("QPlainTextEdit { border: 0; padding: 0; }")

        textedit.setReadOnly(True)

        textedit.setPlainText(license)

        vbox3.addWidget(textedit)

        tab.setLayout(vbox3)

        tabs.addTab(tab, fromUTF8(escape(_("License"))))

        vbox.addWidget(tabs)

        buttonBox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Close)

        buttonBox.rejected.connect(self.hide)

        vbox.addWidget(buttonBox)

        self.setLayout(vbox)

# TrayApplet ##################################################################

class TrayApplet(QtWidgets.QSystemTrayIcon):

    def __init__(self):

        super(TrayApplet, self).__init__()

        self.name = _("Firewall Applet")

        self.prog = "firewall-applet"

        self.icon_name = "firewall-applet"

        self.icons = {

            "normal": QtGui.QIcon.fromTheme(self.icon_name),

            "error": QtGui.QIcon.fromTheme(self.icon_name+"-error"),

            "panic": QtGui.QIcon.fromTheme(self.icon_name+"-panic"),

            "normal-shields_up": QtGui.QIcon.fromTheme(self.icon_name+"-shields_up"),

            "normal-shields_down": QtGui.QIcon.fromTheme(self.icon_name+"-shields_down"),

        }

        self.timer = None

        self.mode = None

        self.blink = False

        self.blink_count = 0

        self._blink = False

        self._blink_count = 0

        self.show_inactive = False

        self.tooltip_messages = [ ]

        self.active_zones = { }

        self.connections = { }

        self.connections_name = { }

        self.default_zone = None

        self.zone_connection_editors = { }

        self.zone_interface_editors = { }

        self.zone_source_editors = { }

        # settings

        self.settings = QtCore.QSettings("firewall", "applet")

        # file system watcher

        self.watcher = Watcher(self.load_settings, 2)

        self.watcher.add_watch_file("/etc/firewall/applet.conf")

        self.watcher.add_watch_file(str(self.settings.fileName()))

        # about dialog

        self.about_dialog = AboutDialog(self.name,

                                        self.icons["normal"],

                                        config.VERSION, config.WEBSITE,

                                        config.COPYRIGHT, config.AUTHORS,

                                        config.LICENSE)

        # urgencies

        self.urgencies = { "noicon": QtWidgets.QSystemTrayIcon.NoIcon,

                           "information": QtWidgets.QSystemTrayIcon.Information,

                           "warning": QtWidgets.QSystemTrayIcon.Warning,

                           "critical": QtWidgets.QSystemTrayIcon.Critical }

        # actions

        self.shieldsupAction = QtWidgets.QAction(fromUTF8(escape(_("Shields Up"))),

                                             self)

        self.shieldsupAction.setCheckable(True)

        self.shieldsupAction.setChecked(False)

        self.shieldsupAction.triggered.connect(self.shieldsup_changed_cb)

        self.notificationsAction = QtWidgets.QAction(

            fromUTF8(escape(_("Enable Notifications"))), self)

        self.notificationsAction.setCheckable(True)

        self.notificationsAction.setChecked(False)

        self.notificationsAction.triggered.connect(self.notification_changed_cb)

        self.settingsAction = QtWidgets.QAction(

            fromUTF8(escape(_("Edit Firewall Settings..."))), self)

        self.settingsAction.triggered.connect(self.configure_cb)

        self.changeZonesAction = QtWidgets.QAction(

            fromUTF8(escape(_("Change Zones of Connections..."))), self)

        self.changeZonesAction.triggered.connect(self.nm_connection_editor)

        self.shieldsAction = QtWidgets.QAction(

            fromUTF8(escape(_("Configure Shields UP/Down Zones..."))), self)

        self.shieldsAction.triggered.connect(self.configure_shields)

        self.panicAction = QtWidgets.QAction(

            fromUTF8(escape(_("Block all network traffic"))), self)

        self.panicAction.setCheckable(True)

        self.panicAction.setChecked(False)

        self.panicAction.triggered.connect(self.panic_mode_cb)

        self.aboutAction = QtWidgets.QAction(fromUTF8(escape(_("About"))), self)

        self.aboutAction.triggered.connect(self.about_dialog.exec_)

        #self.quitAction = QtWidgets.QAction(fromUTF8(escape(_("Quit"))), self,

        #                                triggered=self.quit)

        self.connectionsAction = QtWidgets.QWidgetAction(self)

        self.connectionsAction.setDefaultWidget(QtWidgets.QLabel(

            fromUTF8(""+escape(_("Connections"))+" ")))

        self.interfacesAction = QtWidgets.QWidgetAction(self)

        self.interfacesAction.setDefaultWidget(QtWidgets.QLabel(

            fromUTF8(""+escape(_("Interfaces"))+" ")))

        self.sourcesAction = QtWidgets.QWidgetAction(self)

        self.sourcesAction.setDefaultWidget(QtWidgets.QLabel(

            fromUTF8(""+escape(_("Sources"))+" ")))

        # init

        self.left_menu = QtWidgets.QMenu()

        self.left_menu.setStyleSheet('QMenu { margin: 5px; }')

        self.right_menu = QtWidgets.QMenu()

        self.right_menu.addAction(self.shieldsupAction)

        self.right_menu.addAction(self.notificationsAction)

        self.right_menu.addSeparator()

        self.right_menu.addAction(self.settingsAction)

        self.right_menu.addAction(self.changeZonesAction)

        self.right_menu.addAction(self.shieldsAction)

        self.right_menu.addSeparator()

        self.right_menu.addAction(self.panicAction)

        self.right_menu.addSeparator()

        self.right_menu.addAction(self.aboutAction)

        #self.right_menu.addSeparator()

        #self.right_menu.addAction(self.quitAction)

        self.setContextMenu(self.right_menu)

        self.activated.connect(self.activated_cb)

        self.set_mode("error")

        self.set_icon()

        self.setVisible(self.show_inactive)

        # init notification

        Notify.init(self.prog)

        # connect to firewalld

        DBusQtMainLoop(set_as_default=True)

        try:

            self.bus = slip.dbus.SystemBus()

            self.bus.default_timeout = None

        except Exception as msg:

            print("Not using slip", msg)

            self.bus = dbus.SystemBus()

        if nm_is_imported():

            self.bus.add_signal_receiver(

                self.nm_signal_receiver,

                dbus_interface=nm_get_dbus_interface(),

                signal_name='PropertiesChanged',

                member_keyword='member')

        self.nm_signal_receiver()

        self.fw = FirewallClient(self.bus, wait=1)

        self.fw.setExceptionHandler(self._exception_handler)

        self.fw.connect("connection-established", self.connection_established)

        self.fw.connect("connection-lost", self.connection_lost)

        self.fw.connect("reloaded", self.reloaded),

        self.fw.connect("default-zone-changed", self.default_zone_changed)

        self.fw.connect("panic-mode-enabled", self.panic_mode_enabled)

        self.fw.connect("panic-mode-disabled", self.panic_mode_disabled)

        self.fw.connect("interface-added", self.interface_added)

        self.fw.connect("interface-removed", self.interface_removed)

        self.fw.connect("zone-of-interface-changed",

                        self.zone_of_interface_changed)

        self.fw.connect("source-added", self.source_added)

        self.fw.connect("source-removed", self.source_removed)

        self.fw.connect("zone-of-source-changed",

                        self.zone_of_source_changed)

        self.shields_editor = ShieldsEditor(self.fw, self.settings, None, None)

        self.load_settings()

    def _exception_handler(self, exception_message):

        if "NotAuthorizedException" in exception_message:

            self.error(fromUTF8(escape(_("Authorization failed."))))

        elif "INVALID_NAME" in exception_message:

            msg = exception_message.replace("INVALID_NAME", _("Invalid name"))

            self.warning(fromUTF8(escape(msg)))

        elif "NAME_CONFLICT" in exception_message:

            msg = exception_message.replace("NAME_CONFLICT",

                                            _("Name already exists"))

            self.warning(fromUTF8(escape(msg)))

        elif "NO_DEFAULTS" in exception_message:

            pass

        else:

            self.error(fromUTF8(exception_message))

    def quit(self):

        sys.exit(1)

    def set_icon(self, mode=None):

        if mode is not None:

            self.setIcon(self.icons[mode])

        elif self.mode != "normal":

            self.setIcon(self.icons[self.mode])

        elif self.default_zone == self.shields_up:

            self.setIcon(self.icons["normal-shields_up"])

        else:

            self.setIcon(self.icons["normal-shields_down"])

    def load_settings(self, name=None):

        self.settings.sync()

        notifications = self.settings.value("notifications", False, type=bool)

        self.notificationsAction.setChecked(notifications)

        self.show_inactive = self.settings.value("show-inactive", False,

                                                 type=bool)

        self.blink = self.settings.value("blink", False, type=bool)

        self.blink_count = self.settings.value("blink-count", 5, type=int)

        self.shields_up = self.settings.value("shields-up", "block", type=str)

        if self.default_zone:

            self.shieldsupAction.setChecked(

                self.default_zone == self.shields_up)

        self.shields_editor.set_shields_up(self.shields_up)

        self.shields_down = self.settings.value("shields-down", "public",

                                                type=str)

        self.shields_editor.set_shields_down(self.shields_down)

        #print("shields-up=%s" % self.shields_up)

        #print("notifications=%s" % notifications)

        #print("blink=%s" % self.blink)

        #print("blink-count=%s" % self.blink_count)

        #print("show-inactive=%s" % self.show_inactive)

        if not self.fw.connected:

            self.setVisible(self.show_inactive)

        else:

            self.setVisible(True)

    def activated_cb(self, reason):

        if reason == QtWidgets.QSystemTrayIcon.Trigger:

            self.left_menu.popup(QtGui.QCursor.pos())

    def update_active_zones(self):

        self.active_zones.clear()

        # remove all entries for the left menu

        self.left_menu.clear()

        # add connections entry

        self.left_menu.addAction(self.connectionsAction)

        if not self.fw.connected:

            return

        active_zones = self.fw.getActiveZones()

        if active_zones:

            self.active_zones = active_zones

        # get all active connections (NM) and interfaces

        connections = { }

        interfaces = { }

        sources = { }

        for zone in sorted(self.active_zones):

            if "interfaces" in self.active_zones[zone]:

                for interface in sorted(self.active_zones[zone]["interfaces"]):

                    if interface not in self.connections:

                        interfaces[interface] = zone

            if "sources" in self.active_zones[zone]:

                for source in sorted(self.active_zones[zone]["sources"]):

                    sources[source] = zone

        # NM controlled connections

        for interface in self.connections:

            connection = self.connections[interface]

            if connection not in self.connections_name:

                connection_name = None

            else:

                connection_name = self.connections_name[connection]

            zone = nm_get_zone_of_connection(connection)

            connections[connection] = [ zone, connection_name ]

        binding = _("{entry} (Zone: {zone})")

        # add NM controlled bindings

        for connection in sorted(connections):

            zone = connections[connection][0]

            connection_name = connections[connection][1]

            if zone == "":

                _binding = _("{entry} (Default Zone: {default_zone})")

                action = QtWidgets.QAction(

                    fromUTF8(escape(

                        _binding.format(default_zone=self.default_zone,

                                        entry=connection_name))), self)

            else:

                action = QtWidgets.QAction(

                    fromUTF8(escape(binding.format(zone=zone,

                                                   entry=connection_name))), self)

            action.triggered.connect(functools.partial(

                self.zone_connection_editor, connection, connection_name, zone))

            self.left_menu.addAction(action)

        # add interfaces entry

        self.left_menu.addAction(self.interfacesAction)

        # add other interfaces

        for interface in sorted(interfaces):

            zone = interfaces[interface]

            action = QtWidgets.QAction(

                fromUTF8(escape(binding.format(zone=zone, entry=interface))),

                self)

            action.triggered.connect(functools.partial(

                self.zone_interface_editor, interface, zone))

            self.left_menu.addAction(action)

        # add interfaces entry

        self.left_menu.addAction(self.sourcesAction)

        for source in sorted(sources):

            zone = sources[source]

            action = QtWidgets.QAction(

                fromUTF8(escape(binding.format(zone=zone, entry=source))),

                self)

            action.triggered.connect(functools.partial(

                self.zone_source_editor, source, zone))

            self.left_menu.addAction(action)

    def zone_interface_editor(self, interface, zone):

        if interface in self.zone_interface_editors:

            self.zone_interface_editors[interface].set_zone(zone)

            self.zone_interface_editors[interface].show()

            return self.zone_interface_editors[interface].raise_()

        editor = ZoneInterfaceEditor(self.fw, interface, zone)

        self.zone_interface_editors[interface] = editor

        editor.show()

        editor.raise_()

        editor.show()

    def zone_connection_editor(self, connection, connection_name, zone):

        if connection in self.zone_connection_editors:

            self.zone_connection_editors[connection].set_zone(zone)

            self.zone_connection_editors[connection].show()

            return self.zone_connection_editors[connection].raise_()

        editor = ZoneConnectionEditor(self.fw, connection, connection_name, zone)

        self.zone_connection_editors[connection] = editor

        editor.show()

        editor.raise_()

        editor.show()

    def zone_source_editor(self, source, zone):

        if source in self.zone_source_editors:

            self.zone_source_editors[source].set_zone(zone)

            self.zone_source_editors[source].show()

            return self.zone_source_editors[source].raise_()

        editor = ZoneSourceEditor(self.fw, source, zone)

        self.zone_source_editors[source] = editor

        editor.show()

        editor.raise_()

        editor.show()

    def nm_signal_receiver(self, *args, **kwargs):

        self.connections.clear()

        self.connections_name.clear()

        # do not use NMClient could result in python core dump

        if nm_is_imported():

            text = _("Failed to get connections from NetworkManager")

            try:

                nm_get_connections(self.connections, self.connections_name)

            except Exception:

                self.notify(escape(text), urgency=Notify.Urgency.CRITICAL)

                if text not in self.tooltip_messages:

                    self.tooltip_messages.append(text)

            else:

                if text in self.tooltip_messages:

                    self.tooltip_messages.remove(text)

        else:

            text = _("No NetworkManager imports available")

            self.notify(escape(text), urgency=Notify.Urgency.CRITICAL)

            if text not in self.tooltip_messages:

                self.tooltip_messages.append(text)

        self.update_tooltip()

    def notify(self, msg, urgency="noicon", timeout=5):

        #self.showMessage(fromUTF8(escape(self.name)), msg, self.urgencies[urgency], timeout*1000)

        n = Notify.Notification.new(escape(self.name), msg, self.icon_name)

        n.set_urgency(Notify.Urgency.NORMAL)

        try:

            n.show()

        except:

            return

    def shieldsup_changed_cb(self):

        if self.shieldsupAction.isChecked():

            zone = str(self.shields_up)

        else:

            zone = str(self.shields_down)

        if self.fw.connected and self.default_zone != zone:

            try:

                self.fw.setDefaultZone(zone)

            except dbus.exceptions.DBusException as e:

                print("Error: %s" % e.get_dbus_message())

    def notification_changed_cb(self):

        self.settings.setValue("notifications",

                               self.notificationsAction.isChecked())

        self.settings.sync()

    def __blink(self, arg=None):

        if self._blink_count != 0:

            if self._blink_count > 0 and self._blink:

                self._blink_count -= 1

            self._blink = not self._blink

            if not self.timer:

                self.timer = QtCore.QTimer(self)

                self.timer.timeout.connect(self.__blink)

                self.timer.setInterval(1000)

            self.timer.start()

        if not self._blink:

            self.set_icon()

        else:

            self.set_icon("normal")

    def get_mode(self):

        return self.mode

    def set_mode(self, mode):

        if self.mode != mode:

            if self.timer and self.timer.isActive():

                self.timer.stop()

                self._blink = False

            self.mode = mode

        elif self.mode == mode and self.timer:

            if self._blink_count == 0:

                self._blink_count += 1

            return

        if mode == "normal":

            self.set_icon()

            return

        if self.blink:

            if self.blink_count != 0:

                self._blink = True

                self._blink_count = self.blink_count

                self.__blink()

        else:

            self.set_icon()

    def update_tooltip(self):

        if self.get_mode() == "error":

            self.setToolTip(fromUTF8("<big>" + \

                                     _("No connection to firewall daemon") + \

                                     "</big>"))

            return

        messages = [ ]

        if self.panicAction.isChecked():

            messages.append("<big>" + \

                            _("All network traffic is blocked.") + \

                            "</big>")

        if self.default_zone: