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

from glob import glob

import shutil

import time

import gtk

import gobject

gobject.threads_init()

if __name__ == "__main__":

import sys

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

from chirpui import inputdialog, common

try:

import serial

except ImportError,e:

common.log_exception()

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

from chirp import platform, generic_xml, generic_csv, directory, util

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

from chirp import CHIRP_VERSION, chirp_common, detect, errors

from chirp import icf, ic9x_icf

from chirpui import editorset, clone, miscwidgets, config, reporting, fips

from chirpui import bandplans

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"]:

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

print "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

print "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>.").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))):

print "Skipping existing stock config"

continue

try:

shutil.copy(fn, stock_dir)

print "Copying %s -> %s" % (fn, stock_dir)

except Exception, e:

print "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:

print "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()

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()

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

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)

print "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()

prompt_before = prompts.display_pre_upload_prompt_before_opening_port \

and not CONF.get_bool("force_after", "upload_prompt")

if prompt_before == True:

print "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 prompt_before == False: