def focus(self):
if self.loaded:
return
self.loaded = True
LOG.debug("Loading callsigns...")
def set_ucall(calls):
self.editor_ucall.set_callsigns(calls)
self.editor_ucall.connect("changed", self.__cs_changed)
def set_rcall(calls):
self.editor_rcall.set_callsigns(calls)
self.editor_rcall.connect("changed", self.__cs_changed)
def set_mcall(calls):
self.editor_mcall.set_callsigns(calls)
self.editor_mcall.connect("changed", self.__cs_changed)
job = common.RadioJob(set_ucall, "get_urcall_list")
job.set_desc(_("Downloading URCALL list"))
self.rthread.submit(job)
job = common.RadioJob(set_rcall, "get_repeater_call_list")
job.set_desc(_("Downloading RPTCALL list"))
self.rthread.submit(job)
job = common.RadioJob(set_mcall, "get_mycall_list")
job.set_desc(_("Downloading MYCALL list"))
self.rthread.submit(job)
def _index_edited_cb(self, rend, path, new):
loc, = self._store.get(self._store.get_iter(path), self.C_LOC)
def refresh_memory(*args):
self.refresh_memory(loc)
def set_index(mappings, memory):
self.emit("changed")
# Step 2: Set the index
job = common.RadioJob(refresh_memory, "set_memory_index", memory,
mappings[0], int(new))
job.set_target(self._model)
job.set_desc(
_("Setting index "
"for memory {num}").format(num=memory.number))
self.rthread.submit(job)
def get_mapping(memory):
# Step 1: Get the first/only mapping
job = common.RadioJob(set_index, "get_memory_mappings", memory)
job.set_cb_args(memory)
job.set_target(self._model)
job.set_desc(
_("Getting {type} for "
"memory {num}").format(type=self._type, num=memory.number))
self.rthread.submit(job)
# Step 0: Get the memory
job = common.RadioJob(get_mapping, "get_memory", loc)
job.set_desc(_("Getting memory {num}").format(num=loc))
self.rthread.submit(job)
def do_mapping_adjustment(memory):
# Step 1: Do the mapping add/remove
job = common.RadioJob(do_mapping_index, fn, memory, mapping)
job.set_target(self._model)
job.set_cb_args(memory)
job.set_desc(_("Updating mapping information "
"for memory {num}").format(num=memory.number))
self.rthread.submit(job)
def get_mapping(memory):
# Step 1: Get the first/only mapping
job = common.RadioJob(set_index, "get_memory_mappings", memory)
job.set_cb_args(memory)
job.set_target(self._model)
job.set_desc(
_("Getting {type} for "
"memory {num}").format(type=self._type, num=memory.number))
self.rthread.submit(job)
def set_index(mappings, memory):
self.emit("changed")
# Step 2: Set the index
job = common.RadioJob(refresh_memory, "set_memory_index",
memory, mappings[0], int(new))
job.set_target(self._model)
job.set_desc(_("Setting index "
"for memory {num}").format(num=memory.number))
self.rthread.submit(job)
def __cs_changed(self, cse):
job = None
LOG.debug("Callsigns: %s" % cse.get_callsigns())
if cse == self.editor_ucall:
job = common.RadioJob(None, "set_urcall_list", cse.get_callsigns())
LOG.debug("Set urcall")
elif cse == self.editor_rcall:
job = common.RadioJob(None, "set_repeater_call_list",
cse.get_callsigns())
LOG.debug("Set rcall")
elif cse == self.editor_mcall:
job = common.RadioJob(None, "set_mycall_list", cse.get_callsigns())
if job:
LOG.debug("Submitting job to update call lists")
self.rthread.submit(job)
self.emit("changed")
def prime(self):
# NOTE: this is only called to prime new CSV files, so assume
# only one memory editor for now
mem = chirp_common.Memory()
mem.freq = 146010000
def cb(*args):
gobject.idle_add(self.editors["memedit0"].prefill)
job = common.RadioJob(cb, "set_memory", mem)
job.set_desc(_("Priming memory"))
self.rthread.submit(job)
def _save_settings(self):
if self._settings is None:
return
def setting_cb(result):
if isinstance(result, Exception):
common.show_error(_("Error in setting value: %s") % result)
elif self._changed:
self.emit("changed")
self._changed = False
job = common.RadioJob(setting_cb, "set_settings", self._settings)
job.set_desc("Setting radio settings")
self.rthread.submit(job)
def ensure_calls(self, dst_rthread, import_list):
rlist_changed = False
ulist_changed = False
if not isinstance(self.dst_radio, chirp_common.IcomDstarSupport):
return
ulist = self.dst_radio.get_urcall_list()
rlist = self.dst_radio.get_repeater_call_list()
for old, new in import_list:
mem = self.src_radio.get_memory(old)
if isinstance(mem, chirp_common.DVMemory):
if mem.dv_urcall not in ulist:
LOG.debug("Adding %s to ucall list" % mem.dv_urcall)
ulist.append(mem.dv_urcall)
ulist_changed = True
if mem.dv_rpt1call not in rlist:
LOG.debug("Adding %s to rcall list" % mem.dv_rpt1call)
rlist.append(mem.dv_rpt1call)
rlist_changed = True
if mem.dv_rpt2call not in rlist:
LOG.debug("Adding %s to rcall list" % mem.dv_rpt2call)
rlist.append(mem.dv_rpt2call)
rlist_changed = True
if ulist_changed:
job = common.RadioJob(None, "set_urcall_list", ulist)
job.set_desc(_("Updating URCALL list"))
dst_rthread._qsubmit(job, 0)
if rlist_changed:
job = common.RadioJob(None, "set_repeater_call_list", ulist)
job.set_desc(_("Updating RPTCALL list"))
dst_rthread._qsubmit(job, 0)
return
def mapping_changed(self, listw, key):
def cb(*args):
self.emit("changed")
name = self.listw.get_item(key)[2]
mapping, oldname = self.mappings[self._keys.index(key)]
def trigger_changed(*args):
self.emit("changed")
job = common.RadioJob(trigger_changed, "set_name", name)
job.set_target(mapping)
job.set_desc(_("Setting name on %s") % self._type.lower())
self.rthread.submit(job)
return True
def do_mapping_index(result, memory):
if isinstance(result, Exception):
common.show_error("Failed to add {mem} to mapping: {err}"
.format(mem=memory.number,
err=str(result)),
parent=self.editorset.parent_window)
return
self.emit("changed")
# Step 3: Set the memory's mapping index (maybe)
if not is_indexed or index is None:
return do_refresh_memory()
job = common.RadioJob(do_refresh_memory,
"set_memory_index", memory, mapping, index)
job.set_target(self._model)
job.set_desc(_("Updating {type} index "
"for memory {num}").format(type=self._type,
num=memory.number))
self.rthread.submit(job)
def do_import(self, dst_rthread):
i = 0
error_messages = {}
import_list = self.get_import_list()
src_features = self.src_radio.get_features()
for old, new, name, comm in import_list:
i += 1
LOG.debug("%sing %i -> %i" % (self.ACTION, old, new))
src = self.src_radio.get_memory(old)
try:
mem = import_logic.import_mem(self.dst_radio, src_features,
src, {
"number": new,
"name": name,
"comment": comm
})
except import_logic.ImportError as e:
LOG.error("Import error: %s", e)
error_messages[new] = str(e)
continue
job = common.RadioJob(None, "set_memory", mem)
desc = _("Setting memory {number}").format(number=mem.number)
job.set_desc(desc)
dst_rthread._qsubmit(job, 0)
job = ImportMemoryBankJob(None, mem, self.src_radio, src)
job.set_desc(_("Importing bank information"))
dst_rthread._qsubmit(job, 0)
if error_messages.keys():
msg = _("Error importing memories:") + "\r\n"
for num, msgs in error_messages.items():
msg += "%s: %s" % (num, ",".join(msgs))
common.show_error(msg)
return i
def __init__(self, rthread):
super(SettingsEditor, self).__init__(rthread)
# The main box
self.root = gtk.HBox(False, 0)
# The pane
paned = gtk.HPaned()
paned.show()
self.root.pack_start(paned, 1, 1, 0)
# The selection tree
self._store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT)
self._view = gtk.TreeView(self._store)
self._view.get_selection().connect("changed", self._view_changed_cb)
self._view.append_column(
gtk.TreeViewColumn("", gtk.CellRendererText(), text=0))
self._view.show()
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add_with_viewport(self._view)
scrolled_window.set_size_request(200, -1)
scrolled_window.show()
paned.pack1(scrolled_window)
# The settings notebook
self._notebook = gtk.Notebook()
self._notebook.set_show_tabs(False)
self._notebook.set_show_border(False)
self._notebook.show()
paned.pack2(self._notebook)
self._changed = False
self._settings = None
job = common.RadioJob(self._get_settings_cb, "get_settings")
job.set_desc("Getting radio settings")
self.rthread.submit(job)
def _toggled_cb(self, rend, path, colnum):
try:
if not rend.get_sensitive():
return
except AttributeError:
# support PyGTK < 2.22
iter = self._store.get_iter(path)
if not self._store.get(iter, self.C_FILLED)[0]:
return
# The mapping index is the column number, minus the 3 label columns
mapping, name = self.mappings[colnum - len(self._cols)]
loc, = self._store.get(self._store.get_iter(path), self.C_LOC)
is_indexed = isinstance(self._model,
chirp_common.MappingModelIndexInterface)
if rend.get_active():
# Changing from True to False
fn = "remove_memory_from_mapping"
index = None
else:
# Changing from False to True
fn = "add_memory_to_mapping"
if is_indexed:
index = self._get_next_mapping_index(colnum - len(self._cols))
else:
index = None
def do_refresh_memory(*args):
# Step 2: Update our notion of the memory's mapping information
self.refresh_memory(loc)
def do_mapping_index(result, memory):
if isinstance(result, Exception):
common.show_error(
"Failed to add {mem} to mapping: {err}".format(
mem=memory.number, err=str(result)),
parent=self.editorset.parent_window)
return
self.emit("changed")
# Step 3: Set the memory's mapping index (maybe)
if not is_indexed or index is None:
return do_refresh_memory()
job = common.RadioJob(do_refresh_memory, "set_memory_index",
memory, mapping, index)
job.set_target(self._model)
job.set_desc(
_("Updating {type} index "
"for memory {num}").format(type=self._type,
num=memory.number))
self.rthread.submit(job)
def do_mapping_adjustment(memory):
# Step 1: Do the mapping add/remove
job = common.RadioJob(do_mapping_index, fn, memory, mapping)
job.set_target(self._model)
job.set_cb_args(memory)
job.set_desc(
_("Updating mapping information "
"for memory {num}").format(num=memory.number))
self.rthread.submit(job)
# Step 0: Fetch the memory
job = common.RadioJob(do_mapping_adjustment, "get_memory", loc)
job.set_desc(_("Getting memory {num}").format(num=loc))
self.rthread.submit(job)
