def __init__(self, **kwargs): from kivy.base import EventLoop EventLoop.ensure_window() self._invalid_scale = True self._tiles = [] self._tiles_bg = [] self._tilemap = {} self._layers = [] self._default_marker_layer = None self._need_redraw_all = False self._transform_lock = False self.trigger_update(True) self.canvas = Canvas() self._scatter = MapViewScatter() self.add_widget(self._scatter) with self._scatter.canvas: self.canvas_map = Canvas() self.canvas_layers = Canvas() with self.canvas: self.canvas_layers_out = Canvas() self._scale_target_anim = False self._scale_target = 1. self._touch_count = 0 self.map_source.cache_dir = self.cache_dir Clock.schedule_interval(self._animate_color, 1 / 60.) self.lat = kwargs.get("lat", self.lat) self.lon = kwargs.get("lon", self.lon) super(MapView, self).__init__(**kwargs)
def __init__(self, **kwargs): # XXX move to style.kv if 'size_hint' not in kwargs: if 'size_hint_x' not in kwargs: self.size_hint_x = None if 'size_hint_y' not in kwargs: self.size_hint_y = None if 'size' not in kwargs: if 'width' not in kwargs: self.width = 700 if 'height' not in kwargs: self.height = 200 if 'scale_min' not in kwargs: self.scale_min = .4 if 'scale_max' not in kwargs: self.scale_max = 1.6 if 'docked' not in kwargs: self.docked = False layout_mode = self._trigger_update_layout_mode = Clock.create_trigger( self._update_layout_mode) layouts = self._trigger_load_layouts = Clock.create_trigger( self._load_layouts) layout = self._trigger_load_layout = Clock.create_trigger( self._load_layout) fbind = self.fbind fbind('docked', self.setup_mode) fbind('have_shift', layout_mode) fbind('have_capslock', layout_mode) fbind('have_special', layout_mode) fbind('layout_path', layouts) fbind('layout', layout) super(VKeyboard, self).__init__(**kwargs) # load all the layouts found in the layout_path directory self._load_layouts() # ensure we have default layouts available_layouts = self.available_layouts if not available_layouts: Logger.critical('VKeyboard: unable to load default layouts') # load the default layout from configuration if self.layout is None: self.layout = Config.get('kivy', 'keyboard_layout') else: # ensure the current layout is found on the available layout self._trigger_load_layout() # update layout mode (shift or normal) self._trigger_update_layout_mode() # create a top layer to draw active keys on with self.canvas: self.background_key_layer = Canvas() self.active_keys_layer = Canvas()
def __init__(self, **kwargs): self._touch = None self._trigger_update_from_scroll = Clock.create_trigger( self.update_from_scroll, -1) # create a specific canvas for the viewport from kivy.graphics import PushMatrix, Translate, PopMatrix, Canvas self.canvas_viewport = Canvas() self.canvas = Canvas() with self.canvas_viewport.before: PushMatrix() self.g_translate = Translate(0, 0) with self.canvas_viewport.after: PopMatrix() super(ScrollView, self).__init__(**kwargs) self.register_event_type('on_scroll_start') self.register_event_type('on_scroll_move') self.register_event_type('on_scroll_stop') # now add the viewport canvas to our canvas self.canvas.add(self.canvas_viewport) effect_cls = self.effect_cls if isinstance(effect_cls, string_types): effect_cls = Factory.get(effect_cls) if self.effect_x is None and effect_cls is not None: self.effect_x = effect_cls(target_widget=self._viewport) if self.effect_y is None and effect_cls is not None: self.effect_y = effect_cls(target_widget=self._viewport) trigger_update_from_scroll = self._trigger_update_from_scroll update_effect_widget = self._update_effect_widget update_effect_x_bounds = self._update_effect_x_bounds update_effect_y_bounds = self._update_effect_y_bounds fbind = self.fbind fbind('width', update_effect_x_bounds) fbind('height', update_effect_y_bounds) fbind('viewport_size', self._update_effect_bounds) fbind('_viewport', update_effect_widget) fbind('scroll_x', trigger_update_from_scroll) fbind('scroll_y', trigger_update_from_scroll) fbind('pos', trigger_update_from_scroll) fbind('size', trigger_update_from_scroll) fbind('scroll_y', self._update_effect_bounds) fbind('scroll_x', self._update_effect_bounds) trigger_update_from_scroll() update_effect_widget() update_effect_x_bounds() update_effect_y_bounds()
def __init__(self, **kwargs): super(GeoJsonMapLayer, self).__init__(**kwargs) with self.canvas: self.canvas_polygon = Canvas() self.canvas_line = Canvas() with self.canvas_polygon.before: PushMatrix() self.g_matrix = MatrixInstruction() self.g_scale = Scale() self.g_translate = Translate() with self.canvas_polygon: self.g_canvas_polygon = Canvas() with self.canvas_polygon.after: PopMatrix()
def create_window(self): '''Will create the main window and configure it. .. warning:: This method is called automatically at runtime. If you call it, it will recreate a RenderContext and Canvas. This mean you'll have a new graphics tree, and the old one will be unusable. This method exist to permit the creation of a new OpenGL context AFTER closing the first one. (Like using runTouchApp() and stopTouchApp()). This method have been only tested in unittest environment, and will be not suitable for Applications. Again, don't use this method unless you know exactly what you are doing ! ''' from kivy.core.gl import init_gl init_gl() # create the render context and canvas from kivy.graphics import RenderContext, Canvas self.render_context = RenderContext() self.canvas = Canvas() self.render_context.add(self.canvas)
def __init__(self, **kwargs): self.first_time = True self.initial_zoom = None super().__init__(**kwargs) with self.canvas: self.canvas_polygon = Canvas() self.canvas_line = Canvas() with self.canvas_polygon.before: PushMatrix() self.g_matrix = MatrixInstruction() self.g_scale = Scale() self.g_translate = Translate() with self.canvas_polygon: self.g_canvas_polygon = Canvas() with self.canvas_polygon.after: PopMatrix()
def __init__(self, **kwargs): super(Widget, self).__init__() # Register touch events self.register_event_type('on_touch_down') self.register_event_type('on_touch_move') self.register_event_type('on_touch_up') # Before doing anything, ensure the windows exist. EventLoop.ensure_window() # Auto bind on own handler if exist properties = self.__properties.keys() for func in dir(self): if not func.startswith('on_'): continue name = func[3:] if name in properties: self.bind(**{name: getattr(self, func)}) # Create the default canvas if not exist if self.canvas is None: self.canvas = Canvas() # Apply the existing arguments to our widget for key, value in kwargs.iteritems(): if hasattr(self, key): setattr(self, key, value) # Apply all the styles if '__no_builder' not in kwargs: Builder.apply(self)
def show_lines(self): indices = [] grid = self.grid cols = grid.cols rows = grid.rows for col in range(grid.cols + 1): indices.extend(( col * (rows + 1), col * (rows + 1) + rows, )) for row in range(grid.rows + 1): indices.extend(( row, row + (cols * (rows + 1)), )) with self.canvas: self.g_canvas = Canvas() with self.g_canvas: Color(1, 0, 0, 0.5) PushMatrix() Scale(self.width, self.height, 1.) self.g_mesh = Mesh(vertices=self.grid.line_vertices, indices=self.grid.line_indices, mode="lines", source="projectionmapping/data/white.png") PopMatrix() self.rebuild_informations()
def __init__(self, **kwargs): self.canvas = Canvas() with self.canvas.before: Callback(self._set_blend_func) #self.size self.fbo_texture = Texture.create(size=self.size, colorfmt='rgba') self.fbo_texture.mag_filter = 'linear' self.fbo_texture.min_filter = 'linear' with self.canvas: #self.cbs = Callback(self.prepare_canvas) self.fbo = Fbo(size=self.size, texture=self.fbo_texture) #Color(1, 1, 1, 0) #self.fbo_rect = Rectangle() with self.fbo: ClearColor(0.0, 0.0, 0.0, 0.0) ClearBuffers() self.fbo_rect = Rectangle(size=self.size) #self.fbo.shader.source = resource_find('./kivy3dgui/gles2.0/shaders/invert.glsl') #with self.fbo.after: # self.cbr = Callback(self.reset_gl_context) # PopMatrix() with self.canvas.before: Callback(self._set_blend_func) # wait that all the instructions are in the canvas to set texture self.texture = self.fbo.texture super(FboFloatLayout, self).__init__(**kwargs)
def build(self): radius = self.radius if not self.canvas_points: self.canvas_points = Canvas() self.canvas.add(self.canvas_points) with self.canvas_points: Color(1, 0, 0) for marker in points: Rectangle(pos=(marker.x * 600, marker.y * 600), size=(2, 2)) self.canvas.before.clear() with self.canvas.before: if self.selection_center: Color(0, 1, 0, 0.5) x, y = self.selection_center r = radius * 600 r2 = r * 2 Ellipse(pos=(x - r, y - r), size=(r2, r2)) if self.selection: Color(0, 0, 1) for m_id in self.selection: # x = kdbush.coords[m_id * 2] # y = kdbush.coords[m_id * 2 + 1] marker = points[m_id] x = marker.x y = marker.y Rectangle(pos=(x * 600 - 4, y * 600 - 4), size=(8, 8))
def __init__(self, **kwargs): # Before doing anything, ensure the windows exist. EventLoop.ensure_window() # assign the default context of the widget creation if not hasattr(self, '_context'): self._context = get_current_context() super(Widget, self).__init__(**kwargs) # Create the default canvas if not exist if self.canvas is None: self.canvas = Canvas(opacity=self.opacity) # Apply all the styles if '__no_builder' not in kwargs: #current_root = Builder.idmap.get('root') #Builder.idmap['root'] = self Builder.apply(self) #if current_root is not None: # Builder.idmap['root'] = current_root #else: # Builder.idmap.pop('root') # Bind all the events for argument in kwargs: if argument[:3] == 'on_': self.bind(**{argument: kwargs[argument]})
def __init__(self, overlay, **kwargs): super().__init__(**kwargs) # creating an interface self.controller = overlay self.size_hint = (.8, .8) self.orientation = 'vertical' # starting the gameloop self.event = Clock.schedule_interval(self.mainloop, 0) # create main canvas self.GAME = Widget() self.GAME.canvas = Canvas() self.add_widget(self.GAME) # game classes self.player = Player() self.sprites = Sprites() self.drawing = Drawing(self.GAME.canvas, None) # draw borders with self.canvas.after: Color(.05, .05, .05) Rectangle(pos=(0, 0), size=(NULLX, REAL_SCREEN_Y)) Color(.01, .01, .01) Rectangle(pos=(NULLX, REAL_SCREEN_Y - NULLY), size=(REAL_SCREEN_X - NULLX, NULLY)) Color(.01, .01, .01) Rectangle(pos=(NULLX, 0), size=(REAL_SCREEN_X - NULLX, NULLY)) Color(.05, .05, .05) Rectangle(pos=(REAL_SCREEN_X - NULLX, 0), size=(REAL_SCREEN_X, REAL_SCREEN_Y))
def start(self, manager): '''(internal) Starts the transition. This is automatically called by the :class:`ScreenManager`. ''' self.manager = manager if hasattr(manager, 'c'): manager.canvas.remove(manager.c) manager.c = Canvas() with manager.c: opacity = 0 Color(0, 0, 0, 0.6) Rectangle(size=manager.size, pos=manager.pos) super(CardTransition, self).start(manager) mode = self.mode a = self.screen_in b = self.screen_out # ensure that the correct widget is "on top" if mode == 'push': manager.canvas.add(manager.c) manager.canvas.remove(a.canvas) manager.canvas.add(a.canvas) elif mode == 'pop': manager.canvas.add(manager.c) manager.canvas.remove(b.canvas) manager.canvas.add(b.canvas)
def __init__(self, **kwargs): # Before doing anything, ensure the windows exist. EventLoop.ensure_window() # Assign the default context of the widget creation. if not hasattr(self, '_context'): self._context = get_current_context() no_builder = '__no_builder' in kwargs if no_builder: del kwargs['__no_builder'] on_args = {k: v for k, v in kwargs.items() if k[:3] == 'on_'} for key in on_args: del kwargs[key] super(Widget, self).__init__(**kwargs) # Create the default canvas if it does not exist. if self.canvas is None: self.canvas = Canvas(opacity=self.opacity) # Apply all the styles. if not no_builder: Builder.apply(self, ignored_consts=self._kwargs_applied_init) # Bind all the events. if on_args: self.bind(**on_args)
def __init__(self, **kwargs): # Before doing anything, ensure the windows exist. EventLoop.ensure_window() # Register touch events self.register_event_type('on_touch_down') self.register_event_type('on_touch_move') self.register_event_type('on_touch_up') super(Widget, self).__init__(**kwargs) # Create the default canvas if not exist if self.canvas is None: self.canvas = Canvas(opacity=self.opacity) # Apply all the styles if '__no_builder' not in kwargs: #current_root = Builder.idmap.get('root') #Builder.idmap['root'] = self Builder.apply(self) #if current_root is not None: # Builder.idmap['root'] = current_root #else: # Builder.idmap.pop('root') # Bind all the events for argument in kwargs: if argument[:3] == 'on_': self.bind(**{argument: kwargs[argument]})
def __init__(self, **kwargs): # XXX move to style.kv kwargs.setdefault('size_hint', (None, None)) kwargs.setdefault('scale_min', .4) kwargs.setdefault('scale_max', 1.6) kwargs.setdefault('size', (700, 200)) kwargs.setdefault('docked', False) self._trigger_update_layout_mode = Clock.create_trigger( self._update_layout_mode) self._trigger_load_layouts = Clock.create_trigger( self._load_layouts) self._trigger_load_layout = Clock.create_trigger( self._load_layout) self.bind( docked=self.setup_mode, have_shift=self._trigger_update_layout_mode, have_capslock=self._trigger_update_layout_mode, layout_path=self._trigger_load_layouts, layout=self._trigger_load_layout) super(VKeyboard, self).__init__(**kwargs) # load all the layouts found in the layout_path directory self._load_layouts() # ensure we have default layouts available_layouts = self.available_layouts if not available_layouts: Logger.critical('VKeyboard: unable to load default layouts') # load the default layout from configuration if self.layout is None: self.layout = Config.get('kivy', 'keyboard_layout') else: # ensure the current layout is found on the available layout self._trigger_load_layout() # update layout mode (shift or normal) self._trigger_update_layout_mode() # create a top layer to draw active keys on with self.canvas: self.background_key_layer = Canvas() self.active_keys_layer = Canvas() # prepare layout widget self.refresh_keys_hint() self.refresh_keys()
def __init__(self, **kwargs): super(RippleBehavior, self).__init__(**kwargs) self.ripple_pane_bg = Canvas() self.canvas.add(self.ripple_pane_bg) self.bind(ripple_bg_color=self._ripple_set_bg_color, ) self.ripple_rectangle = None self.ripple_bg_color_instruction = None self.ripple_pane = Canvas() self.canvas.add(self.ripple_pane) self.bind(ripple_color=self._ripple_set_color, ripple_pos=self._ripple_set_ellipse, ripple_rad=self._ripple_set_ellipse) self.ripple_ellipse = None self.ripple_col_instruction = None self.execution_index = 1
def __init__(self, **kwargs): if platform == "ios": user_data_dir = App.get_running_app().user_data_dir self.cache_dir = join(user_data_dir, "cache_dir") self.first_time = True self.initial_zoom = None super(GeoJsonMapLayer, self).__init__(**kwargs) with self.canvas: self.canvas_polygon = Canvas() with self.canvas_polygon.before: PushMatrix() self.g_matrix = MatrixInstruction() self.g_scale = Scale() self.g_translate = Translate() with self.canvas_polygon: self.g_canvas_polygon = Canvas() with self.canvas_polygon.after: PopMatrix()
def __init__(self, label, setting, color, **kwargs): super(Setting, self).__init__(**kwargs) Clock.schedule_once(self._finish_init) self._setting = setting self.label = label self.canvas = Canvas() with self.canvas.before: Color(rgba=color) self.rect = Rectangle(size=self.size, pos=self.pos) self.bind(pos=self.update_bg, size=self.update_bg)
def __init__(self, **kwargs): self.canvas = Canvas() with self.canvas: self.fbo = Fbo(size=self.size) Color(1, 1, 1) self.fbo_rect = Rectangle() # wait that all the instructions are in the canvas to set texture self.texture = self.fbo.texture super(FboFloatLayout, self).__init__(**kwargs)
def create_window(self, *largs): '''Will create the main window and configure it. .. warning:: This method is called automatically at runtime. If you call it, it will recreate a RenderContext and Canvas. This means you'll have a new graphics tree, and the old one will be unusable. This method exist to permit the creation of a new OpenGL context AFTER closing the first one. (Like using runTouchApp() and stopTouchApp()). This method has only been tested in a unittest environment and is not suitable for Applications. Again, don't use this method unless you know exactly what you are doing! ''' # just to be sure, if the trigger is set, and if this method is # manually called, unset the trigger Clock.unschedule(self.create_window) # ensure the window creation will not be called twice if platform in ('android', 'ios'): self._unbind_create_window() if not self.initialized: from kivy.core.gl import init_gl init_gl() # create the render context and canvas, only the first time. from kivy.graphics import RenderContext, Canvas self.render_context = RenderContext() self.canvas = Canvas() self.render_context.add(self.canvas) else: # if we get initialized more than once, then reload opengl state # after the second time. # XXX check how it's working on embed platform. if platform == 'linux' or Window.__class__.__name__ == 'WindowSDL': # on linux, it's safe for just sending a resize. self.dispatch('on_resize', *self.system_size) else: # on other platform, window are recreated, we need to reload. from kivy.graphics.context import get_context get_context().reload() Clock.schedule_once(lambda x: self.canvas.ask_update(), 0) self.dispatch('on_resize', *self.system_size) # ensure the gl viewport is correct self.update_viewport()
def __init__(self, **kwargs): self.canvas = Canvas() with self.canvas: self.fbo = Fbo(size=self.size, with_depthbuffer=True, compute_normal_mat=True, clear_color=(0., 0., 0., 0.)) self.viewport = Rectangle(size=self.size, pos=self.pos) self.fbo.shader.source = resource_find( join(dirname(__file__), 'simple.glsl')) super(ObjectRenderer, self).__init__(**kwargs)
def __init__(self, **kwargs): self._touch = None self._trigger_update_from_scroll = Clock.create_trigger( self.update_from_scroll, -1) # create a specific canvas for the viewport from kivy.graphics import PushMatrix, Translate, PopMatrix, Canvas self.canvas_viewport = Canvas() self.canvas = Canvas() with self.canvas_viewport.before: PushMatrix() self.g_translate = Translate(0, 0) with self.canvas_viewport.after: PopMatrix() super(ScrollView, self).__init__(**kwargs) # now add the viewport canvas to our canvas self.canvas.add(self.canvas_viewport) effect_cls = self.effect_cls if isinstance(effect_cls, string_types): effect_cls = Factory.get(effect_cls) if self.effect_x is None and effect_cls is not None: self.effect_x = effect_cls(target_widget=self._viewport) if self.effect_y is None and effect_cls is not None: self.effect_y = effect_cls(target_widget=self._viewport) self.bind(width=self._update_effect_x_bounds, height=self._update_effect_y_bounds, viewport_size=self._update_effect_bounds, _viewport=self._update_effect_widget, scroll_x=self._trigger_update_from_scroll, scroll_y=self._trigger_update_from_scroll, pos=self._trigger_update_from_scroll, size=self._trigger_update_from_scroll) self._update_effect_widget() self._update_effect_x_bounds() self._update_effect_y_bounds()
def __init__(self, **kwargs): """ Set up inheritance of parent with the kwargs as well as add variables needed by all instances. :param kwargs: all available kwargs can be found at https://kivy.org/docs/api-kivy.uix.floatlayout.html """ super().__init__(**kwargs) self.root = root = self self.root.canvas = Canvas() root.bind(angle=self.on_angle) self.rotate_animation = Animation(angle=0.5, duration=1) self.rotate_animation.start(self)
def __init__(self, **kw): self.shader_file = kw.pop("shader_file", None) self.canvas = Canvas() super(Renderer, self).__init__(**kw) with self.canvas: self._viewport = Rectangle(size=self.size, pos=self.pos) self.fbo = Fbo(size=self.size, with_depthbuffer=True, compute_normal_mat=True, clear_color=(0., 0., 0., 0.)) self._config_fbo() self.texture = self.fbo.texture self.camera = None self.scene = None
def __init__(self, **kwargs): self.mesh_data = MeshData() self.canvas = Canvas() with self.canvas: self.fbo = Fbo(size=(10, 10), compute_normal_mat=True) self.fbo.add_reload_observer(self.populate_fbo) with self.fbo: ClearColor(0, 0, 0, 0) ClearBuffers() self.populate_fbo(self.fbo) super(GLWindow, self).__init__(**kwargs) Clock.schedule_interval(self.update_glsl, 1 / 60.)
def _highlight(results): from kivy.graphics import Color, Rectangle, Canvas from kivy.core.window import Window if not hasattr(Window, "_telenium_canvas"): Window._telenium_canvas = Canvas() _canvas = Window._telenium_canvas Window.canvas.remove(_canvas) Window.canvas.add(_canvas) _canvas.clear() with _canvas: Color(1, 0, 0, 0.5) for widget, bounds in results: left, bottom, right, top = bounds Rectangle(pos=(left, bottom), size=(right - left, top - bottom))
def _highlight(self, results): from kivy.graphics import Color, Rectangle, Canvas from kivy.core.window import Window if not hasattr(self, "_canvas"): self._canvas = Canvas() Window.canvas.remove(self._canvas) Window.canvas.add(self._canvas) self._canvas.clear() with self._canvas: Color(1, 0, 0, 0.5) for widget, bounds in results: left, bottom, right, top = bounds Rectangle(pos=(left, bottom), size=(right - left, top - bottom))
def build(self): #self.load_kv('MyApp.kv') self.title = "Graphic Test Framework" widget = MyWidget() widget.add_widget(Label(text="prueba")) myCanvas = Canvas() myCanvas.add(Rectangle(size=(350, 1), pos=(0, 500))) widget.canvas = myCanvas widget.add_widget(Button(text="Boton", pos=(100, 500))) return widget return MyWidget() return PageLayout() return StackLayout() return BoxLayout() return GridLayout() return FloatLayout() return CustomWidget()
def __init__(self, **kwargs): self.register_event_type('on_touch_hover') self.chooser = None self.popup = None self.skeletons = [] self.states = [] # self.batch = PolygonSpriteBatch() self.renderer = SkeletonRenderer() self.debugRenderer = SkeletonRendererDebug() self.draw_canvas = Canvas() super().__init__(**kwargs) self.canvas.add(self.draw_canvas)