def start(self): """Starts the Clutter main event loop and sets our kernel startup routine. """ # Register our function to initiate the kernel and start Clutter GObject.idle_add(self._wire_kernel) Clutter.init([]) Clutter.main()
def _on_lag(self, lag_type, element_to_hilite, lag_duration): """ Stops ('lags') the scanning proccess for the given amount of time and performes all the previously ordered actions, i.e. highlights the current element. In the end schedules an adequate closure. :param lag_type: type of lag to be performed. Currently there are only two of them: 'start_up' that can happen before the scanning proccess starts and 'select', after selection of an element. :param element_to_hilite: element that has scanning focus during the lag and that should be highlighted. :param lag_duration: duration of the lag in miliseconds. """ if self.lag_hilite_mode == "blink": timeout_start = time.time() self.blink(element_to_hilite, timeout_start, lag_duration, self.blinking_freq) elif self.lag_hilite_mode == "still": if hasattr(element_to_hilite, "enable_lag_hilite"): element_to_hilite.enable_lag_hilite() if lag_type == "start_up": closure = self._do_start param = None elif lag_type == "select": closure = self._do_select param = element_to_hilite Clutter.threads_add_timeout(0, lag_duration, closure, param)
def clutter(self): if self.actor is None: if self._tag == 'img': self.actor = Clutter.Texture() self.actor.set_from_file(self._src) elif self._tag == 'video': self.actor = ClutterGst.VideoTexture() self.actor.set_seek_flags(ClutterGst.SeekFlags(1)) self.actor.set_uri(self._src) self.actor.connect("eos", self._after) if self._region in region_names: parent = False for region in region_names[self._region]: if not parent: region.stage.add_actor(self.actor) parent = True else: clone = Clutter.Clone.new(self.actor) region.stage.add_actor(clone) self.clone.append(clone) elif self._region in region_ids: region_ids[self._region].stage.add_actor(self.actor) else: stage.add_actor(self.actor) if self._tag == 'img': Clutter.threads_add_timeout(0, self._dur, self._after, None) elif self._tag == 'video': self.actor.set_progress(0.0) self.actor.set_playing(True) self.actor.show()
def run(self, block): self.idx = 0 self.items = block.get_children() self.limit = len(self.items) Clutter.threads_add_timeout(0, self.pace, self._on_timeout, None) self.is_running = True self._on_timeout(None)
def _do_run_app(self, app_exec): cmd = ["python3", app_exec] cmd.extend(sys.argv[1:]) self.current_app = subprocess.Popen(cmd) self.current_app.wait() Clutter.threads_add_idle(0, self.maximize_panel, None) self.current_app = None
def button_press_handler(self, widget, event): print(event) if event.button == 1: self.dash.show(self, event.time) self.dash.window.focus(event.time) elif event.button == 3: Clutter.main_quit()
def __init__(self): self.stage = Clutter.Stage() self.stage.set_title('Clutter example') self.stage.set_background_color(Clutter.color_from_string('#BBB')[1]) self.stage.set_size(300.0, 300.0) self.actor = Clutter.Actor() self.actor.set_background_color(Clutter.color_from_string('#DA0060')[1]) self.actor.set_position(75.0, 75.0) self.actor.set_size(150.0, 150.0) self.actor.set_pivot_point(0.5, 0.5) self.rotation = Clutter.PropertyTransition(property_name='rotation-angle-z') self.rotation.set_animatable(self.actor) self.rotation.set_duration(5000) self.rotation.set_from(0.0) self.rotation.set_to(360.0) self.rotation.set_repeat_count(-1) self.rotation.start() text = Clutter.Text.new_full('Arial Black 12', 'Click me!', Clutter.color_from_string('black')[1]) self.actor.add_child(text) self.stage.add_child(self.actor) self.stage.show() self.actor.set_reactive(True) self.stage.set_user_resizable(True) self.actor.connect('button-press-event', self.color_actor) self.stage.connect('key-press-event', self.on_key_press) self.stage.connect('destroy', lambda *_: Clutter.main_quit())
def on_key_press_event(stage, event): scroll = stage.get_first_child() menu = scroll.get_first_child() key = event.keyval if key == Clutter.KEY_q: Clutter.main_quit() return True if key == Clutter.KEY_Up: item = menu.select_prev() if item is not None: pos = Clutter.Point() (pos.x, pos.y) = item.get_position() scroll.scroll_to_point(pos) return True if key == Clutter.KEY_Down: item = menu.select_next() if item is not None: pos = Clutter.Point() (pos.x, pos.y) = item.get_position() scroll.scroll_to_point(pos) return True if key == Clutter.KEY_Return or key == Clutter.KEY_KP_Enter: menu.activate_item() return True return False
def run(self): """ Run automatic slideshow. Turn on the fullscreen mode if the corresponding property is setted to True. """ if self.slideshow_on_fullscreen: self.fullscreen_on = True self.stage = self.get_stage() self.cover_frame = Clutter.Actor() self.cover_frame.set_size(unit.size_pix[0], unit.size_pix[1]) self.slide.remove_transition("x") self.remove_child(self.slide) self.cover_frame.add_child(self.slide) self.slide.set_x(0) cover_frame_color = Clutter.Color.new(0, 0, 0, 255) self.cover_frame.set_background_color(cover_frame_color) if (self.cached_slide_width is None and self.cached_slide_height is None): self.cached_slide_width, self.cached_slide_height = \ self.slide.get_size() self.slide.set_size(unit.size_pix[0], unit.size_pix[1]) self.stage.add_child(self.cover_frame) self.slideshow_on = True Clutter.threads_add_timeout(0, self.idle_duration, lambda _: self.slideshow_timeout(), None)
def __init__(self): Clutter.init([]) self.__latitude = None self.__longitude = None self.__selected_marker = None self.__active_sensitive = False self.__marker_last_location = None self.__factory = Champlain.MapSourceFactory.dup_default() self.__set_location_context_menu = None self.__locations = [] self.__task_locations = {} self.__tag_locations = {} self.__view = None self.__vbox_map = None self.__map = None self.__current_layer = None self.__menu_item_tag_sidebar = None self.__plugin_api = None self.__where = Geoclue() self.__where.client.connect_to_signal( 'LocationUpdated', self._location_updated ) self.__where.client.Start() self.__distance = 15 self.__preferences = None
def __init__(self): self.stage = Clutter.Stage() self.stage.set_size(400, 400) self.layout_manager = Clutter.BoxLayout() self.textures_box = Clutter.Actor(layout_manager=self.layout_manager) self.stage.add_actor(self.textures_box) self.video_texture = Clutter.Texture.new() self.video_texture.set_keep_aspect_ratio(True) self.video_texture.set_size(400,400) self.layout_manager.pack(self.video_texture, expand=False, x_fill=False, y_fill=False, x_align=Clutter.BoxAlignment.CENTER, y_align=Clutter.BoxAlignment.CENTER) self.camera = Cheese.Camera.new(self.video_texture, None, 100, 100) Cheese.Camera.setup(self.camera, None) Cheese.Camera.play(self.camera) def added(signal, data): uuid=data.get_uuid() node=data.get_device_node() print "uuid is " +str(uuid) print "node is " +str(node) self.camera.set_device_by_device_node(node) self.camera.switch_camera_device() device_monitor=Cheese.CameraDeviceMonitor.new() device_monitor.connect("added", added) device_monitor.coldplug() self.stage.show() Clutter.main()
def do_leave_event (self, actor, event): if self._is_pressed == True: self._is_pressed = False Clutter.ungrab_pointer() return True else: return False
def do_button_press_event (self, actor, event): if event.button == 1: self._is_pressed = True Clutter.grab_pointer(self) return True else: return False
def __init__(self, container, argv): PisakEduApp.APP = self Clutter.init(argv) self.stage = PisakEduStage(container) self.stage.connect("destroy", lambda _: Clutter.main_quit()) self.stage.set_fullscreen(True) self.stage.show_all()
def load_popup(self, message, unwind=None, unwind_data=None, container=None, timeout=5000): """ Load a pop-up view with some message displayed and then, after a given amount of time automatically load some another view or perform some operation. :param message: message to be displayed on the screen. :param unwind: name of a view that should be loaded after the `timeout` expires or callable that should be called then or None. :param unwind_data: data to be passed to an unwind handler or None. :param container: container that popup should be added to or None, if None then it will be displayed as a standard standalone view. :param timeout: time after which the `unwind` will be executed automatically, in miliseconds, default is 1 second, if -1 then the `unwind` to will not be executed at all. :return: None. """ if timeout >= 0 and unwind is not None: if callable(unwind): handler = (lambda *_: unwind(unwind_data)) if \ unwind_data is not None else lambda *_: unwind() else: handler = lambda *_: self.load_view(unwind, unwind_data) Clutter.threads_add_timeout(0, timeout, handler) if container: self._display_popup_widget(container, message) else: self.load_view("popup", {"message": message})
def __init__(self, argv, descriptor): super().__init__() Clutter.init(sys.argv) # application main window, instance of :see: :class: `window.Window`: self.window = None # path to a file with style definition: self.style = None # dictionary for all the application basic elements: self.box = {} # if playing of the sound effects should be enabled: self.sound_effects_enabled = False # indicator of the application main loop status, should be used # with caution as there will always be some non-zero time interval # between setting this flag 'True' and actual launching of the loop and # between actual quit of the loop and setting the flag 'False': self.main_loop_is_running = False # player of any audio effects: self.sound_effects_player = None self._sound_effects = {} self._read_descriptor(descriptor) self._configure() self._initialize_style() self._initialize_window(argv, descriptor) self._initialize_sound_effects_player()
def blink(blinking_element, timeout_start, overall_duration, freq): """ Make the given element blinking. :param blinking_element: any :class:`Scannable` instance. :param timeout_start: current timestamp, helps calculating when the animation should be over. :param overall_duration: total duration of the blinking animation. :param freq: frequency of blinking. """ hilitten = False def switch_hilite(): nonlocal hilitten when_to_exit = timeout_start + (overall_duration - 2*freq)/1000 if time.time() > when_to_exit: if hasattr(blinking_element, "disable_lag_hilite"): blinking_element.disable_lag_hilite() return False else: if hilitten: if hasattr(blinking_element, "disable_lag_hilite"): blinking_element.disable_lag_hilite() hilitten = False else: if hasattr(blinking_element, "enable_lag_hilite"): blinking_element.enable_lag_hilite() hilitten = True return True Clutter.threads_add_timeout(0, freq, switch_hilite)
def main(args): Gst.init() record_view = RecordView() if args.interactive: gui_thread = Thread(target=record_view.show_and_run) gui_thread.daemon = True gui_thread.start() else: record_view.show() while record_view.video_view is None: time.sleep(.1) print 'waiting for GUI' view = record_view.video_view def add_svg(view, svg_path): actor = SvgGroup.from_path(svg_path) view.stage.add_actor(actor) actor.add_constraint(Clutter.BindConstraint .new(view.stage, Clutter.BindCoordinate.SIZE, 0)) if args.svg_path is not None: Clutter.threads_add_idle(GLib.PRIORITY_DEFAULT, add_svg, view, args.svg_path) if args.interactive: raw_input() else: record_view.show_and_run() return record_view
def main(): GLib.threads_init() Clutter.init(sys.argv) MainWindow() Clutter.main()
def __init__(self, argv): PisakSpellerApp.APP = self Clutter.init(argv) self.stage = PisakSpellerStage() TimerCycle(self.stage.contents).start_cycle() self.stage.connect("destroy", lambda _: Clutter.main_quit()) self.stage.set_fullscreen(True) self.stage.show_all()
def do_button_release_event (self, actor, event): if event.button == 1 and self._is_pressed == True: self._is_pressed = False Clutter.ungrab_pointer() self.emit('clicked') return True else: return False
def __init__(self): Clutter.init() self.stage = TextStage() self.stage.connect("destroy", lambda *_: Clutter.main_quit()) self.stage.show_all() Clutter.main()
def run_automatic(self): """ Start automatic page flipping. """ if self._page_count > 1: self.is_running = True Clutter.threads_add_timeout(0, self.idle_duration, self._automatic_timeout, None)
def __init__(self): super().__init__() self.dynamic_canvas = DynamicCanvas() self.dynamic_canvas.set_x_expand(True) self.dynamic_canvas.set_y_expand(True) self.add_child(self.dynamic_canvas) self.layout = Clutter.BoxLayout() self.set_layout_manager(self.layout) Clutter.threads_add_timeout(0, 33, self._render, None)
def on_new_data(self, data): """ Receives new raw data, parses them and schedules calling the main thread callback. :param data: raw data. """ x, y = self.parse_coords(data) Clutter.threads_add_timeout(-100, 20, self.on_new_coords, x, y)
def do_prediction(self, text, position): context = self.get_prediction_context(text[0:position]) if context == '': self.content = self.basic_content else: self.content = predictor.get_predictions(context) if len(self.content) == 1: self.content[0] = self.content[0] + ' ' # automatic space if only one suggestion Clutter.threads_add_idle(0, self.emit, "content-update")
def _schedule_sending_data(self, direction): """ Schedule sending the data as soon as it is available. Data should be loaded in a background. :param direction: -1 or 1, that is whether data should be sent from backward or forward. """ Clutter.threads_add_timeout(0, 0.1, self._send_data, direction)
def _do_start(self, source=None): self.index = None self._cycle_count = 0 self._expose_next(enforced=True) self.timeout_token = object() if hasattr(self.group, "disable_lag_hilite"): self.group.disable_lag_hilite() Clutter.threads_add_timeout(0, self.interval, self.cycle_timeout, self.timeout_token)
def start(self): self.compute_sequence() if len(self._subgroups) == 0: # stop immediately self.index = None Clutter.threads_add_timeout(0, self.interval, self.cycle_timeout, self.timeout_token) else: self.index = None self._cycle_count = 0 self._expose_next() self.timeout_token = object() Clutter.threads_add_timeout(0, self.interval, self.cycle_timeout, self.timeout_token)
def load(self, warp_path): warp_path = str(warp_path) try: parent_corners = pd.read_hdf(warp_path, '/corners/parent') child_corners = pd.read_hdf(warp_path, '/corners/child') self.parent_corners[:] = parent_corners self.child_corners[:] = child_corners except Exception: pass else: Clutter.threads_add_idle(GLib.PRIORITY_DEFAULT, self.update_transform)
def cairo_draw(canvas, cr): # Rather than using GTimeDate (which I couldn't find), we'll use Python time. t = time.localtime() s = t.tm_sec * math.pi / 30.0 m = t.tm_min * math.pi / 30.0 h = t.tm_hour * math.pi / 6.0 # Clear the texture contents, so that our drawing doesn't "stack." # If you don't call this, you'll notice lots of aliasing artifacts. canvas.clear() # Scale the modelview to the size of the surface. cr.scale(*canvas.get_surface_size()) cr.set_line_cap(cairo.LINE_CAP_ROUND) cr.set_line_width(0.1) # The black rail that holds the seconds indicator. cr.set_source_rgb(0.0, 0.0, 0.0) cr.translate(0.5, 0.5) cr.arc(0.0, 0.0, 0.4, 0.0, math.pi * 2.0) cr.stroke() # The seconds indicator. cr.set_source_rgb(1.0, 1.0, 1.0) cr.move_to(0.0, 0.0) cr.arc(math.sin(s) * 0.4, -math.cos(s) * 0.4, 0.05, 0.0, math.pi * 2) cr.fill() # The minutes hand. Here we want to assign a Clutter-based color to a # cairo context, so we need to use Clutter wrappers. Clutter.cairo_set_source_color( cr, Clutter.Color.get_static(Clutter.StaticColor.CHAMELEON_DARK)) cr.move_to(0.0, 0.0) cr.line_to(math.sin(m) * 0.4, -math.cos(m) * 0.4) cr.stroke() # The hours hand. cr.move_to(0.0, 0.0) cr.line_to(math.sin(h) * 0.2, -math.cos(h) * 0.2) cr.stroke() return True
def __init__(self): Clutter.Actor.__init__(self) self._path = Clutter.Path() self.set_reactive(True) # set default color to black color = Clutter.Color.from_string("#000") self.set_color(color)
def _createPreview(self): if isinstance(self.bElement, GES.AudioUriSource): previewer = AudioPreviewer(self.bElement, self.timeline) previewer.startLevelsDiscoveryWhenIdle() return previewer if isinstance(self.bElement, GES.VideoUriSource): return VideoPreviewer(self.bElement, self.timeline) # TODO: GES.AudioTransition, GES.VideoTransition, GES.ImageSource, # GES.TitleSource return Clutter.Actor()
def create_line(i): line = Clutter.Text() # We must never see this color: line.set_color(Clutter.Color.new(255, 0, 255, 255)) line.set_font_name(self.font) line.set_width(self.char_width * self.shell.cols) line.set_height(self.char_height) line.set_y(i * self.char_height) self.linesGroup.add_actor(line) return line
def add_point_to_bed(self, point): probe = Mash.Model.new_from_file(0, self.config.get("System", "probe-point")) probe.set_size(10, 10) (width, height) = probe.get_size() v_min = Clutter.Vertex() v_max = Clutter.Vertex() data = probe.get_property("data") data.get_extents(v_min, v_max) depth = v_max.z - v_min.z probe.set_y(-depth/2.0-point[2]) probe.set_x(-width/2.0-point[0]) probe.set_z_position(-height/2.0+point[1]) probe.z = point[2] # Store z-value for rescaling probe.set_light_set(self.config.loader.model.light_set) probe.set_rotation_angle(Clutter.RotateAxis.X_AXIS, 90.0) self.config.ui.get_object("model-flipper").add_actor(probe) self.probe_points.append(probe)
def _updateScrollPosition(self, adjustment): self._scroll_pos_ns = Zoomable.pixelToNs(self.hadj.get_value()) point = Clutter.Point() point.x = self.hadj.get_value() point.y = self.vadj.get_value() self.point = point self.timeline.scroll_to_point(point) point.x = 0 self.controls.scroll_to_point(point)
def create_window(self, argv, descriptor): """ Create application main window as the Clutter.Stage. :param: argv: application arguments. :param descriptor: general application descriptor. """ clutter_window = window.Window(self, Clutter.Stage(), descriptor) clutter_window.stage.set_title('PISAK') clutter_window.stage.set_position(unit.MONITOR_X, unit.MONITOR_Y) if arg_parser.get_args().debug: coeff = 0.7 clutter_window.stage.set_size(coeff * unit.w(1), coeff * unit.h(1)) clutter_window.stage.set_user_resizable(True) else: clutter_window.stage.set_size(unit.w(1), unit.h(1)) clutter_window.stage.set_fullscreen(True) clutter_window.stage.connect("destroy", lambda _: Clutter.main_quit()) return clutter_window
def __init__(self): super().__init__() background_image = Clutter.Canvas() background_image.set_size(unit.mm(2), unit.mm(2)) background_image.connect("draw", self.fence_pattern) background_image.invalidate() self.set_content(background_image) self.set_content_repeat(Clutter.ContentRepeat.BOTH) self.set_content_scaling_filters(Clutter.ScalingFilter.TRILINEAR, Clutter.ScalingFilter.TRILINEAR)
def __init__(self, actor, time=300, start=0, end=255): super(FadeAnimation, self).__init__() super(FadeAnimation, self).set_duration(time) alpha = Clutter.Alpha.new_full(self, Clutter.AnimationMode.EASE_OUT_SINE) self.behaviour = Clutter.BehaviourOpacity(alpha=alpha, opacity_start=start, opacity_end=end) self.behaviour.apply(actor)
def __init__(self): Clutter.Actor.__init__(self) layout = Clutter.BoxLayout(orientation=Clutter.Orientation.VERTICAL, spacing=12) self.props.layout_manager = layout self.props.background_color = Clutter.Color.get_static( Clutter.StaticColor.BLACK) self._current_idx = 0
def __init__(self, widget): Clutter.Actor.__init__(self) self.props.reactive = True self._widget = widget self._context = widget.get_style_context() self._canvas = Clutter.Canvas(width=100, height=100) self._canvas.connect('draw', self._on_canvas_draw) self.props.content = self._canvas self.set_content_scaling_filters(Clutter.ScalingFilter.TRILINEAR, Clutter.ScalingFilter.LINEAR) action = Clutter.ClickAction() action.connect('clicked', self._on_clicked) self.add_action(action) self._crossing = False
def animated_move(self, x, y, mode=Clutter.AnimationMode.EASE_OUT_CUBIC): self._move_animation = Clutter.Animation(object=self, mode=mode, duration=250) self._move_animation.bind("antler-window-position", (x, y)) timeline = self._move_animation.get_timeline() timeline.start() return self._move_animation
def get_preview_for_object(bElement, timeline): # Fixme special preview for transitions, titles if not isinstance(bElement.get_parent(), GES.UriClip): return Clutter.Actor() track_type = bElement.get_track_type() if track_type == GES.TrackType.AUDIO: # FIXME: RandomAccessAudioPreviewer doesn't work yet # previewers[key] = RandomAccessAudioPreviewer(instance, uri) # TODO: return waveform previewer return Clutter.Actor() elif track_type == GES.TrackType.VIDEO: if bElement.get_parent().is_image(): # TODO: return still image previewer return Clutter.Actor() else: return VideoPreviewer(bElement, timeline) else: return Clutter.Actor()
def HTMLColorToRGB(self, colorstring): """ convert #RRGGBB to a clutter color var """ colorstring = colorstring.strip() if colorstring[0] == '#': colorstring = colorstring[1:] if len(colorstring) != 6: raise ValueError(f"input #{colorstring} is not in #RRGGBB format") r, g, b = colorstring[:2], colorstring[2:4], colorstring[4:] r, g, b = [int(n, 16) for n in (r, g, b)] return Clutter.Color(r, g, b)
def __init__(self, size): super().__init__() self.width = size[0] self.height = size[1] self.set_size(self.width, self.height) self.canvas = Clutter.Canvas() self.canvas.set_size(self.width, self.height) self.canvas.connect('draw', self._draw) self.canvas.invalidate() self.set_content(self.canvas)
def __init__(self, text_buffer): super(TextField, self).__init__() self.set_scroll_mode(Clutter.ScrollMode.VERTICALLY) self.text_buffer = text_buffer self.layout = Clutter.BinLayout() self.set_layout_manager(self.layout) white_color = Clutter.Color.new(255, 255, 255, 255) self.set_background_color(white_color) self.font = 'Sans 100px' self._init_field()
def __init__(self): super(MapShadowRectangle, self).__init__() self.timeline = FadeAnimationTimeline(self, end=200) color = Clutter.Color() color.from_string("black") self.set_color(color) super(MapShadowRectangle, self).show() self.set_opacity(100)
def __init__(self, container): super().__init__() self.container = container layout = Clutter.BinLayout() self.set_layout_manager(layout) self.set_y_expand(True) self.set_x_expand(True) self.set_reactive(True) self.connect('button_release_event', lambda x, y: self.exit_panel()) self._init_elements()
def get_texture(img): pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(img, 800, 600, True) t = Clutter.Texture() t.set_from_rgb_data(pixbuf.get_pixels(), pixbuf.get_has_alpha(), pixbuf.get_width(), pixbuf.get_height(), pixbuf.get_rowstride(), 4 if pixbuf.get_has_alpha() else 3, Clutter.TextureFlags.NONE) return t
def listbox_select(lb, offset, offsetType=SelectOffsetType.START, animOrientation=None, colorizeEffect=None, scrollToView=True): cnt = lb.get_n_children() aID = lb.get_id() curIndex = gActors[aID]['curIndex'] if offsetType == SelectOffsetType.CUR: nxtIndex = (curIndex + offset) % cnt elif offsetType == SelectOffsetType.START: nxtIndex = offset % cnt #while nxtIndex < 0: # nxtIndex = cnt + nxtIndex curActor = lb.get_child_at_index(curIndex) nxtActor = lb.get_child_at_index(nxtIndex) curActor.save_easing_state() nxtActor.save_easing_state() lb.save_easing_state() lb.set_easing_duration(500) if scrollToView: nxtActorPos = nxtActor.get_position() point = Clutter.Point() point.x = nxtActorPos[0] point.y = nxtActorPos[1] lb.scroll_to_point(point) if colorizeEffect != None: curActor.remove_effect(colorizeEffect) curActor.set_scale(1, 1) if (animOrientation == None): listOrientation = lb.get_layout_manager().get_orientation() if listOrientation == Clutter.Orientation.HORIZONTAL: animOrientation = AnimOrientation.VERTICAL elif listOrientation == Clutter.Orientation.VERTICAL: animOrientation = AnimOrientation.HORIZONTAL else: print("WARN:animate_listbox:Unknown listbox Orientation") animOrientation = AnimOrientation.BOTH if (animOrientation == AnimOrientation.HORIZONTAL): xScale = 1 + LB_SELSCALE_PERCENT yScale = 1 elif (animOrientation == AnimOrientation.VERTICAL): xScale = 1 yScale = 1 + LB_SELSCALE_PERCENT else: xScale = 1 + LB_SELSCALE_PERCENT yScale = 1 + LB_SELSCALE_PERCENT nxtActor.set_scale(xScale, yScale) if colorizeEffect != None: nxtActor.add_effect(colorizeEffect) curActor.restore_easing_state() nxtActor.restore_easing_state() lb.restore_easing_state() gActors[aID]['curIndex'] = nxtIndex
def load_popup(self, message, unwind=None, unwind_data=None, container=None, timeout=5000, icon=True): """ Load a pop-up view with some message displayed and then, after a given amount of time automatically load some another view or perform some operation. :param message: message to be displayed on the screen. :param unwind: name of a view that should be loaded after the `timeout` expires or callable that should be called then or None. :param unwind_data: data to be passed to an unwind handler or None. :param container: container that popup should be added to or None, if None then it will be displayed as a standard standalone view. :param timeout: time after which the `unwind` will be executed automatically, in miliseconds, default is 1 second, if -1 then the `unwind` to will not be executed at all. :param icon: boolean, if icon should be displayed. :return: None. """ if timeout >= 0 and unwind is not None: if callable(unwind): handler = (lambda *_: unwind(unwind_data)) if \ unwind_data is not None else lambda *_: unwind() else: if unwind.split('/')[ 0] == 'main_panel' and self.app_name != 'main_panel': handler = lambda *_: self.application.main_quit() else: handler = lambda *_: self.load_view(unwind, unwind_data) Clutter.threads_add_timeout(0, timeout, handler) if container: self._display_popup_widget(container, message) else: self.load_view("popup", {"message": message, 'icon': icon})
def enable_sliders(self): for box in ["network", "wifi", "slicer", "printer"]: header = self.config.ui.get_object(box + "-header") header.set_reactive(True) tap = Clutter.TapAction() header.add_action(tap) tap.connect("tap", self.tap) body = self.config.ui.get_object(box + "-body") body.set_height(5) header.is_open = False header.body = body
def create_label(color, markup): text = Clutter.Text() text.set_color(Clutter.Color.from_string(color)) text.set_markup(markup) text.set_editable(False) text.set_selectable(False) text.set_single_line_mode(True) text.set_ellipsize(Pango.EllipsizeMode.END) return text
def __init__(self, **kw): kw.setdefault("layout-manager", Clutter.BinLayout()) super(PhotosImageWidget, self).__init__(**kw) self._ratio = 1.0 self._base_image = Clutter.Texture() self.add_child(self._base_image) self._border_image = Clutter.Texture() self.add_child(self._border_image) self._crop_overlay = CropOverlay() self.add_child(self._crop_overlay) self._crop_overlay.hide_crop_overlay() self.crop_overlay_visible = False bind_overlay_size = Clutter.BindConstraint( coordinate=Clutter.BindCoordinate.SIZE, source=self._base_image) self._crop_overlay.add_constraint(bind_overlay_size) self.connect('allocation-changed', self.alloc_changed)
def __init__(self, *args): super(DraggableBorder, self).__init__(*args) self.line = Clutter.Actor() self.add_child(self.line) self.add_child(self.hitbox) self.thickness = BORDER_THICKNESS self.NORMAL_COLOR = Clutter.Color.from_string("#000000")[1] self.HIGHLIGHT_COLOR = Clutter.Color.from_string("#FFFFFF")[1] self.darken()
def handle_key_press(actor, event): global lPos, lYRotate #print("INFO:KeyPress:{}:{}:{}".format(actor, event.keyval, chr(event.keyval)), event.flags, event.type, event.modifier_state) #CMDKEY_MODSTATE = (Clutter.ModifierType.SHIFT_MASK | Clutter.ModifierType.CONTROL_MASK) CMDKEY_MODSTATE = (Clutter.ModifierType.CONTROL_MASK) if ((event.modifier_state & CMDKEY_MODSTATE) == CMDKEY_MODSTATE): if (event.keyval == Clutter.KEY_A): cg.listbox_select(gGUI['LBCAT'], 1, cg.SelectOffsetType.CUR) cg.listbox_select(gGUI['LBG1'], 1, cg.SelectOffsetType.CUR, colorizeEffect=colorizeEffect1) elif (event.keyval == Clutter.KEY_X): load_screen('main') elif (event.keyval == Clutter.KEY_Y): load_screen('audio') elif (event.keyval == Clutter.KEY_Q): print("INFO: Bowing down gracefully") Clutter.main_quit() return Clutter.EVENT_STOP
def _connectToEvents(self): self.dragAction = Clutter.DragAction() self.add_action(self.dragAction) self.dragAction.connect("drag-progress", self._dragProgressCb) self.dragAction.connect("drag-begin", self._dragBeginCb) self.dragAction.connect("drag-end", self._dragEndCb) self.bElement.selected.connect("selected-changed", self._selectedChangedCb) # We gotta go low-level cause Clutter.ClickAction["clicked"] # gets emitted after Clutter.DragAction["drag-begin"] self.connect("button-press-event", self._clickedCb)
def make_button(text): black = Clutter.Color.new(0x00, 0x00, 0x00, 0xff) white = Clutter.Color.new(0xff, 0xff, 0xff, 0xff) button = Clutter.Actor() button_bg = Clutter.Actor() button_bg.set_background_color(white) button_bg.set_opacity(0xcc) button.add_child(button_bg) button_text = Clutter.Text.new_full("Sans 10", text, black) button.add_child(button_text) (width, height) = button_text.get_size() button_bg.set_size(width + PADDING * 2, height + PADDING * 2) button_bg.set_position(0, 0) button_text.set_position(PADDING, PADDING) return button
def do_allocate(self, actor, box, flags): for i, row in enumerate(actor.get_children()): row_box = Clutter.ActorBox() row_height = box.get_height() / VISIBLE_ROWS row_box.x1 = box.x1 row_box.x2 = box.x2 row_box.y1 = row_height * i row_box.y2 = (row_height * i) + row_height row.allocate(row_box, flags)
def __init__(self, container): super(ResultInfoPanel, self).__init__() self.container = container self.word = container.word self.user_word = container.user_word self.result = container.result layout = Clutter.BinLayout() self.set_layout_manager(layout) self.set_y_expand(True) self.set_x_expand(True) self._init_result_info()