def on_changed(self, collection, id, fields, cleared): self.set_audio(fields) me = self.client.find_one('rooms') if self.paused != me['paused']: self.set_paused(me['paused']) if context.get_state().is_recording != me['recording']: self.set_recording(me)
def check_net(self, origin, status=None): """Update the value of the network status""" attr1 = pango.AttrList() attr2 = pango.AttrList() attr3 = pango.AttrList() attr4 = pango.AttrList() gray = pango.AttrForeground(20000, 20000, 20000, 0, -1) red = pango.AttrForeground(65535, 0, 0, 0, -1) green = pango.AttrForeground(0, 65535, 0, 0, -1) black = pango.AttrForeground(5000, 5000, 5000, 0, -1) attr1.insert(gray) attr2.insert(green) attr3.insert(red) attr4.insert(black) s3 = self.gui.get_object("status3") if not self.net_activity: s3.set_text("Disabled") s3.set_attributes(attr1) else: net = status or context.get_state().net try: if net: s3.set_text("Up") s3.set_attributes(attr2) else: s3.set_text("Down") s3.set_attributes(attr3) except KeyError: s3.set_text("Connecting") s3.set_attributes(attr4)
def on_scheduled_start(self, source, identifier): """Starts a scheduled recording, replacing the mediapackage in use""" logger.info("Scheduled Start") self.conf.reload() self.current_mediapackage = identifier context.get_state().mp = identifier self.scheduled_recording = True if self.status == GC_PREVIEW: # Record directly self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() elif self.status in [ GC_RECORDING, GC_PAUSED ] : if self.allow_overlap: pass # TODO: dont stop and extend recording until the end of the new interval # In case of stop, restart with the overlapped job else: # Stop current recording, wait until prewiew restarted and record self.start_recording = True self.close_recording() elif self.status == GC_INIT: # Start Preview and Record self.on_start_button() while self.recorder.get_status() != gst.STATE_PLAYING: time.sleep(0.2) self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() title = self.repo.get(identifier).title self.dispatcher.emit("update-video", title)
def close_recording(self): """Set the final data on the mediapackage, stop the record and restart the preview""" paused = self.paused_time.total_seconds() * 1000000000 # pass to ns close_duration = int( (self.recorder.get_time() - self.initial_time - paused) * 1000 / gst.SECOND) # To avoid error messages on stopping pipelines if self.error_dialog: if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.recorder.stop_record_and_restart_preview() self.change_state(GC_STOP) self.mediapackage.status = mediapackage.RECORDED self.mediapackage.properties['origin'] = self.conf.hostname self.repo.add_after_rec(self.mediapackage, self.recorder.bins_desc, close_duration, self.mediapackage.manual) code = 'manual' if self.mediapackage.manual else 'scheduled' if self.conf.get_lower('ingest', code) == 'immediately': self.worker.ingest(self.mediapackage) elif self.conf.get_lower('ingest', code) == 'nightly': self.worker.ingest_nightly(self.mediapackage) context.get_state().is_recording = False self.timer_thread_id = None
def close_recording(self): """Set the final data on the mediapackage, stop the record and restart the preview""" paused = self.paused_time.total_seconds()*1000000000 # pass to ns close_duration = int((self.recorder.get_time()-self.initial_time-paused)*1000/gst.SECOND) # To avoid error messages on stopping pipelines if self.error_dialog: if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.recorder.stop_record_and_restart_preview() self.change_state(GC_STOP) self.mediapackage.status = mediapackage.RECORDED self.mediapackage.properties['origin'] = self.conf.hostname self.repo.add_after_rec(self.mediapackage, self.recorder.bins_desc, close_duration, self.mediapackage.manual) code = 'manual' if self.mediapackage.manual else 'scheduled' if self.conf.get_lower('ingest', code) == 'immediately': self.worker.ingest(self.mediapackage) elif self.conf.get_lower('ingest', code) == 'nightly': self.worker.ingest_nightly(self.mediapackage) context.get_state().is_recording = False self.timer_thread_id = None
def _update_images(self, delay): time.sleep(delay) files = {} audio_devices = ['audiotest', 'autoaudio', 'pulse'] for track in context.get_state().profile.tracks: if track.device not in audio_devices: file = os.path.join('/tmp', track.file + '.jpg') try: if(os.path.getctime(file) > time.time() - 3): files[track.flavor] = (track.flavor + '.jpg', open(file, 'rb'), 'image/jpeg') except Exception: logger.warn("Unable to check date of or open file (%s)" % file) im = ImageGrab.grab(bbox=(10, 10, 1280, 720), backend='imagemagick') im.thumbnail((640, 360)) output = cStringIO.StringIO() if im.mode != "RGB": im = im.convert("RGB") im.save(output, format="JPEG") files['galicaster'] = ('galicaster.jpg', output.getvalue(), 'image/jpeg') try: # add verify=False for testing self signed certs requests.post( "%s/image/%s" % (self._http_host, self.id), files=files, auth=( self._user, self._password)) except Exception: logger.warn('Unable to post images')
def _update_images(self, delay): time.sleep(delay) files = {} audio_devices = ['audiotest', 'autoaudio', 'pulse'] for track in context.get_state().profile.tracks: if track.device not in audio_devices: file = os.path.join('/tmp', track.file + '.jpg') try: if (os.path.getctime(file) > time.time() - 3): files[track.flavor] = (track.flavor + '.jpg', open(file, 'rb'), 'image/jpeg') except Exception: logger.warn("Unable to check date of or open file (%s)" % file) im = ImageGrab.grab(bbox=(10, 10, 1280, 720), backend='imagemagick') im.thumbnail((640, 360)) output = cStringIO.StringIO() if im.mode != "RGB": im = im.convert("RGB") im.save(output, format="JPEG") files['galicaster'] = ('galicaster.jpg', output.getvalue(), 'image/jpeg') try: # add verify=False for testing self signed certs requests.post("%s/image/%s" % (self._http_host, self.id), files=files, auth=(self._user, self._password)) except Exception: logger.warn('Unable to post images')
def select_devices(self): """Loads the bins and creates the preview areas for the active profile, creating a new mediapacakge.""" self.configure_profile() logger.info("Setting Devices the new way") now = datetime.datetime.now().replace(microsecond=0) self.mediapackage = mediapackage.Mediapackage( title="Recording started at " + now.isoformat()) context.get_state().mp = self.mediapackage.identifier current_profile = self.conf.get_current_profile() bins = current_profile.tracks for objectbin in bins: objectbin['path'] = self.repo.get_rectemp_path() devices = current_profile.get_video_areas() areas = self.create_drawing_areas(devices) self.bins = bins self.areas = areas if self.error_dialog: if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.error_id = self.dispatcher.connect("recorder-error", self.handle_pipeline_error) self.audiobar.ClearVumeter() if self.ok_to_show: self.init_recorder() return True
def quit(): if not context.get_state().is_recording: # Emit quit signal and exit gtk.gdk.threads_enter() context.get_dispatcher().emit('galicaster-notify-quit') gtk.main_quit() gtk.gdk.threads_leave()
def select_devices(self): """Loads the bins and creates the preview areas for the active profile, creating a new mediapacakge.""" self.configure_profile() logger.info("Setting Devices the new way") now = datetime.datetime.now().replace(microsecond=0) self.mediapackage = mediapackage.Mediapackage(title="Recording started at " + now.isoformat()) context.get_state().mp = self.mediapackage.identifier current_profile = self.conf.get_current_profile() bins = current_profile.tracks for objectbin in bins: objectbin["path"] = self.repo.get_rectemp_path() devices = current_profile.get_video_areas() areas = self.create_drawing_areas(devices) self.bins = bins self.areas = areas if self.error_dialog: if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.error_id = self.dispatcher.connect("recorder-error", self.handle_pipeline_error) self.audiobar.ClearVumeter() if self.ok_to_show: self.init_recorder() return True
def configure_profile(self): profile = self.conf.get_current_profile() context.get_state().profile = profile if profile.execute: out = os.system(profile.execute) logger.info("Executing {0} with out {1}".format(profile.execute, out)) if out: self.dispatcher.emit("recorder-error", "Error executing command configuring profile")
def on_start_before(self, origin, key): """ Start a recording before its schedule or via rest """ if key: logger.info("Start recording before schedule") self.mediapackage = self.repo.get(key) context.get_state().mp=self.mediapackage.identifier else: logger.info("Rest triggered recording") self.on_rec() return True
def on_start_before(self, origin, key): """ Start a recording before its schedule or via rest """ if key: logger.info("Start recording before schedule") self.mediapackage = self.repo.get(key) context.get_state().mp = self.mediapackage.identifier else: logger.info("Rest triggered recording") self.on_rec() return True
def handle_pipeline_error(self, origin, error_message): """ Captures a pipeline error. If the recording are is active, shows it """ self.change_state(GC_ERROR) self.timer_thread_id = None context.get_state().is_error = True self.recorder.stop_elements() context.get_state().is_recording = False self.error_count += 1 if (self.error_count > 5): logger.error("Error. Show message ({})".format(self.error_count)) self.show_pipeline_error(origin, error_message) elif(self.status not in [ GC_RECORDING, GC_PAUSED ]): if self.error_count == 1: self.repo.save_crash_recordings() logger.error("Error, retry intent {}".format(self.error_count)) self.error_handle_id = gobject.timeout_add_seconds(13, self.select_devices)
def on_start_recording(self, sender, id): self.recording = True self.currentMediaPackage = self.media_package_metadata(id) self.currentProfile = context.get_state().profile.name self.update('rooms', {'_id': self.id}, { '$set': { 'currentMediaPackage': self.currentMediaPackage, 'currentProfile': self.currentProfile, 'recording': self.recording } })
def stop(): response.content_type = 'text/html' state = context.get_state() if state.is_recording: #Emit the signal to begin the recording gtk.gdk.threads_enter() context.get_dispatcher().emit('stop-record', 0) gtk.gdk.threads_leave() return "Signal to stop recording sent" else: abort(500, "failed to stop the capture, or no current active capture")
def start_thread(self,identifier): """Thread handling a scheduled recording""" self.start_thread_id = 1 if self.status == GC_PREVIEW: # Record directly self.mediapackage = self.repo.get(self.current_mediapackage) context.get_state().mp = self.mediapackage.identifier self.on_rec() elif self.status in [ GC_RECORDING, GC_PAUSED ] : if self.allow_overlap: pass # TODO: dont stop and extend recording until the end of the new interval # In case of stop, restart with the overlapped job else: # Stop current recording, wait until prewiew restarted and record self.restarting = True self.close_recording() while self.restarting: time.sleep(0.1) if self.start_thread_id == None: return self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() elif self.status == GC_INIT: # Start Preview and Record self.on_start_button() while self.recorder.get_status() != gst.STATE_PLAYING: time.sleep(0.2) if self.start_thread_id == None: return self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() elif self.status == GC_ERROR: if self.error_dialog: if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.on_start_button() while self.recorder.get_status() != gst.STATE_PLAYING: time.sleep(0.2) if self.start_thread_id == None: return self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() title = self.repo.get(identifier).title self.dispatcher.emit("update-video", title) return None
def check_pipeline_amp(self, valor): if context.get_state().is_recording: rms = valor rms_list.append(rms) if os.path.exists(temp_amp): f = open(temp_amp, 'a') else: f = open(temp_amp, 'w') if len(rms_list) > 100: f.write(str(max(rms_list)) + '\n') f.close() del rms_list[:]
def close_recording(self): """Set the final data on the mediapackage, stop the record and restart the preview""" # To avoid error messages on stopping pipelines if self.error_dialog: self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.recorder.stop_record_and_restart_preview() self.change_state(GC_STOP) context.get_state().is_recording = False self.timer_thread_id = None
def start_thread(self, identifier): """Thread handling a scheduled recording""" self.start_thread_id = 1 if self.status == GC_PREVIEW: # Record directly self.mediapackage = self.repo.get(self.current_mediapackage) context.get_state().mp = self.mediapackage.identifier self.on_rec() elif self.status in [GC_RECORDING, GC_PAUSED]: if self.allow_overlap: pass # TODO: dont stop and extend recording until the end of the new interval # In case of stop, restart with the overlapped job else: # Stop current recording, wait until prewiew restarted and record self.restarting = True self.close_recording() while self.restarting: time.sleep(0.1) if self.start_thread_id == None: return self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() elif self.status == GC_INIT: # Start Preview and Record self.on_start_button() while self.recorder.get_status() != gst.STATE_PLAYING: time.sleep(0.2) if self.start_thread_id == None: return self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() elif self.status == GC_ERROR: if self.error_dialog: if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.on_start_button() while self.recorder.get_status() != gst.STATE_PLAYING: time.sleep(0.2) if self.start_thread_id == None: return self.mediapackage = self.repo.get(self.current_mediapackage) self.on_rec() title = self.repo.get(identifier).title self.dispatcher.emit("update-video", title) return None
def start(): response.content_type = 'text/html' state = context.get_state() # Already Recording if state.is_recording: abort(500, "couldn't start capture") else: gtk.gdk.threads_enter() context.get_dispatcher().emit('start-before', None) gtk.gdk.threads_leave() return "Signal to start recording sent"
def __init__(self): DBusService(self) logger.info('galicaster.__version__: %r', __version__) logger.info('galicaster.__file__: %r', __file__) self.conf = context.get_conf() self.state = context.get_state() self.dispatcher = context.get_dispatcher() self.modules = self.conf.get_modules() self.load_modules() self.dispatcher.connect('net-up', self.check_net, True) self.dispatcher.connect('net-down', self.check_net, False)
def __init__(self): DBusService(self) logger.info("galicaster.__version__: %r", __version__) logger.info("galicaster.__file__: %r", __file__) self.conf = context.get_conf() self.state = context.get_state() self.dispatcher = context.get_dispatcher() self.modules = self.conf.get_modules() self.load_modules() self.dispatcher.connect("net-up", self.check_net, True) self.dispatcher.connect("net-down", self.check_net, False)
def select_devices(self): """Loads the bins and creates the preview areas for the active profile, creating a new mediapacakge.""" self.configure_profile() logger.info("Setting Devices the new way") now = datetime.datetime.now().replace(microsecond=0) self.mediapackage = mediapackage.Mediapackage(title=_("Recording started at {0}").format(now.isoformat())) context.get_state().mp = self.mediapackage.identifier if self.ok_to_show: self.init_recorder() self.error_handle_id = None return False
def init_recorder(self): if self.error_dialog: self.error_dialog.dialog_destroy() self.error_dialog = None self.error_text = None self.audiobar.ClearVumeter() context.get_state().is_error = False current_profile = self.conf.get_current_profile() bins = current_profile.tracks for objectbin in bins: objectbin['path'] = self.repo.get_rectemp_path() self.recorder = Recorder(bins) self.recorder.mute_preview(not self.focus_is_active) info = self.recorder.get_display_areas_info() if self.swap: info.reverse() areas = self.create_drawing_areas(info) self.recorder.set_drawing_areas(areas) if self.start_recording: self.start_recording = False ok = self.recorder.preview_and_record() self.mediapackage = self.repo.get(self.current_mediapackage) # NOTE only call on_rec to update UI. Recorder is already recording. self.on_rec() else: ok = self.recorder.preview() if ok : if self.mediapackage.manual: self.change_state(GC_PREVIEW) else: logger.error("Restarting Preview Failed") context.get_state().is_error = True self.change_state(GC_ERROR) if self.scheduled_recording: self.on_failed_scheduled(self.current_mediapackage)
def on_start_recording(self, sender, id): self.recording = True self.currentMediaPackage = self.media_package_metadata(id) self.currentProfile = context.get_state().profile.name self.update( 'rooms', { '_id': self.id }, { '$set': { 'currentMediaPackage': self.currentMediaPackage, 'currentProfile': self.currentProfile, 'recording': self.recording } })
def on_rec(self, button=None): """Manual Recording """ logger.info("Recording") self.dispatcher.emit("starting-record") self.recorder.record() self.mediapackage.status = mediapackage.RECORDING now = datetime.datetime.utcnow().replace(microsecond=0) self.mediapackage.setDate(now) self.timer_thread_id = 1 self.timer_thread = thread(target=self.timer_launch_thread) self.timer_thread.daemon = True self.timer_thread.start() self.change_state(GC_RECORDING) context.get_state().is_recording = True return True
def handle_pipeline_error(self, origin, error_message): """ Captures a pipeline error. If the recording are is active, shows it """ self.change_state(GC_ERROR) self.recorder.stop_elements() context.get_state().is_recording = False if self.error_id: self.dispatcher.disconnect(self.error_id) self.error_id = None #TODO kill previous error if needed self.error_text = error_message if self.focus_is_active: self.launch_error_message(error_message)
def __init__(self): DBusService(self) logger.info('galicaster.__version__: %r', __version__) logger.info('galicaster.__file__: %r', __file__) self.conf = context.get_conf() self.state = context.get_state() self.dispatcher = context.get_dispatcher() self.modules = self.conf.get_modules() self.load_modules() self.dispatcher.connect('net-up', self.check_net, True) self.dispatcher.connect('net-down', self.check_net, False) self.dispatcher.connect("reload-profile", self.reload_profile) self.reload_profile(None) # To exec the execute to start
def on_rec(self,button=None): """Manual Recording """ logger.info("Recording") self.dispatcher.emit("starting-record") self.recorder.record() self.mediapackage.status=mediapackage.RECORDING now = datetime.datetime.utcnow().replace(microsecond=0) self.mediapackage.setDate(now) self.timer_thread_id = 1 self.timer_thread = thread(target=self.timer_launch_thread) self.timer_thread.daemon = True self.timer_thread.start() self.change_state(GC_RECORDING) context.get_state().is_recording = True return True
def check_status_area(self, origin, signal=None, other=None): """Updates the values on the recording tab""" s1 = self.gui.get_object("status1") s2 = self.gui.get_object("status2") # s3 = self.gui.get_object("status3") s4 = self.gui.get_object("status4") freespace,text_space=status_bar.GetFreeSpace(self.repo.get_rectemp_path()) s1.set_text(text_space) four_gb = 4000000000.0 hours = int(freespace/four_gb) s2.set_text(_("{0} hours left").format(str(hours))) agent = context.get_state().hostname # TODO just consult it once if s4.get_text() != agent: s4.set_text(agent)
def event_change_mode(self, orig, old_state, new_state): """Handles the focus or the Rercording Area, launching messages when focus is recoverde""" if new_state == 0: self.focus_is_active = True if self.recorder: self.recorder.mute_preview(False) if self.error_text: if self.status != GC_ERROR: self.change_state(GC_ERROR) context.get_state().is_error = True self.launch_error_message(self.error_text) if old_state == 0: self.focus_is_active = False if self.recorder: self.recorder.mute_preview(True)
def check_status_area(self, origin, signal=None, other=None): """Updates the values on the recording tab""" s1 = self.gui.get_object("status1") s2 = self.gui.get_object("status2") # s3 = self.gui.get_object("status3") s4 = self.gui.get_object("status4") freespace, text_space = status_bar.GetFreeSpace( self.repo.get_attach_path()) s1.set_text(text_space) four_gb = 4000000000.0 hours = int(freespace / four_gb) s2.set_text(str(hours) + " hours left") agent = context.get_state().hostname # TODO just consult it once if s4.get_text() != agent: s4.set_text(agent)
def index(): response.content_type = 'application/json' state = context.get_state() text="Galicaster REST endpoint plugin\n\n" endpoints = { "/state" : "show some state values", "/repository" : "list mp keys" , "/repository/:id" : "get mp manifest (XML)", "/metadata/:id" : "get mp metadata (JSON)", "/start" : "starts a manual recording", "/stop" : "stops current recording", "/operation/ingest/:id" : "Ingest MP", "/operation/sidebyside/:id" : "Export MP to side-by-side", "/operation/exporttozip/:id" : "Export MP to zip", "/screen" : "get a screenshoot of the active" } return json.dumps(endpoints)
def check_status_area(self, origin, signal=None, other=None): """Updates the values on the recording tab""" s1 = self.gui.get_object("status1") s2 = self.gui.get_object("status2") # s3 = self.gui.get_object("status3") s4 = self.gui.get_object("status4") freespace = self.repo.get_free_space() text_space = readable.size(freespace) s1.set_text(text_space) four_gb = 4000000000.0 hours = int(freespace/four_gb) s2.set_text(_("{0} hours left").format(str(hours))) agent = context.get_state().hostname # TODO just consult it once if s4.get_text() != agent: s4.set_text(agent)
def on_rec(self,button=None, pre_filled=False): """Manual Recording """ logger.info("Recording") self.dispatcher.emit("starting-record") self.recorder.record() self.mediapackage.status=mediapackage.RECORDING now = datetime.datetime.utcnow().replace(microsecond=0) self.mediapackage.setDate(now) if self.mediapackage.manual and not pre_filled: self.mediapackage.setTitle(_("Recording started at {0}").format(now.isoformat())) self.timer_thread_id = 1 self.timer_thread = thread(target=self.timer_launch_thread) self.timer_thread.daemon = True self.timer_thread.start() self.change_state(GC_RECORDING) context.get_state().is_recording = True return True
def check_key(source, event): """ Filter Ctrl combinations for quit,restart and configuration """ dispatcher = context.get_dispatcher() window = context.get_mainwindow() state = context.get_state() if ((event.state & gtk.gdk.SHIFT_MASK and event.state & gtk.gdk.CONTROL_MASK) and event.state & gtk.gdk.MOD2_MASK and (event.keyval in [gtk.gdk.keyval_from_name('q'), gtk.gdk.keyval_from_name('Q')])): if not state.is_recording: dispatcher.emit('galicaster-quit') if ((event.state & gtk.gdk.CONTROL_MASK) and event.keyval == gtk.gdk.keyval_from_name('Return') ): window.toggle_fullscreen(None) return True
def __init__(self): service = DBusService(self) self.conf = context.get_conf() self.state = context.get_state() self.dispatcher = context.get_dispatcher() self.modules = [] self.modules.append('recorder') if self.conf.get_boolean('basic', 'admin'): self.modules.append('media_manager') self.modules.append('player') if self.conf.get_boolean('ingest', 'active'): self.modules.append('scheduler') if self.conf.get_boolean('basic', 'pin'): self.modules.append('pin') self.load_modules() self.dispatcher.connect('net-up', self.check_net, True) self.dispatcher.connect('net-down', self.check_net, False)
def check_key(source, event): """ Filter Ctrl combinations for quit,restart and configuration """ dispatcher = context.get_dispatcher() window = context.get_mainwindow() state = context.get_state() if ((event.state & gtk.gdk.SHIFT_MASK and event.state & gtk.gdk.CONTROL_MASK) and event.state & gtk.gdk.MOD2_MASK and (event.keyval in [gtk.gdk.keyval_from_name('q'), gtk.gdk.keyval_from_name('Q')])): if not state.is_recording: dispatcher.emit('galicaster-quit') if ((event.state & gtk.gdk.CONTROL_MASK) and event.keyval == gtk.gdk.keyval_from_name('Return')): window.toggle_fullscreen(None) return True
def check_net(self, origin, data): context.get_state().net = data
def change_state(self, state): """Activates or deactivates the buttons depending on the new state""" record = self.gui.get_object("recbutton") pause = self.gui.get_object("pausebutton") stop = self.gui.get_object("stopbutton") helpb = self.gui.get_object("helpbutton") editb = self.gui.get_object("editbutton") prevb = self.gui.get_object("previousbutton") swapb = self.gui.get_object("swapbutton") if not self.swap_active: swapb.hide() if state != self.status: self.previous, self.status = self.status, state if state == GC_INIT: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) swapb.set_sensitive(False) self.dispatcher.emit("update-rec-status", "Initialization") elif state == GC_PREVIEW: record.set_sensitive((self.allow_start or self.allow_manual)) pause.set_sensitive(False) pause.set_active(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) swapb.set_sensitive(True) if self.next == None: self.dispatcher.emit("update-rec-status", "Idle") else: self.dispatcher.emit("update-rec-status", "Waiting") elif state == GC_RECORDING: record.set_sensitive(False) pause.set_sensitive(self.allow_pause and self.recorder.is_pausable()) stop.set_sensitive((self.allow_stop or self.allow_manual)) helpb.set_sensitive(True) prevb.set_sensitive(False) swapb.set_sensitive(False) editb.set_sensitive(True and not self.scheduled_recording) self.dispatcher.emit("update-rec-status", " Recording ") elif state == GC_PAUSED: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) prevb.set_sensitive(False) helpb.set_sensitive(False) editb.set_sensitive(False) self.dispatcher.emit("update-rec-status", "Paused") elif state == GC_STOP: if self.previous == GC_PAUSED: self.pause_dialog.destroy() record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) elif state == GC_BLOCKED: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(False) prevb.set_sensitive(False) editb.set_sensitive(False) elif state == GC_ERROR: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) context.get_state().status = STATUS[state][0] if self.next == None and state == GC_PREVIEW: self.view.set_displayed_row(GC_PRE2) else: self.view.set_displayed_row(state)
def state(): response.content_type = 'application/json' state = context.get_state() return json.dumps(state.get_all())
def change_state(self, state): """Activates or deactivates the buttons depending on the new state""" record = self.gui.get_object("recbutton") pause = self.gui.get_object("pausebutton") stop = self.gui.get_object("stopbutton") helpb = self.gui.get_object("helpbutton") editb = self.gui.get_object("editbutton") prevb = self.gui.get_object("previousbutton") swapb = self.gui.get_object("swapbutton") if not self.swap_active: swapb.hide() if state != self.status: self.previous,self.status = self.status,state if state == GC_INIT: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) swapb.set_sensitive(False) self.dispatcher.emit("update-rec-status", "Initialization") elif state == GC_PREVIEW: record.set_sensitive( (self.allow_start or self.allow_manual) ) pause.set_sensitive(False) pause.set_active(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) swapb.set_sensitive(True) if self.next == None: self.dispatcher.emit("update-rec-status", "Idle") else: self.dispatcher.emit("update-rec-status", "Waiting") elif state == GC_RECORDING: record.set_sensitive(False) pause.set_sensitive(self.allow_pause and self.recorder.is_pausable()) stop.set_sensitive( (self.allow_stop or self.allow_manual) ) helpb.set_sensitive(True) prevb.set_sensitive(False) swapb.set_sensitive(False) editb.set_sensitive(True and not self.scheduled_recording) self.dispatcher.emit("update-rec-status", " Recording ") elif state == GC_PAUSED: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) prevb.set_sensitive(False) helpb.set_sensitive(False) editb.set_sensitive(False) self.dispatcher.emit("update-rec-status", "Paused") elif state == GC_STOP: if self.previous == GC_PAUSED: self.pause_dialog.destroy() record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) elif state == GC_BLOCKED: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(False) prevb.set_sensitive(False) editb.set_sensitive(False) elif state == GC_ERROR: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True ) editb.set_sensitive(False) context.get_state().status = STATUS[state][0] if self.next == None and state == GC_PREVIEW: self.view.set_displayed_row(GC_PRE2) else: self.view.set_displayed_row(state)