def __init__(self, stem_controller: stem_controller.STEMController, savepath=None):
self.spectrum_parameters = MultiEELSParameters(
[{'index': 0, 'offset_x': 0, 'exposure_ms': 1, 'frames': 1},
{'index': 1, 'offset_x': 160, 'exposure_ms': 8, 'frames': 1},
{'index': 2, 'offset_x': 320, 'exposure_ms': 16, 'frames': 1}])
self.settings = MultiEELSSettings(
{'x_shifter': 'LossMagnetic', 'blanker': 'C_Blank', 'x_shift_delay': 0.05,
'focus': '', 'focus_delay': 0, 'auto_dark_subtract': False, 'bin_spectra': True,
'blanker_delay': 0.05, 'sum_frames': True, 'camera_hardware_source_id': '',
'use_multi_eels_calibration': False})
self.stem_controller = stem_controller
self.camera: camera_base.CameraHardwareSource = None
self.scan_controller: scan_base.ScanHardwareSource = None
self.zeros = {'x': 0, 'focus': 0}
self.scan_calibrations = [{'offset': 0, 'scale': 1, 'units': ''}, {'offset': 0, 'scale': 1, 'units': ''}]
self.__progress_counter = 0
self.acquisition_state_changed_event = Event.Event()
self.new_scan_data_ready_event = Event.Event()
self.progress_updated_event = Event.Event()
self.__active_settings = self.settings
self.__active_spectrum_parameters = self.spectrum_parameters
self.abort_event = threading.Event()
self.__savepath = savepath # or os.path.join(os.path.expanduser('~'), 'MultiAcquire')
self.load_settings()
self.load_parameters()
self.__settings_changed_event_listener = self.settings.settings_changed_event.listen(self.save_settings)
self.__spectrum_parameters_changed_event_listener = self.spectrum_parameters.parameters_changed_event.listen(self.save_parameters)
def __init__(self,
*,
container=None,
master_items_key: str = None,
items_key: str = None,
map_fn: typing.Callable = None,
unmap_fn: typing.Callable = None,
selection: Selection.IndexedSelection = None):
super().__init__()
self.__container = None
self.__master_items_key = master_items_key
self.__items_key = items_key
self.__map_fn = map_fn or (lambda x: x)
self.__unmap_fn = unmap_fn or (lambda x: x)
self.__items: typing.List = list() # a list of transformed items
self._update_mutex = threading.RLock()
self.__change_level = 0
self.begin_changes_event = Event.Event()
self.end_changes_event = Event.Event()
self.__item_inserted_event_listener = None
self.__item_removed_event_listener = None
self.__begin_changes_event_listener = None
self.__end_changes_event_listener = None
self.__selections = list()
if selection:
self.__selections.append(selection)
self.container = container
def __init__(
self,
*,
container: typing.Optional[Observable.Observable] = None,
master_items_key: typing.Optional[str] = None,
items_key: typing.Optional[str] = None,
map_fn: typing.Optional[MappedListModel._MapFunctionType] = None,
unmap_fn: typing.Optional[MappedListModel._MapFunctionType] = None,
selection: typing.Optional[Selection.IndexedSelection] = None
) -> None:
super().__init__()
self.__container = None
self.__master_items_key = master_items_key or "items"
self.__items_key = items_key or self.__master_items_key
self.__map_fn = map_fn or (lambda x: x)
self.__unmap_fn = unmap_fn or (lambda x: x)
self.__items: typing.List[
typing.Any] = list() # a list of transformed items
self._update_mutex = threading.RLock()
self.__change_level = 0
self.begin_changes_event = Event.Event()
self.end_changes_event = Event.Event()
self.__item_inserted_event_listener = None
self.__item_removed_event_listener = None
self.__begin_changes_event_listener = None
self.__end_changes_event_listener = None
self.__selections = list()
if selection:
self.__selections.append(selection)
self.container = container
def __init__(self,
*,
container=None,
master_items_key=None,
items_key=None,
selection=None):
super().__init__()
self.__container = None
self.__master_items_key = master_items_key or items_key
self.__items_key = items_key
self.__master_items = list() # a list of source items (to be filtered)
self.__items = list() # a list of filtered items
self.__items_sorted = False
self._update_mutex = threading.RLock()
self.__filter = Filter(True)
self.__sort_key = None
self.__sort_reverse = False
self.__change_level = 0
self.reset_list_event = Event.Event()
self.begin_changes_event = Event.Event()
self.end_changes_event = Event.Event()
self.__item_changed_event_listeners = dict()
self.__item_inserted_event_listener = None
self.__item_removed_event_listener = None
self.__reset_list_event_listener = None
self.__begin_changes_event_listener = None
self.__end_changes_event_listener = None
self.__selections = list()
if selection:
self.__selections.append(selection)
self.container = container
def setUp(self):
#self.app = Application.Application(TestUI.UserInterface(), set_global=False)
HardwareSource.HardwareSourceManager().hardware_sources = []
HardwareSource.HardwareSourceManager(
).hardware_source_added_event = Event.Event()
HardwareSource.HardwareSourceManager(
).hardware_source_removed_event = Event.Event()
def setUp(self):
self.app = Application.Application(TestUI.UserInterface(), set_global=False)
self.source_image = numpy.random.randn(1024, 1024).astype(numpy.float32)
self.exposure = 1.0
HardwareSource.HardwareSourceManager().hardware_sources = []
HardwareSource.HardwareSourceManager().hardware_source_added_event = Event.Event()
HardwareSource.HardwareSourceManager().hardware_source_removed_event = Event.Event()
def __init__(self, **kwargs):
self.spectrum_parameters = MultiEELSParameters(
[{'index': 0, 'offset_x': 0, 'offset_y': 0, 'exposure_ms': 1, 'frames': 1},
{'index': 1, 'offset_x': 160, 'offset_y': 0, 'exposure_ms': 8, 'frames': 1},
{'index': 2, 'offset_x': 320, 'offset_y': 0, 'exposure_ms': 16, 'frames': 1}])
self.settings = MultiEELSSettings(
{'x_shifter': 'LossMagnetic', 'y_shifter': '', 'x_units_per_ev': 1,
'y_units_per_px': 0.00081, 'blanker': 'C_Blank', 'x_shift_delay': 0.05, 'y_shift_delay': 0.05,
'focus': '', 'focus_delay': 0, 'saturation_value': 12000, 'y_align': True,
'stitch_spectra': False, 'auto_dark_subtract': False, 'bin_spectra': True,
'blanker_delay': 0.05, 'sum_frames': True, 'camera_hardware_source_id': ''})
self.stem_controller = None
self.camera = None
self.superscan = None
self.zeros = {'x': 0, 'y': 0, 'focus': 0}
self.scan_calibrations = [{'offset': 0, 'scale': 1, 'units': ''}, {'offset': 0, 'scale': 1, 'units': ''}]
self.__progress_counter = 0
self.__flyback_pixels = 0
self.acquisition_state_changed_event = Event.Event()
self.new_data_ready_event = Event.Event()
self.progress_updated_event = Event.Event()
self.__stop_processing_event = threading.Event()
self.__queue = queue.Queue()
self.__acquisition_finished_event = threading.Event()
self.__process_and_send_data_thread = None
self.__active_settings = self.settings
self.__active_spectrum_parameters = self.spectrum_parameters
self.abort_event = threading.Event()
self.__savepath = os.path.join(os.path.expanduser('~'), 'MultiAcquire')
self.load_settings()
self.load_parameters()
self.__settings_changed_event_listener = self.settings.settings_changed_event.listen(self.save_settings)
self.__spectrum_parameters_changed_event_listener = self.spectrum_parameters.parameters_changed_event.listen(self.save_parameters)
def __init__(
self,
*,
structure_type: typing.Optional[str] = None,
source: typing.Optional[Persistence.PersistentObject] = None
) -> None:
super().__init__()
self.__properties: typing.Dict[str, typing.Any] = dict()
self.__referenced_object_proxies: typing.Dict[
str, Persistence.PersistentObjectProxy[Persistence.
PersistentObject]] = dict()
self.define_type("data_structure")
self.define_property("structure_type",
structure_type,
changed=self.__structure_type_changed,
hidden=True)
self.define_property("source_specifier",
changed=self.__source_specifier_changed,
key="source_uuid",
hidden=True)
# properties is handled explicitly
self.data_structure_changed_event = Event.Event()
self.data_structure_objects_changed_event = Event.Event()
self.__source_reference = self.create_item_reference(item=source)
self.source_specifier = Persistence.write_persistent_specifier(
source.uuid) if source else None
self.__entity: typing.Optional[Schema.Entity] = None
self.__entity_property_changed_event_listener: typing.Optional[
Event.EventListener] = None
self.__create_entity()
def __init__(self):
self.sections = list()
self.item_inserted_event = Event.Event()
self.item_removed_event = Event.Event()
self.sections.append(Section("Apples"))
self.sections.append(Section("Oranges"))
self.title_model = Model.PropertyModel()
def __init__(
self,
schema: MDescription,
values: typing.Optional[typing.List[typing.Any]] = None) -> None:
if values is not None:
items: typing.Optional[typing.List[typing.Any]] = list()
assert isinstance(schema, dict)
assert isinstance(items, list)
item_schema = schema["items"]
for value in values:
items.append(build_value(item_schema, value=value))
else:
items = None
super().__init__(items=items)
self.schema = schema
self.field_value_changed_event = Event.Event()
self.array_item_inserted_event = Event.Event()
self.array_item_removed_event = Event.Event()
self.model_changed_event = Event.Event()
self.__model_changed_listeners = list()
for item in self.items:
trampoline = None
if isinstance(item, (RecordModel, ArrayModel)):
trampoline = item.model_changed_event.listen(
self.model_changed_event.fire)
self.__model_changed_listeners.append(trampoline)
def __init__(self):
self.__probe_position_value = Model.PropertyModel()
self.__probe_position_value.on_value_changed = self.set_probe_position
self.__probe_state_stack = list() # parked, or scanning
self.__probe_state_stack.append("parked")
self.probe_state_changed_event = Event.Event()
self.__subscan_state_value = Model.PropertyModel(SubscanState.INVALID)
self.__subscan_region_value = Model.PropertyModel(None)
self.scan_data_items_changed_event = Event.Event()
def __init__(self, stem_controller, device, hardware_source_id: str,
display_name: str):
super().__init__(hardware_source_id, display_name)
self.features["is_scanning"] = True
# define events
self.profile_changed_event = Event.Event()
self.frame_parameters_changed_event = Event.Event()
self.probe_state_changed_event = Event.Event()
self.channel_state_changed_event = Event.Event()
self.__stem_controller = stem_controller
self.__probe_state_changed_event_listener = self.__stem_controller.probe_state_changed_event.listen(
self.__probe_state_changed)
self.__subscan_state_changed_event_listener = self.__stem_controller._subscan_state_value.property_changed_event.listen(
self.__subscan_state_changed)
self.__subscan_region_changed_event_listener = self.__stem_controller._subscan_region_value.property_changed_event.listen(
self.__subscan_region_changed)
ChannelInfo = collections.namedtuple("ChannelInfo",
["channel_id", "name"])
self.__device = device
self.__device.on_device_state_changed = self.__device_state_changed
# add data channel for each device channel
channel_info_list = [
ChannelInfo(self.__make_channel_id(channel_index),
self.__device.get_channel_name(channel_index))
for channel_index in range(self.__device.channel_count)
]
for channel_info in channel_info_list:
self.add_data_channel(channel_info.channel_id, channel_info.name)
# add an associated sub-scan channel for each device channel
for channel_index, channel_info in enumerate(channel_info_list):
subscan_channel_index, subscan_channel_id, subscan_channel_name = self.get_subscan_channel_info(
channel_index, channel_info.channel_id, channel_info.name)
self.add_data_channel(subscan_channel_id, subscan_channel_name)
self.__last_idle_position = None # used for testing
# configure the initial profiles from the device
self.__profiles = list()
self.__profiles.extend(self.__get_initial_profiles())
self.__current_profile_index = self.__get_initial_profile_index()
self.__frame_parameters = self.__profiles[0]
self.__record_parameters = self.__profiles[2]
self.__acquisition_task = None
# the task queue is a list of tasks that must be executed on the UI thread. items are added to the queue
# and executed at a later time in the __handle_executing_task_queue method.
self.__task_queue = queue.Queue()
self.__latest_values_lock = threading.RLock()
self.__latest_values = dict()
self.record_index = 1 # use to give unique name to recorded images
def __init__(self):
super().__init__()
self.define_type("data_group")
self.define_property("title", _("Untitled"), validate=self.__validate_title, changed=self.__property_changed)
self.define_property("display_item_references", list(), validate=self.__validate_display_item_references, converter=UuidsToStringsConverter(), changed=self.__property_changed)
self.define_relationship("data_groups", data_group_factory, insert=self.__insert_data_group, remove=self.__remove_data_group)
self.__get_display_item_by_uuid = None
self.__display_items = list()
self.__counted_display_items = collections.Counter()
self.display_item_inserted_event = Event.Event()
self.display_item_removed_event = Event.Event()
def __init__(self, variable):
self.__variable = variable
self.changed_event = Event.Event()
self.needs_rebind_event = Event.Event()
def property_changed(key):
if key == "value":
self.changed_event.fire()
self.__variable_property_changed_listener = variable.property_changed_event.listen(
property_changed)
def __init__(self, type, *, parent=None):
super().__init__()
self.__container_weak_ref = None
self.about_to_be_removed_event = Event.Event()
self.about_to_cascade_delete_event = Event.Event()
self._about_to_be_removed = False
self._closed = False
self.__registration_listener = None
self.define_type(type)
self.define_property("parent_uuid",
converter=Converter.UuidToStringConverter())
self.__parent = parent
if parent is not None:
self.parent_uuid = parent.uuid
def __init__(self, *, structure_type: str=None, source=None):
super().__init__()
self.__properties = dict()
self.__referenced_object_proxies = dict()
self.define_type("data_structure")
self.define_property("structure_type", structure_type, changed=self.__structure_type_changed)
self.define_property("source_specifier", changed=self.__source_specifier_changed, key="source_uuid")
# properties is handled explicitly
self.data_structure_changed_event = Event.Event()
self.referenced_objects_changed_event = Event.Event()
self.__source_proxy = self.create_item_proxy(item=source)
self.source_specifier = source.project.create_specifier(source).write() if source else None
self.__entity: typing.Optional[Schema.Entity] = None
self.__create_entity()
def __init__(self, schema: MDescription, *, values=None):
super().__init__()
self.field_value_changed_event = Event.Event()
self.array_item_inserted_event = Event.Event()
self.array_item_removed_event = Event.Event()
self.model_changed_event = Event.Event()
self.__field_models = dict()
self.__field_model_property_changed_listeners = dict()
self.__field_model_changed_listeners = dict()
self.__array_item_inserted_listeners = dict()
self.__array_item_removed_listeners = dict()
self.schema = schema
assert isinstance(schema, dict)
for field_schema in schema["fields"]:
field_name = field_schema["name"]
field_type = field_schema["type"]
field_default = field_schema.get("default")
field_model = build_model(field_type,
default_value=field_default,
value=(values or dict()).get(field_name))
self.__field_models[field_name] = field_model
def handle_property_changed(field_name, name):
if name == "value":
self.property_changed_event.fire(field_name)
def handle_array_item_inserted(field_name, key, value,
before_index):
if key == "items":
self.item_inserted_event.fire(field_name, value,
before_index)
def handle_array_item_removed(field_name, key, value, index):
if key == "items":
self.item_removed_event.fire(field_name, value, index)
self.__field_model_property_changed_listeners[
field_name] = field_model.field_value_changed_event.listen(
functools.partial(handle_property_changed, field_name))
self.__field_model_changed_listeners[
field_name] = field_model.model_changed_event.listen(
self.model_changed_event.fire)
self.__array_item_inserted_listeners[
field_name] = field_model.array_item_inserted_event.listen(
functools.partial(handle_array_item_inserted, field_name))
self.__array_item_removed_listeners[
field_name] = field_model.array_item_removed_event.listen(
functools.partial(handle_array_item_removed, field_name))
self.__initialized = True
def __init__(self) -> None:
self.storage_cache = Cache.DictStorageCache()
self.profile_properties = dict()
self.__storage_system = FileStorageSystem.MemoryPersistentStorageSystem(
library_properties=self.profile_properties)
self.__storage_system.load_properties()
# these contain the data for each project.
self.x_project_properties = dict()
self.x_data_properties_map = dict()
self.x_data_map = dict()
self.x_trash_map = dict()
# these contain the data for the first created project. they also facilitate legacy project testing.
self.project_uuid = None
self.project_properties = None
self.data_properties_map = None
self.data_map = None
self.trash_map = None
self._test_data_read_event = Event.Event()
self.__profile = None
self.__items_exit = list()
def __init__(self, profile: Profile.Profile) -> None:
super().__init__()
# cache
self.__project_panel_items: typing.Optional[
typing.List[ProjectPanelItemLike]] = None
# define the top level list
self.__root_node = TreeNode()
# define events to make this a model
self.property_changed_event = Event.Event()
# define the closed items
self.__closed_items = set(profile.closed_items)
self.on_closed_items_changed: typing.Optional[typing.Callable[
[typing.Set[str]], None]] = None
def update_items(item: Observer.ItemValue) -> None:
if self.__project_panel_items is not None:
self.property_changed_event.fire("value")
# build an observer that will call update_items whenever any of the project_references changes.
oo = Observer.ObserverBuilder()
oo.source(profile).tuple(
oo.x.ordered_sequence_from_array(
"project_references").collect_list()).action_fn(update_items)
self.__profile_observer = typing.cast(Observer.AbstractItemSource,
oo.make_observable())
def __init__(self):
# these events must be defined
self.current_frame_parameters_changed_event = Event.Event()
self.record_frame_parameters_changed_event = Event.Event()
self.profile_changed_event = Event.Event()
self.frame_parameters_changed_event = Event.Event()
# optional event and identifier for settings. defining settings_id signals that
# the settings should be managed as a dict by the container of this class. the container
# will call apply_settings to initialize settings and then expect settings_changed_event
# to be fired when settings change.
self.settings_changed_event = Event.Event()
self.settings_id = str()
# the list of possible modes should be defined here
self.modes = [str()]
def __init__(self, ui: UserInterface.UserInterface,
display_item: DisplayItem.DisplayItem) -> None:
super().__init__()
self._ui = ui
self._display_item = display_item
self.thumbnail_updated_event = Event.Event()
self.__thumbnail_processor = ThumbnailProcessor(display_item)
def thumbnail_changed() -> None:
thumbnail_processor = self.__thumbnail_processor
if thumbnail_processor:
thumbnail_processor.mark_data_dirty()
thumbnail_processor.recompute(ui)
self.__display_changed_event_listener = display_item.display_changed_event.listen(
thumbnail_changed)
def thumbnail_updated() -> None:
self.thumbnail_updated_event.fire()
self.__thumbnail_processor.on_thumbnail_updated = thumbnail_updated
# initial recompute, if required
if self.__thumbnail_processor._is_cached_value_dirty:
self.__thumbnail_processor.recompute(ui)
def display_item_will_close() -> None:
if self.__thumbnail_processor:
self.__thumbnail_processor.close()
self.__thumbnail_processor = typing.cast(typing.Any, None)
self.__display_will_close_listener = display_item.about_to_be_removed_event.listen(
display_item_will_close)
class Handler:
# method 1: explicitly handle events
hello1_label = None
def hello1_updated(self, widget, text):
self.hello1_label.text = text
if widget.focused:
widget.select_all()
# method 2: dialog handler becomes a model, explicit handling of hello2_text model property
property_changed_event = Event.Event()
__hello2_text = "Hello World Two"
@property
def hello2_text(self):
return self.__hello2_text
@hello2_text.setter
def hello2_text(self, value):
self.__hello2_text = value
self.property_changed_event.fire("hello2_text")
# method 3: use a property model
hello3_model = Model.PropertyModel("Hello World Three")
def __init__(self, ui, display_item: DisplayItem.DisplayItem):
super().__init__()
self._ui = ui
self._display_item = display_item
self.thumbnail_updated_event = Event.Event()
self.__thumbnail_processor = ThumbnailProcessor(display_item)
self._on_will_delete = None
def thumbnail_changed():
thumbnail_processor = self.__thumbnail_processor
if thumbnail_processor:
thumbnail_processor.mark_data_dirty()
thumbnail_processor.recompute_if_necessary(ui)
self.__display_changed_event_listener = display_item.display_changed_event.listen(
thumbnail_changed)
def thumbnail_updated():
self.thumbnail_updated_event.fire()
self.__thumbnail_processor.on_thumbnail_updated = thumbnail_updated
self.__thumbnail_processor.recompute_if_necessary(ui)
def display_item_will_close():
if self.__thumbnail_processor:
self.__thumbnail_processor.close()
self.__thumbnail_processor = None
self.__display_will_close_listener = display_item.about_to_be_removed_event.listen(
display_item_will_close)
def __init__(self, selection_style: typing.Optional[Style] = None, expanded_changed_event: bool = False) -> None:
super().__init__()
self.__changed_event = Event.Event()
self.expanded_changed_event = expanded_changed_event # whether to fire when updating indexes
self.__indexes : typing.MutableSet[int] = set()
self.__anchor_index : typing.Optional[int] = None
self.selection_style = selection_style if selection_style else Style.multiple
def __init__(self):
self.property_changed_event = Event.Event()
self.title_edit = None
self.caption_edit = None
self.__is_rejected = False
self.__title = display_item.title
self.__caption = display_item.caption
def __init__(self, container, hardware_source):
self.container = container
self.hardware_source = hardware_source
self.settings = video_base.video_configuration.get_settings_model(
hardware_source)
self.settings_original = copy.deepcopy(self.settings)
self.needs_saving_model = Model.PropertyModel(False)
self.property_changed_event = Event.Event()
self.apply_button = None
self.revert_button = None
def settings_changed(property_name):
self.needs_saving_model.value = True
self.__settings_changed_event_listener = self.settings.property_changed_event.listen(
settings_changed)
def needs_saving_model_changed(property_name):
if self.apply_button:
self.apply_button.enabled = self.needs_saving_model.value
if self.revert_button:
self.revert_button.enabled = self.needs_saving_model.value
self.__needs_saving_changed_event_listener = self.needs_saving_model.property_changed_event.listen(
needs_saving_model_changed)
def __init__(
self, document_controller: DocumentController.DocumentController
) -> None:
self.__weak_document_controller = weakref.ref(document_controller)
self.__data_item: typing.Optional[DataItem.DataItem] = None
# thread safe.
def display_item_changed(
display_item: typing.Optional[DisplayItem.DisplayItem]
) -> None:
data_item = display_item.data_item if display_item else None
def update_data_item() -> None:
self.__set_data_item(data_item)
document_controller = self.document_controller
if document_controller:
document_controller.add_task(
"update_data_item" + str(id(self)), update_data_item)
self.__display_item_changed_event_listener = document_controller.focused_display_item_changed_event.listen(
display_item_changed)
self.__set_data_item(None)
self.__metadata_changed_event_listener: typing.Optional[
Event.EventListener] = None
self.__metadata: typing.Optional[DataAndMetadata.MetadataType] = None
self.metadata_changed_event = Event.Event()
def __init__(self, ui: UserInterface.UserInterface, app: typing.Optional[Application.BaseApplication] = None,
parent_window: typing.Optional[Window] = None, window_style: typing.Optional[str] = None,
persistent_id: typing.Optional[str] = None):
Window.count += 1
self.ui = ui
self.parent_window = parent_window
self.app: typing.Optional[Application.BaseApplication] = app or (parent_window.app if parent_window else None)
self.on_close: typing.Optional[typing.Callable[[], None]] = None
parent_ui_window = parent_window._document_window if parent_window else None
self.__document_window = self.ui.create_document_window(parent_window=parent_ui_window)
if window_style:
self.__document_window.window_style = window_style
self.__persistent_id = persistent_id
self.__shown = False
self.__request_close = False
# Python 3.9+: should be weakref.ReferenceType[Dialog]
self.__dialogs: typing.List[typing.Any] = list()
self._window_close_event = Event.Event()
self.__document_window.on_periodic = self.periodic
self.__document_window.on_queue_task = self.queue_task
self.__document_window.on_clear_queued_tasks = self.clear_queued_tasks
self.__document_window.on_add_task = self.add_task
self.__document_window.on_clear_task = self.clear_task
self.__document_window.on_about_to_show = self.about_to_show
self.__document_window.on_about_to_close = self.about_to_close
self.__document_window.on_activation_changed = self.activation_changed
self.__document_window.on_key_pressed = self.key_pressed
self.__document_window.on_key_released = self.key_released
self.__document_window.on_size_changed = self.size_changed
self.__document_window.on_position_changed = self.position_changed
self.__document_window.on_refocus_widget = self.refocus_widget
self.__document_window.on_ui_activity = self._register_ui_activity
self.__periodic_queue = Process.TaskQueue()
self.__periodic_set = Process.TaskSet()
self.__modal_actions: typing.List[Action] = list()
# define old-style menu actions for backwards compatibility
self._close_action = None
self._page_setup_action = None
self._print_action = None
self._quit_action = None
self._undo_action = None
self._redo_action = None
self._cut_action = None
self._copy_action = None
self._paste_action = None
self._delete_action = None
self._select_all_action = None
self._minimize_action = None
self._zoom_action = None
self._bring_to_front_action = None
# configure the event loop object. for backwards compatibility only.
self.__event_loop = asyncio.get_event_loop_policy().get_event_loop()
if app:
app._window_created(self)
def __init__(self, display_item: DisplayItem.DisplayItem, ui: UserInterface.UserInterface):
self.__display_item: typing.Optional[DisplayItem.DisplayItem] = display_item
self.ui = ui
self.needs_update_event = Event.Event()
def display_item_changed() -> None:
self.needs_update_event.fire()
self.__display_changed_event_listener = display_item.item_changed_event.listen(display_item_changed) if display_item else None
self.__display_item_about_to_be_removed_event_listener = None
def display_item_removed() -> None:
if self.__display_changed_event_listener:
self.__display_changed_event_listener.close()
self.__display_changed_event_listener = None
if self.__display_item_about_to_be_removed_event_listener:
self.__display_item_about_to_be_removed_event_listener.close()
self.__display_item_about_to_be_removed_event_listener = None
self.__display_item = None
self.__display_item_about_to_be_removed_event_listener = display_item.about_to_be_removed_event.listen(display_item_removed) if display_item else None
self.__thumbnail_updated_event_listener = None
self.__thumbnail_source : typing.Optional[Thumbnails.ThumbnailSource] = None
def __init__(
self, container: typing.Any,
hardware_source: video_base.VideoHardwareSource
) -> None:
self.container = container
self.hardware_source = hardware_source
self.settings = video_base.video_configuration.get_settings_model(
hardware_source)
self.settings_original = copy.deepcopy(self.settings)
self.needs_saving_model = Model.PropertyModel(False)
self.property_changed_event = Event.Event()
# these will be assigned by declarative setup
self.apply_button: typing.Optional[
UserInterface.PushButtonWidget] = None
self.revert_button: typing.Optional[
UserInterface.PushButtonWidget] = None
def settings_changed(property_name: str) -> None:
self.needs_saving_model.value = True
self.__settings_changed_event_listener = self.settings.property_changed_event.listen(
settings_changed) if self.settings else None
def needs_saving_model_changed(
property_name: str) -> None:
if self.apply_button:
self.apply_button.enabled = self.needs_saving_model.value or False
if self.revert_button:
self.revert_button.enabled = self.needs_saving_model.value or False
self.__needs_saving_changed_event_listener = self.needs_saving_model.property_changed_event.listen(
needs_saving_model_changed)
