def download(tk_parent, connection):
c = connection
with dialogs.ProgressDialog(tk_parent,
describtion="Downloading...") as progress:
new_files = c.download_all_records(progress.set_maximum,
progress.set_progress)
for filename in new_files:
c.delete_record(filename)
def scan_opened_file(self):
if self.plot is None:
return
# disable the button to stop repeating this step
self.button_scan.configure(state='disabled') # un-press-able
# restart the codec from the first sample
self.codec.goto_sample_index(0)
# create mip maps
mipmap_step = 64
with dialogs.ProgressDialog(self.gui_window, "Indexing...") as dialog:
dialog.set_maximum(self.codec.header.sample_count)
# first level mipmap is the file itself
indexer = compound_samples.CompoundSampleFromStream(self.codec)
mipmap1 = compound_samples.CompoundSampleMipMap(mipmap_step)
mipmap1.generate_from(
indexer,
lambda head: dialog.set_progress(indexer.get_sample_index()))
# second mipmap level can now be calculated
mipmap2 = compound_samples.CompoundSampleMipMap(mipmap_step**2)
mipmap2.generate_from(
mipmap1,
lambda head: dialog.set_progress(mipmap1.get_sample_index()))
# third mipmap level can now be calculated
mipmap3 = compound_samples.CompoundSampleMipMap(mipmap_step**3)
mipmap3.generate_from(
mipmap2,
lambda head: dialog.set_progress(mipmap2.get_sample_index()))
# create a new renderer
mipmaps = compound_samples.MipMapList()
mipmaps.add_level(compound_samples.CompoundSampleFromStream(
self.codec))
mipmaps.add_level(mipmap1)
mipmaps.add_level(mipmap2)
mipmaps.add_level(mipmap3)
self.plot = visualization.PlotView(mipmaps, self.codec.header)
# render result
self.redraw_canvas()
def apply_action():
c.stop_measurement()
with dialogs.ProgressDialog(window, "Please wait..") as dialog:
dialog.set_maximum(2)
dialog.set_progress(0)
# this simple statement will wait for Raspberry to stop the measurement, which can take a while depending on the configuration
c.is_measurement_running()
try:
new_config = copy(config)
current_entry = "device name"
if len(w_device_name.value) > 31:
raise ValueError("too long")
new_config.device_name = w_device_name.value
current_entry = "unit name"
if len(w_unit_name.value) > 15:
raise ValueError("too long")
new_config.unit_name = w_unit_name.value
current_entry = "unit range"
new_config.unit_significand, config.unit_exponent = read_format_significand_exponent(
w_unit_range.value)
current_entry = "sample rate"
new_config.frequency = int(w_sample_rate.value)
current_entry = "ADC min"
new_config.ADC_min = int(w_ADC_min.value, 16)
current_entry = "ADC max"
new_config.ADC_max = int(w_ADC_max.value, 16)
current_entry = "SPI clock mode"
new_config.SPI_output_pattern = int(w_SPI_output.value, 16)
current_entry = "SPI clock mode"
new_config.SPI_clock_mode = (1 if w_SPI_clock_invert.value else
0) + (2 if w_SPI_clock_delay.value
else 0)
current_entry = "ADC bit position"
new_config.bit_shift = int(w_bit_shift.value)
current_entry = "digital channel position"
new_config.digital_bit_shift = int(w_digital_shift.value)
current_entry = "unknown"
c.set_config(config)
diagram.config = new_config
c.start_dry_run()
except (ValueError, struct.error) as e:
GUI.messagebox.showwarning(
"Error",
"Invalid entry in {}\n{}".format(current_entry, str(e)))
return
def on_click():
try:
export_plugin = folder.load(module_name)
# suggest a filename and initial directory. let's hope the plugin uses these values
default_filename = os.path.basename(
self.codec.byte_stream.name)
if default_filename.endswith(".pgrecord"):
default_filename = default_filename[:-9]
default_folder = os.path.abspath(
os.path.dirname(os.path.realpath(__file__)) +
"/../exports")
self.codec.goto_sample_index(0)
export_plugin.export(
self.codec, lambda: dialogs.ProgressDialog(
self.gui_window, "asdf"))
except Exception as e:
# user cancelled or serious error
GUI.messagebox.showwarning("Error", str(e))
def on_mi_delete_user_activate(self, widget):
users = self.get_selected_users()
users_n = len(users)
if users_n == 1:
message = _(
"Are you sure you want to delete user \"%s\"?") % users[0].name
homes_message = _("Also delete the user's home directory.")
homes_warn = _(
"WARNING: if you enable this option, the user's home directory with all its files will be deleted, along with the user's e-mail at /var/mail, if it exists"
)
else:
message = _(
"Are you sure you want to delete the following %d users?"
) % users_n
message += "\n" + ', '.join([user.name for user in users])
homes_message = _("Also delete the users' home directories.")
homes_warn = _(
"WARNING: if you enable this option, the users' home directories with all their files will be deleted, along with the users' e-mails at /var/mail, if they exist"
)
homes_warn += "\n\n" + _("This action can't be undone.")
dlg = dialogs.AskDialog(message, parent=self.main_window)
vbox = dlg.get_message_area()
rm_homes_check = Gtk.CheckButton(homes_message)
rm_homes_check.get_child().set_tooltip_text(homes_warn)
rm_homes_check.show()
vbox.pack_start(rm_homes_check, False, False, 12)
response = dlg.showup()
if response == Gtk.ResponseType.YES:
rm_homes = rm_homes_check.get_active()
if users_n > 1:
progress = dialogs.ProgressDialog("Deleting Users", users_n,
self.main_window)
for user in self.get_selected_users():
dialogs.wait_gtk()
progress.set_message(
"Delete user: {user}".format(user=user.name))
self.system.delete_user(user, rm_homes)
progress.inc()
else:
self.system.delete_user(users[0], rm_homes)
def on_mi_delete_group_activate(self, widget):
groups = self.get_selected_groups()
groups_n = len(groups)
if groups_n == 1:
message = _(
"Are you sure you want to delete group %s?") % groups[0].name
else:
message = _(
"Are you sure you want to delete the following %d groups?"
) % groups_n
message += "\n" + ', '.join([group.name for group in groups])
response = dialogs.AskDialog(message, parent=self.main_window).showup()
if response == Gtk.ResponseType.YES:
self.sf.remove(groups)
progress = dialogs.ProgressDialog("Deleting Groups", len(groups),
self.main_window)
for group in groups:
dialogs.wait_gtk()
progress.set_message(
"Deleting group {group}".format(group=group.name))
self.system.delete_group(group)
progress.inc()
def on_mi_remove_user_activate(self, widget):
users = self.get_selected_users()
groups = self.get_selected_groups()
users_n = len(users)
group_names = ', '.join([group.name for group in groups])
if users_n == 1:
message = _(
"Are you sure you want to remove user %(user)s from the selected groups (%(groups)s)?"
) % {
"user": users[0].name,
"groups": group_names
}
else:
message = _(
"Are you sure you want to remove the following %(count)d users from the selected groups (%(groups)s)?"
) % {
"count": users_n,
"groups": group_names
}
message += "\n" + ', '.join([user.name for user in users])
response = dialogs.AskDialog(message, parent=self.main_window).showup()
if response == Gtk.ResponseType.YES:
if users_n > 1:
progress = dialogs.ProgressDialog("Remove users from groups",
users_n, self.main_window)
for user in self.get_selected_users():
dialogs.wait_gtk()
progress.set_message(
"remove user {user} from groups {groups}".format(
user=user.name,
groups=', '.join([g.name for g in groups])))
self.system.remove_user_from_groups(user, groups)
progress.inc()
else:
self.system.remove_user_from_groups(users[0], groups)
def show_progress(self, title, parent_max, child_max=1, message=''):
dlg = dialogs.ProgressDialog(self, title, parent_max, child_max,
message)
def Apply(self, widget):
text = _("Create the following users?\n\n" +
', '.join([u.name for u in self.set.users.values()]))
response = dialogs.AskDialog(text, "Confirm",
parent=self.dialog).showup()
if response == Gtk.ResponseType.YES:
new_groups = {}
new_gids = [u.gid for u in self.set.users.values()]
sys_gids = [g.gid for g in libuser.get_system().groups.values()]
for u in self.set.users.values():
if u.primary_group not in libuser.get_system().groups:
if u.primary_group not in new_groups:
g_obj = libuser.Group(u.primary_group, u.gid)
new_groups[u.primary_group] = g_obj
new_groups[u.primary_group].members[u.name] = u
for u in self.set.users.values():
for g in u.groups:
if g not in libuser.get_system().groups:
if g not in new_groups:
g_obj = libuser.Group(g)
if g in self.set.groups:
g_obj.gid = self.set.groups[g].gid
if g_obj.gid in new_gids + sys_gids or g_obj.gid is None:
g_obj.gid = libuser.get_system().get_free_gid(
exclude=new_gids)
new_gids.append(g_obj.gid)
new_groups[g] = g_obj
new_groups[g].members[u.name] = u
operations = len(new_groups) + len(self.set.users)
for gr in new_groups.values():
operations += len(gr.members)
progress = dialogs.ProgressDialog(_("Creating all users"),
operations, self.dialog)
def wait_gtk():
while Gtk.events_pending():
Gtk.main_iteration()
for gr in new_groups.values():
wait_gtk()
progress.set_message(
_("Adding group {group}").format(group=gr.name))
gr_tmp = libuser.Group(gr.name, gr.gid)
libuser.get_system().add_group(gr_tmp)
progress.inc()
for u in self.set.users.values():
wait_gtk()
progress.set_message(
_("Adding user {user}").format(user=u.name))
libuser.get_system().add_user(u)
progress.inc()
for gr in new_groups.values():
for u in gr.members.values():
wait_gtk()
progress.set_message(
_("Adding user {user} to group {group}").format(
user=u.name, group=gr.name))
libuser.get_system().add_user_to_groups(u, [gr])
progress.inc()
else:
return False
self.dialog.destroy()
def on_button_apply_clicked(self, widget):
self.computers = self.glade.get_object('computers_number_spin').\
get_value_as_int()
self.groups_tmpl = self.glade.get_object('groups_template_entry').\
get_text()
button_close = self.glade.get_object('button_close')
total_users = self.computers * len(self.classes)
total_groups = len(self.classes)
progress = dialogs.ProgressDialog(
_("Creating all users"),
total_users + total_groups,
self.dialog,
on_close=self.on_button_cancel_clicked)
users_created = 0
groups_created = 0
set_gids = []
set_uids = []
# Create groups for all the listed classes
if self.classes != ['']:
for classn in self.classes:
dialogs.wait_gtk()
if classn not in self.system.groups:
tmp_gid = self.system.get_free_gid(exclude=set_gids)
set_gids.append(tmp_gid)
cmd_error = self.system.add_group(
libuser.Group(classn, tmp_gid, {}))
progress.set_message(
_("Creating group %(current)d of %(total)d...") % {
"current": groups_created + 1,
"total": total_groups
})
if cmd_error[0] and cmd_error[1] != "":
self.glade.get_object('error_label').set_text(
cmd_error[1])
self.glade.get_object('error_hbox').show()
button_close.set_sensitive(True)
return
groups_created += 1
progress.set_progress(groups_created)
else:
tmp_gid = self.system.groups[classn].gid
groups_created += 1
# Add teachers to group
if self.glade.get_object('teachers_checkbutton').get_active():
progress.set_message(
_("Adding teachers to group {group}").format(
group=classn))
for user in self.system.users.values():
dialogs.wait_gtk()
if 'teachers' in user.groups and classn not in user.groups:
user.groups.append(classn)
self.system.update_user(user.name, user)
# Create shared folders
if self.glade.get_object('shared_checkbutton').get_active():
for classn in self.classes:
progress.set_message(
_("Adding shares for {group}").format(group=classn))
dialogs.wait_gtk()
self.sf.add([classn])
# And finally, create the users
cmd_error = (False, '')
for classn in self.classes:
for compn in range(1, self.computers + 1):
dialogs.wait_gtk()
progress.set_message(
_("Creating user %(current)d of %(total)d...") % {
"current": users_created + 1,
"total": total_users
})
ev = lambda x: x.replace('{c}', classn.strip()).replace(
'{i}', str(compn)).replace('{0i}', '%02d' % compn)
epoch = datetime.datetime.utcfromtimestamp(0)
uname = ev(self.username_tmpl)
tmp_uid = self.system.get_free_uid(exclude=set_uids)
set_uids.append(tmp_uid)
tmp_gid = self.system.get_free_gid(exclude=set_gids)
tmp_password = ev(self.password_tmpl)
# Create the UPG
g = libuser.Group(uname, tmp_gid)
self.system.add_group(g)
u = libuser.User(
name=uname,
uid=tmp_uid,
gid=tmp_gid,
rname=ev(self.name_tmpl),
directory=(self.home + ev(self.username_tmpl)),
lstchg=(datetime.datetime.today() - epoch).days,
groups=[classn],
password=self.system.encrypt(tmp_password))
cmd_error = self.system.add_user(u)
self.system.load()
users_created += 1
progress.set_progress(groups_created + users_created)
if cmd_error[0] and cmd_error[1] != "":
self.progress.set_error(cmd_error.strip())
return
