CHIRP

# Copyright 2008 Dan Smith <dsmith@danplanet.com>

# Copyright 2012 Tom Hayward <tom@tomh.us>

#

# 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 3 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 os

import tempfile

import urllib

import webbrowser

from glob import glob

import shutil

import time

import logging

import gtk

import gobject

import sys

from chirp.ui import inputdialog, common

from chirp import platform, directory, util

from chirp.drivers import generic_xml, generic_csv

from chirp.drivers import ic9x, kenwood_live, idrp, vx7, vx5, vx6

from chirp.drivers import icf, ic9x_icf

from chirp import CHIRP_VERSION, chirp_common, detect, errors

from chirp.ui import editorset, clone, miscwidgets, config, reporting, fips

from chirp.ui import bandplans

gobject.threads_init()

LOG = logging.getLogger(__name__)

if __name__ == "__main__":

    sys.path.insert(0, "..")

try:

    import serial

except ImportError, e:

    common.log_exception()

    common.show_error("\nThe Pyserial module is not installed!")

CONF = config.get()

KEEP_RECENT = 8

RB_BANDS = {

    "--All--":                  0,

    "10 meters (29MHz)":        29,

    "6 meters (54MHz)":         5,

    "2 meters (144MHz)":        14,

    "1.25 meters (220MHz)":     22,

    "70 centimeters (440MHz)":  4,

    "33 centimeters (900MHz)":  9,

    "23 centimeters (1.2GHz)":  12,

}

def key_bands(band):

    if band.startswith("-"):

        return -1

    amount, units, mhz = band.split(" ")

    scale = units == "meters" and 100 or 1

    return 100000 - (float(amount) * scale)

class ModifiedError(Exception):

    pass

