CHIRP

# Copyright 2008 Dan Smith <dsmith@danplanet.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 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 threading

import os

import gtk

import gobject

from chirp import platform, directory, detect, chirp_common

from chirpui import miscwidgets, cloneprog, inputdialog, common, config

AUTO_DETECT_STRING = "Auto Detect (Icom Only)"

class CloneSettings:

    def __init__(self):

        self.port = None

        self.radio_class = None

    def __str__(self):

        s = ""

        if self.radio_class:

            return _("{vendor} {model} on {port}").format(\

                vendor=self.radio_class.VENDOR,

                model=self.radio_class.MODEL,

                port=self.port)

class CloneSettingsDialog(gtk.Dialog):

    def __make_field(self, label, widget):

        l = gtk.Label(label)

        self.__table.attach(l, 0, 1, self.__row, self.__row+1)

        self.__table.attach(widget, 1, 2, self.__row, self.__row+1)

        self.__row += 1

        l.show()

        widget.show()

    def __make_port(self, port):

        conf = config.get("state")

        ports = platform.get_platform().list_serial_ports()

        if not port:

            if conf.get("last_port"):

                port = conf.get("last_port")

            elif ports:

                port = ports[0]

            else:

                port = ""

            if not port in ports:

                ports.insert(0, port)

        return miscwidgets.make_choice(ports, True, port)

    def __make_model(self):

        return miscwidgets.make_choice([], False)

    def __make_vendor(self, model):

        vendors = {}

        for rclass in sorted(directory.DRV_TO_RADIO.values()):

            if not issubclass(rclass, chirp_common.CloneModeRadio) and \

                    not issubclass(rclass, chirp_common.LiveRadio):

                continue

            if not vendors.has_key(rclass.VENDOR):

                vendors[rclass.VENDOR] = []

            vendors[rclass.VENDOR].append(rclass)

        self.__vendors = vendors

        conf = config.get("state")

        if not conf.get("last_vendor"):

            conf.set("last_vendor", sorted(vendors.keys())[0])

        last_vendor = conf.get("last_vendor")

        if last_vendor not in vendors.keys():

            last_vendor = vendors.keys()[0]

        v = miscwidgets.make_choice(sorted(vendors.keys()), False, last_vendor)

        def _changed(box, vendors, model):

            models = vendors[box.get_active_text()]

            added_models = []

            model.get_model().clear()

            for rclass in sorted(models, key=lambda c: c.__name__):

                if rclass.MODEL not in added_models:

                    model.append_text(rclass.MODEL)

                    added_models.append(rclass.MODEL)

            if box.get_active_text() in detect.DETECT_FUNCTIONS:

                model.insert_text(0, _("Detect"))

                added_models.insert(0, _("Detect"))

            model_names = [x.MODEL for x in models]

            if conf.get("last_model") in model_names:

                model.set_active(added_models.index(conf.get("last_model")))

            else:

                model.set_active(0)

        v.connect("changed", _changed, vendors, model)

        _changed(v, vendors, model)

        return v

    def __make_ui(self, settings):

        self.__table = gtk.Table(3, 2)

        self.__table.set_row_spacings(3)

        self.__table.set_col_spacings(10)

        self.__row = 0

        self.__port = self.__make_port(settings and settings.port or None)

        self.__modl = self.__make_model()

        self.__vend = self.__make_vendor(self.__modl)

        self.__make_field(_("Port"), self.__port)

        self.__make_field(_("Vendor"), self.__vend)

        self.__make_field(_("Model"), self.__modl)

        if settings and settings.radio_class:

            common.combo_select(self.__vend, settings.radio_class.VENDOR)

            self.__modl.get_model().clear()

            self.__modl.append_text(settings.radio_class.MODEL)

            common.combo_select(self.__modl, settings.radio_class.MODEL)

            self.__vend.set_sensitive(False)

            self.__modl.set_sensitive(False)

            self.__prompt_force_after = gtk.CheckButton()

            try:

                self.__prompt_force_after.set_tooltip_text(

                    _("Try this if download work but upload fails immediately"))

            except:

                pass

            self.__prompt_force_after.set_active(

                    config.get("upload_prompt").get_bool("force_after"))

            self.__make_field(

                    _("Force alternative\nopen schema"),

                    self.__prompt_force_after)

        self.__table.show()

        self.vbox.pack_start(self.__table, 1, 1, 1)

    def __init__(self, settings=None, parent=None, title=_("Radio")):

        buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,

                   gtk.STOCK_OK, gtk.RESPONSE_OK)

        gtk.Dialog.__init__(self, title,

                            parent=parent,

                            flags=gtk.DIALOG_MODAL)

        self.__make_ui(settings)

        self.__cancel_button = self.add_button(gtk.STOCK_CANCEL,

                                               gtk.RESPONSE_CANCEL)

        self.__okay_button = self.add_button(gtk.STOCK_OK,

                                             gtk.RESPONSE_OK)

        self.__okay_button.grab_default()

        self.__okay_button.grab_focus()

    def run(self):

        r = gtk.Dialog.run(self)

        if r != gtk.RESPONSE_OK:

            return None

        vendor = self.__vend.get_active_text()

        model = self.__modl.get_active_text()

        cs = CloneSettings()

        cs.port = self.__port.get_active_text()

        if model == _("Detect"):

            try:

                cs.radio_class = detect.DETECT_FUNCTIONS[vendor](cs.port)

                if not cs.radio_class:

                    raise Exception(_("Unable to detect radio on {port}").format(port=cs.port))

            except Exception, e:

                d = inputdialog.ExceptionDialog(e)

                d.run()

                d.destroy()

                return None

        else:

            for rclass in directory.DRV_TO_RADIO.values():

                if rclass.MODEL == model:

                    cs.radio_class = rclass

                    break

            if not cs.radio_class:

                common.show_error(_("Internal error: Unable to upload to {model}").format(model=model))

                print self.__vendors

                return None

        conf = config.get("state")

        conf.set("last_port", cs.port)

        conf.set("last_vendor", cs.radio_class.VENDOR)

        conf.set("last_model", model)

        try:

            if self.__prompt_force_after != None:

                config.get("upload_prompt").set_bool("force_after", self.__prompt_force_after.get_active())

        except:

                pass

        return cs

class CloneCancelledException(Exception):

    pass

class CloneThread(threading.Thread):

    def __status(self, status):

        gobject.idle_add(self.__progw.status, status)

    def __init__(self, radio, direction, cb=None, parent=None):

        threading.Thread.__init__(self)

        self.__radio = radio

        self.__out = direction == "out"

        self.__cback = cb

        self.__cancelled = False

        self.__progw = cloneprog.CloneProg(parent=parent, cancel=self.cancel)

    def cancel(self):

        self.__radio.pipe.close()

        self.__cancelled = True

    def run(self):

        print "Clone thread started"

        gobject.idle_add(self.__progw.show)

        self.__radio.status_fn = self.__status

        try:

            if self.__out:

                self.__radio.sync_out()

            else:

                self.__radio.sync_in()

            emsg = None

        except Exception, e:

            common.log_exception()

            print _("Clone failed: {error}").format(error=e)

            emsg = e

        gobject.idle_add(self.__progw.hide)

        # NB: Compulsory close of the radio's serial connection

        self.__radio.pipe.close()

        print "Clone thread ended"

        if self.__cback and not self.__cancelled:

            gobject.idle_add(self.__cback, self.__radio, emsg)

if __name__ == "__main__":

    d = CloneSettingsDialog("/dev/ttyUSB0")

    r = d.run()

    print r