class ChirpMain(gtk.Window):

    def get_current_editorset(self):

        page = self.tabs.get_current_page()

        if page is not None:

            return self.tabs.get_nth_page(page)

        else:

            return None

    def ev_tab_switched(self, pagenum=None):

        def set_action_sensitive(action, sensitive):

            self.menu_ag.get_action(action).set_sensitive(sensitive)

        if pagenum is not None:

            eset = self.tabs.get_nth_page(pagenum)

        else:

            eset = self.get_current_editorset()

        upload_sens = bool(eset and

                           isinstance(eset.radio, chirp_common.CloneModeRadio))

        if not eset or isinstance(eset.radio, chirp_common.LiveRadio):

            save_sens = False

        elif isinstance(eset.radio, chirp_common.NetworkSourceRadio):

            save_sens = False

        else:

            save_sens = True

        for i in ["import", "importsrc", "stock"]:

            set_action_sensitive(i,

                                 eset is not None and not eset.get_read_only())

        for i in ["save", "saveas"]:

            set_action_sensitive(i, save_sens)

        for i in ["upload"]:

            set_action_sensitive(i, upload_sens)

        for i in ["cancelq"]:

            set_action_sensitive(i, eset is not None and not save_sens)

        for i in ["export", "close", "columns", "irbook", "irfinder",

                  "move_up", "move_dn", "exchange", "iradioreference",

                  "cut", "copy", "paste", "delete", "viewdeveloper",

                  "all", "properties"]:

            set_action_sensitive(i, eset is not None)

    def ev_status(self, editorset, msg):

        self.sb_radio.pop(0)

        self.sb_radio.push(0, msg)

    def ev_usermsg(self, editorset, msg):

        self.sb_general.pop(0)

        self.sb_general.push(0, msg)

    def ev_editor_selected(self, editorset, editortype):

        mappings = {

            "memedit": ["view", "edit"],

            }

        for _editortype, actions in mappings.items():

            for _action in actions:

                action = self.menu_ag.get_action(_action)

                action.set_sensitive(editortype.startswith(_editortype))

    def _connect_editorset(self, eset):

        eset.connect("want-close", self.do_close)

        eset.connect("status", self.ev_status)

        eset.connect("usermsg", self.ev_usermsg)

        eset.connect("editor-selected", self.ev_editor_selected)

    def do_diff_radio(self):

        if self.tabs.get_n_pages() < 2:

            common.show_error("Diff tabs requires at least two open tabs!")

            return

        esets = []

        for i in range(0, self.tabs.get_n_pages()):

            esets.append(self.tabs.get_nth_page(i))

        d = gtk.Dialog(title="Diff Radios",

                       buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,

                                gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL),

                       parent=self)

        label = gtk.Label("")

        label.set_markup("<b>-1</b> for either Mem # does a full-file hex " +

                         "dump with diffs highlighted.\n" +

                         "<b>-2</b> for first Mem # shows " +

                         "<b>only</b> the diffs.")

        d.vbox.pack_start(label, True, True, 0)

        label.show()

        choices = []

        for eset in esets:

            choices.append("%s %s (%s)" % (eset.rthread.radio.VENDOR,

                                           eset.rthread.radio.MODEL,

                                           eset.filename))

        choice_a = miscwidgets.make_choice(choices, False, choices[0])

        choice_a.show()

        chan_a = gtk.SpinButton()

        chan_a.get_adjustment().set_all(1, -2, 999, 1, 10, 0)

        chan_a.show()

        hbox = gtk.HBox(False, 3)

        hbox.pack_start(choice_a, 1, 1, 1)

        hbox.pack_start(chan_a, 0, 0, 0)

        hbox.show()

        d.vbox.pack_start(hbox, 0, 0, 0)

        choice_b = miscwidgets.make_choice(choices, False, choices[1])

        choice_b.show()

        chan_b = gtk.SpinButton()

        chan_b.get_adjustment().set_all(1, -1, 999, 1, 10, 0)

        chan_b.show()

        hbox = gtk.HBox(False, 3)

        hbox.pack_start(choice_b, 1, 1, 1)

        hbox.pack_start(chan_b, 0, 0, 0)

        hbox.show()

        d.vbox.pack_start(hbox, 0, 0, 0)

        r = d.run()

        sel_a = choice_a.get_active_text()

        sel_chan_a = chan_a.get_value()

        sel_b = choice_b.get_active_text()

        sel_chan_b = chan_b.get_value()

        d.destroy()

        if r == gtk.RESPONSE_CANCEL:

            return

        if sel_a == sel_b:

            common.show_error("Can't diff the same tab!")

            return

        LOG.debug("Selected %s@%i and %s@%i" %

                  (sel_a, sel_chan_a, sel_b, sel_chan_b))

        name_a = os.path.basename(sel_a)

        name_a = name_a[:name_a.rindex(")")]

        name_b = os.path.basename(sel_b)

        name_b = name_b[:name_b.rindex(")")]

        diffwintitle = "%s@%i  diff  %s@%i" % (

            name_a, sel_chan_a, name_b, sel_chan_b)

        eset_a = esets[choices.index(sel_a)]

        eset_b = esets[choices.index(sel_b)]

        def _show_diff(mem_b, mem_a):

            # Step 3: Show the diff

            diff = common.simple_diff(mem_a, mem_b)

            common.show_diff_blob(diffwintitle, diff)

        def _get_mem_b(mem_a):

            # Step 2: Get memory b

            job = common.RadioJob(_show_diff, "get_raw_memory",

                                  int(sel_chan_b))

            job.set_cb_args(mem_a)

            eset_b.rthread.submit(job)

        if sel_chan_a >= 0 and sel_chan_b >= 0:

            # Diff numbered memory

            # Step 1: Get memory a

            job = common.RadioJob(_get_mem_b, "get_raw_memory",

                                  int(sel_chan_a))

            eset_a.rthread.submit(job)

        elif isinstance(eset_a.rthread.radio, chirp_common.CloneModeRadio) and\

                isinstance(eset_b.rthread.radio, chirp_common.CloneModeRadio):

            # Diff whole (can do this without a job, since both are clone-mode)

            try:

                addrfmt = CONF.get('hexdump_addrfmt', section='developer',

                                   raw=True)

            except:

                pass

            a = util.hexprint(eset_a.rthread.radio._mmap.get_packed(),

                              addrfmt=addrfmt)

            b = util.hexprint(eset_b.rthread.radio._mmap.get_packed(),

                              addrfmt=addrfmt)

            if sel_chan_a == -2:

                diffsonly = True

            else:

                diffsonly = False

            common.show_diff_blob(diffwintitle,

                                  common.simple_diff(a, b, diffsonly))

        else:

            common.show_error("Cannot diff whole live-mode radios!")

    def do_new(self):

        eset = editorset.EditorSet(_("Untitled") + ".csv", self)

        self._connect_editorset(eset)

        eset.prime()

        eset.show()

        tab = self.tabs.append_page(eset, eset.get_tab_label())

        self.tabs.set_current_page(tab)

    def _do_manual_select(self, filename):

        radiolist = {}

        for drv, radio in directory.DRV_TO_RADIO.items():

            if not issubclass(radio, chirp_common.CloneModeRadio):

                continue

            radiolist["%s %s" % (radio.VENDOR, radio.MODEL)] = drv

        lab = gtk.Label("""<b><big>Unable to detect model!</big></b>

If you think that it is valid, you can select a radio model below to

force an open attempt. If selecting the model manually works, please

file a bug on the website and attach your image. If selecting the model

does not work, it is likely that you are trying to open some other type

of file.

""")

        lab.set_justify(gtk.JUSTIFY_FILL)

        lab.set_line_wrap(True)

        lab.set_use_markup(True)

        lab.show()

        choice = miscwidgets.make_choice(sorted(radiolist.keys()), False,

                                         sorted(radiolist.keys())[0])

        d = gtk.Dialog(title="Detection Failed",

                       buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,

                                gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))

        d.vbox.pack_start(lab, 0, 0, 0)

        d.vbox.pack_start(choice, 0, 0, 0)

        d.vbox.set_spacing(5)

        choice.show()

        d.set_default_size(400, 200)

        # d.set_resizable(False)

        r = d.run()

        d.destroy()

        if r != gtk.RESPONSE_OK:

            return

        try:

            rc = directory.DRV_TO_RADIO[radiolist[choice.get_active_text()]]

            return rc(filename)

        except:

            return

    def do_open(self, fname=None, tempname=None):

        if not fname:

            types = [(_("CHIRP Radio Images") + " (*.img)", "*.img"),

                     (_("CHIRP Files") + " (*.chirp)", "*.chirp"),

                     (_("CSV Files") + " (*.csv)", "*.csv"),

                     (_("DAT Files") + " (*.dat)", "*.dat"),

                     (_("EVE Files (VX5)") + " (*.eve)", "*.eve"),

                     (_("ICF Files") + " (*.icf)", "*.icf"),

                     (_("VX5 Commander Files") + " (*.vx5)", "*.vx5"),

                     (_("VX6 Commander Files") + " (*.vx6)", "*.vx6"),

                     (_("VX7 Commander Files") + " (*.vx7)", "*.vx7"),

                     ]

            fname = platform.get_platform().gui_open_file(types=types)

            if not fname:

                return

        self.record_recent_file(fname)

        if icf.is_icf_file(fname):

            a = common.ask_yesno_question(

                _("ICF files cannot be edited, only displayed or imported "

                  "into another file. Open in read-only mode?"),

                self)

            if not a:

                return

            read_only = True

        else:

            read_only = False

        if icf.is_9x_icf(fname):

            # We have to actually instantiate the IC9xICFRadio to get its

            # sub-devices

            radio = ic9x_icf.IC9xICFRadio(fname)

        else:

            try:

                radio = directory.get_radio_by_image(fname)

            except errors.ImageDetectFailed:

                radio = self._do_manual_select(fname)

                if not radio:

                    return

                LOG.debug("Manually selected %s" % radio)

            except Exception, e:

                common.log_exception()

                common.show_error(os.path.basename(fname) + ": " + str(e))

                return

        first_tab = False

        try:

            eset = editorset.EditorSet(radio, self,

                                       filename=fname,

                                       tempname=tempname)

        except Exception, e:

            common.log_exception()

            common.show_error(

                _("There was an error opening {fname}: {error}").format(

                    fname=fname,

                    error=e))

            return

        eset.set_read_only(read_only)

        self._connect_editorset(eset)

        eset.show()

        self.tabs.append_page(eset, eset.get_tab_label())

        if hasattr(eset.rthread.radio, "errors") and \

                eset.rthread.radio.errors:

            msg = _("{num} errors during open:").format(

                num=len(eset.rthread.radio.errors))

            common.show_error_text(msg,

                                   "\r\n".join(eset.rthread.radio.errors))

    def do_live_warning(self, radio):

        d = gtk.MessageDialog(parent=self, buttons=gtk.BUTTONS_OK)

        d.set_markup("<big><b>" + _("Note:") + "</b></big>")

        msg = _("The {vendor} {model} operates in <b>live mode</b>. "

                "This means that any changes you make are immediately sent "

                "to the radio. Because of this, you cannot perform the "

                "<u>Save</u> or <u>Upload</u> operations. If you wish to "

                "edit the contents offline, please <u>Export</u> to a CSV "

                "file, using the <b>File menu</b>.")

        msg = msg.format(vendor=radio.VENDOR, model=radio.MODEL)

        d.format_secondary_markup(msg)

        again = gtk.CheckButton(_("Don't show this again"))

        again.show()

        d.vbox.pack_start(again, 0, 0, 0)

        d.run()

        CONF.set_bool("live_mode", again.get_active(), "noconfirm")

        d.destroy()

    def do_open_live(self, radio, tempname=None, read_only=False):

        eset = editorset.EditorSet(radio, self, tempname=tempname)

        eset.connect("want-close", self.do_close)

        eset.connect("status", self.ev_status)

        eset.set_read_only(read_only)

        eset.show()

        self.tabs.append_page(eset, eset.get_tab_label())

        if isinstance(radio, chirp_common.LiveRadio):

            reporting.report_model_usage(radio, "live", True)

            if not CONF.get_bool("live_mode", "noconfirm"):

                self.do_live_warning(radio)

    def do_save(self, eset=None):

        if not eset:

            eset = self.get_current_editorset()

        # For usability, allow Ctrl-S to short-circuit to Save-As if

        # we are working on a yet-to-be-saved image

        if not os.path.exists(eset.filename):

            return self.do_saveas()

        eset.save()

    def do_saveas(self):

        eset = self.get_current_editorset()

        label = _("{vendor} {model} image file").format(

            vendor=eset.radio.VENDOR,

            model=eset.radio.MODEL)

        types = [(label + " (*.%s)" % eset.radio.FILE_EXTENSION,

                 eset.radio.FILE_EXTENSION)]

        if isinstance(eset.radio, vx7.VX7Radio):

            types += [(_("VX7 Commander") + " (*.vx7)", "vx7")]

        elif isinstance(eset.radio, vx6.VX6Radio):

            types += [(_("VX6 Commander") + " (*.vx6)", "vx6")]

        elif isinstance(eset.radio, vx5.VX5Radio):

            types += [(_("EVE") + " (*.eve)", "eve")]

            types += [(_("VX5 Commander") + " (*.vx5)", "vx5")]

        while True:

            fname = platform.get_platform().gui_save_file(types=types)

            if not fname:

                return

            if os.path.exists(fname):

                dlg = inputdialog.OverwriteDialog(fname)

                owrite = dlg.run()

                dlg.destroy()

                if owrite == gtk.RESPONSE_OK:

                    break

            else:

                break

        try:

            eset.save(fname)

        except Exception, e:

            d = inputdialog.ExceptionDialog(e)

            d.run()

            d.destroy()

    def cb_clonein(self, radio, emsg=None):

        radio.pipe.close()

        reporting.report_model_usage(radio, "download", bool(emsg))

        if not emsg:

            self.do_open_live(radio, tempname="(" + _("Untitled") + ")")

        else:

            d = inputdialog.ExceptionDialog(emsg)

            d.run()

            d.destroy()

    def cb_cloneout(self, radio, emsg=None):

        radio.pipe.close()

        reporting.report_model_usage(radio, "upload", True)

        if emsg:

            d = inputdialog.ExceptionDialog(emsg)

            d.run()

            d.destroy()

    def _get_recent_list(self):

        recent = []

        for i in range(0, KEEP_RECENT):

            fn = CONF.get("recent%i" % i, "state")

            if fn:

                recent.append(fn)

        return recent

    def _set_recent_list(self, recent):

        for fn in recent:

            CONF.set("recent%i" % recent.index(fn), fn, "state")

    def update_recent_files(self):

        i = 0

        for fname in self._get_recent_list():

            action_name = "recent%i" % i

            path = "/MenuBar/file/recent"

            old_action = self.menu_ag.get_action(action_name)

            if old_action:

                self.menu_ag.remove_action(old_action)

            file_basename = os.path.basename(fname).replace("_", "__")

            action = gtk.Action(

                action_name, "_%i. %s" % (i+1, file_basename),

                _("Open recent file {name}").format(name=fname), "")

            action.connect("activate", lambda a, f: self.do_open(f), fname)

            mid = self.menu_uim.new_merge_id()

            self.menu_uim.add_ui(mid, path,

                                 action_name, action_name,

                                 gtk.UI_MANAGER_MENUITEM, False)

            self.menu_ag.add_action(action)

            i += 1

    def record_recent_file(self, filename):

        recent_files = self._get_recent_list()

        if filename not in recent_files:

            if len(recent_files) == KEEP_RECENT:

                del recent_files[-1]

            recent_files.insert(0, filename)

            self._set_recent_list(recent_files)

        self.update_recent_files()

    def import_stock_config(self, action, config):

        eset = self.get_current_editorset()

        count = eset.do_import(config)

    def copy_shipped_stock_configs(self, stock_dir):

        execpath = platform.get_platform().executable_path()

        basepath = os.path.abspath(os.path.join(execpath, "stock_configs"))

        if not os.path.exists(basepath):

            basepath = "/usr/share/chirp/stock_configs"

        files = glob(os.path.join(basepath, "*.csv"))

        for fn in files:

            if os.path.exists(os.path.join(stock_dir, os.path.basename(fn))):

                LOG.info("Skipping existing stock config")

                continue

            try:

                shutil.copy(fn, stock_dir)

                LOG.debug("Copying %s -> %s" % (fn, stock_dir))

            except Exception, e:

                LOG.error("Unable to copy %s to %s: %s" % (fn, stock_dir, e))

                return False

        return True

    def update_stock_configs(self):

        stock_dir = platform.get_platform().config_file("stock_configs")

        if not os.path.isdir(stock_dir):

            try:

                os.mkdir(stock_dir)

            except Exception, e:

                LOG.error("Unable to create directory: %s" % stock_dir)

                return

        if not self.copy_shipped_stock_configs(stock_dir):

            return

        def _do_import_action(config):

            name = os.path.splitext(os.path.basename(config))[0]

            action_name = "stock-%i" % configs.index(config)

            path = "/MenuBar/radio/stock"

            action = gtk.Action(action_name,

                                name,

                                _("Import stock "

                                  "configuration {name}").format(name=name),

                                "")

            action.connect("activate", self.import_stock_config, config)

            mid = self.menu_uim.new_merge_id()

            mid = self.menu_uim.add_ui(mid, path,

                                       action_name, action_name,

                                       gtk.UI_MANAGER_MENUITEM, False)

            self.menu_ag.add_action(action)

        def _do_open_action(config):

            name = os.path.splitext(os.path.basename(config))[0]

            action_name = "openstock-%i" % configs.index(config)

            path = "/MenuBar/file/openstock"

            action = gtk.Action(action_name,

                                name,

                                _("Open stock "

                                  "configuration {name}").format(name=name),

                                "")

            action.connect("activate", lambda a, c: self.do_open(c), config)

            mid = self.menu_uim.new_merge_id()

            mid = self.menu_uim.add_ui(mid, path,

                                       action_name, action_name,

                                       gtk.UI_MANAGER_MENUITEM, False)

            self.menu_ag.add_action(action)

        configs = glob(os.path.join(stock_dir, "*.csv"))

        for config in configs:

            _do_import_action(config)

            _do_open_action(config)

    def _confirm_experimental(self, rclass):

        sql_key = "warn_experimental_%s" % directory.radio_class_id(rclass)

        if CONF.is_defined(sql_key, "state") and \

                not CONF.get_bool(sql_key, "state"):

            return True

        title = _("Proceed with experimental driver?")

        text = rclass.get_prompts().experimental

        msg = _("This radio's driver is experimental. "

                "Do you want to proceed?")

        resp, squelch = common.show_warning(msg, text,

                                            title=title,

                                            buttons=gtk.BUTTONS_YES_NO,

                                            can_squelch=True)

        if resp == gtk.RESPONSE_YES:

            CONF.set_bool(sql_key, not squelch, "state")

        return resp == gtk.RESPONSE_YES

    def _show_instructions(self, radio, message):

        if message is None:

            return

        if CONF.get_bool("clone_instructions", "noconfirm"):

            return

        d = gtk.MessageDialog(parent=self, buttons=gtk.BUTTONS_OK)

        d.set_markup("<big><b>" + _("{name} Instructions").format(

                     name=radio.get_name()) + "</b></big>")

        msg = _("{instructions}").format(instructions=message)

        d.format_secondary_markup(msg)

        again = gtk.CheckButton(

            _("Don't show instructions for any radio again"))

        again.show()

        again.connect("toggled", lambda action:

            self.clonemenu.set_active(not action.get_active()))

        d.vbox.pack_start(again, 0, 0, 0)

        h_button_box = d.vbox.get_children()[2]

        try:

            ok_button = h_button_box.get_children()[0]

            ok_button.grab_default()

            ok_button.grab_focus()

        except AttributeError:

            # don't grab focus on GTK+ 2.0

            pass

        d.run()

        d.destroy()

    def do_download(self, port=None, rtype=None):

        d = clone.CloneSettingsDialog(parent=self)

        settings = d.run()

        d.destroy()

        if not settings:

            return

        rclass = settings.radio_class

        if issubclass(rclass, chirp_common.ExperimentalRadio) and \

                not self._confirm_experimental(rclass):

            # User does not want to proceed with experimental driver

            return

        self._show_instructions(rclass, rclass.get_prompts().pre_download)

        LOG.debug("User selected %s %s on port %s" %

                  (rclass.VENDOR, rclass.MODEL, settings.port))

        try:

            ser = serial.Serial(port=settings.port,

                                baudrate=rclass.BAUD_RATE,

                                rtscts=rclass.HARDWARE_FLOW,

                                timeout=0.25)

            ser.flushInput()

        except serial.SerialException, e:

            d = inputdialog.ExceptionDialog(e)

            d.run()

            d.destroy()

            return

        radio = settings.radio_class(ser)

        fn = tempfile.mktemp()

        if isinstance(radio, chirp_common.CloneModeRadio):

            ct = clone.CloneThread(radio, "in", cb=self.cb_clonein,

                                   parent=self)

            ct.start()

        else:

            self.do_open_live(radio)

    def do_upload(self, port=None, rtype=None):

        eset = self.get_current_editorset()

        radio = eset.radio

        settings = clone.CloneSettings()

        settings.radio_class = radio.__class__

        d = clone.CloneSettingsDialog(settings, parent=self)

        settings = d.run()

        d.destroy()

        if not settings:

            return

        prompts = radio.get_prompts()

        if prompts.display_pre_upload_prompt_before_opening_port is True:

            LOG.debug("Opening port after pre_upload prompt.")

            self._show_instructions(radio, prompts.pre_upload)

        if isinstance(radio, chirp_common.ExperimentalRadio) and \

                not self._confirm_experimental(radio.__class__):

            # User does not want to proceed with experimental driver

            return

        try:

            ser = serial.Serial(port=settings.port,

                                baudrate=radio.BAUD_RATE,

                                rtscts=radio.HARDWARE_FLOW,

                                timeout=0.25)

            ser.flushInput()

        except serial.SerialException, e:

            d = inputdialog.ExceptionDialog(e)

            d.run()

            d.destroy()

            return

        if prompts.display_pre_upload_prompt_before_opening_port is False:

            LOG.debug("Opening port before pre_upload prompt.")

            self._show_instructions(radio, prompts.pre_upload)

        radio.set_pipe(ser)

        ct = clone.CloneThread(radio, "out", cb=self.cb_cloneout, parent=self)

        ct.start()

    def do_close(self, tab_child=None):

        if tab_child:

            eset = tab_child

        else:

            eset = self.get_current_editorset()

        if not eset:

            return False

        if eset.is_modified():

            dlg = miscwidgets.YesNoDialog(

                title=_("Save Changes?"), parent=self,

                buttons=(gtk.STOCK_YES, gtk.RESPONSE_YES,

                         gtk.STOCK_NO, gtk.RESPONSE_NO,

                         gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))