Example #1
1
 def post_event(self, event, *args):
     ev = SDL.SDL_Event()
     ev.type = SDL.SDL_USEREVENT
     ev.user.code = self.known_events[event]
     argcopy = tuple(args)
     argid = self.event_data_counter
     self.event_data_counter += 1
     data1 = ctypes.cast(argid, ctypes.c_void_p)
     self.event_data[argid] = argcopy
     ev.user.data1 = data1
     SDL.SDL_PushEvent(SDL.pointer(ev))
Example #2
1
    def setup(self):
        """
        Setup that takes more time.  Shows a loading screen, and initializes
        SDL to poll joysticks.  Should be called after pyglet's run_app
        function has been started.
        """
        if self.load_joystick:
            print("Loading SDL")
            SDL.start()
            SDL.SDL_Init(SDL.SDL_INIT_JOYSTICK)
            print("Done loading SDL")

        self.camera = Camera(self)
        self.tickers.append(self.camera)

        pyglet.clock.schedule_interval(self.tick, 1.0/60)

        while self.setup_hook:
            self.setup_hook.pop().setup()

        self.init = True
Example #3
1
 def blit_surface(self, surface, x, y, anchor_x='left', anchor_y='bottom'):
     """Blit the entire image to the window with upper left corner at
     the position specified.
     
     """
     w = surface.contents.w
     h = surface.contents.h
     y = self.height - y
     if anchor_y == 'bottom':
         y -= h
     elif anchor_y == 'center':
         y -= h // 2
     if anchor_x == 'center':
         x -= w // 2
     elif anchor_x == 'right':
         x -= w
     destrect = SDL.SDL_Rect(x, y, 0, 0)
     SDL.SDL_UpperBlit(surface, None, self.screen, SDL.pointer(destrect))
Example #4
1
def main_loop():
	ev = SDL.SDL_Event()	
	oldtime = SDL.SDL_GetTicks()
	
	maxfps = 100
	
	global quit
	while not quit:
		while SDL.SDL_PollEvent(SDL.pointer(ev)) == 1:
			handle_event(ev)
			
		newtime = SDL.SDL_GetTicks()
		dt = newtime - oldtime
		oldtime = newtime
		
		waittime = 1000 / maxfps - dt
		if waittime > 0:
			SDL.SDL_Delay(waittime)
Example #5
1
 def clear_rect(self, x, y, w, h):
     destrect = SDL.SDL_Rect(x, self.height - y - h, w, h)
     print "clearing %s" % str((x, self.height - y - h, w, h))
     SDL.SDL_FillRect(self.screen, SDL.pointer(destrect), 0)
Example #6
1
		oldtime = newtime
		
		waittime = 1000 / maxfps - dt
		if waittime > 0:
			SDL.SDL_Delay(waittime)


def app_main():
	print "loaded SDL"
	
	SDL.SDL_Init(SDL.SDL_INIT_EVERYTHING)
	global screen
	screen = SDL.SDL_SetVideoMode(640,480,0,0)
	SDL.SDL_EnableUNICODE(1)
	print "initialized SDL"
	
	if SDL.IMG_Init(SDL.IMG_INIT_JPG | SDL.IMG_INIT_PNG | SDL.IMG_INIT_TIF) == 0:
		print "failed to init SDL_image"
		return
	print "initialized SDL_image"
	
	main_loop()
	
	SDL.SDL_Quit()
	print "quit"


if __name__ == '__main__':
	print "parsing SDL headers and loading SDL ..."
	SDL.start(app_main)
    def init_gui_SDL(self):

        import SDL

        SDL.init(auto_refresh=False)
        self.event_loop = event_loop(refresh_cb=SDL.refresh)

        # Register SDL display driver.

        disp_buf1 = lv.disp_draw_buf_t()
        buf1_1 = bytes(480 * 10)
        disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
        disp_drv = lv.disp_drv_t()
        disp_drv.init()
        disp_drv.draw_buf = disp_buf1
        disp_drv.flush_cb = SDL.monitor_flush
        disp_drv.hor_res = 480
        disp_drv.ver_res = 320
        disp_drv.register()

        # Regsiter SDL mouse driver

        indev_drv = lv.indev_drv_t()
        indev_drv.init()
        indev_drv.type = lv.INDEV_TYPE.POINTER
        indev_drv.read_cb = SDL.mouse_read
        indev_drv.register()
Example #8
0
 def init_gui_SDL(self):
     import SDL
     SDL.init()
     self.init_disp_drv(SDL.monitor_flush, 480, 320)
     self.init_indev_drv(SDL.mouse_read)
     print('Initialized SDL device')
     return True
Example #9
0
    def init_gui_SDL(self):

        import SDL
        SDL.init()

        # Register SDL display driver.

        disp_buf1 = lv.disp_buf_t()
        buf1_1 = bytearray(480 * 10)
        lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
        disp_drv = lv.disp_drv_t()
        lv.disp_drv_init(disp_drv)
        disp_drv.buffer = disp_buf1
        disp_drv.flush_cb = SDL.monitor_flush
        disp_drv.hor_res = 480
        disp_drv.ver_res = 320
        lv.disp_drv_register(disp_drv)

        # Regsiter SDL mouse driver

        indev_drv = lv.indev_drv_t()
        lv.indev_drv_init(indev_drv)
        indev_drv.type = lv.INDEV_TYPE.POINTER
        indev_drv.read_cb = SDL.mouse_read
        lv.indev_drv_register(indev_drv)
Example #10
0
    def display_driver_SDL(self):

        import SDL
        SDL.init(w=self.width, h=self.height)
        # Register SDL display driver.

        disp_buf1 = lv.disp_buf_t()
        buf1_1 = bytearray(self.width * 10)
        disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
        disp_drv = lv.disp_drv_t()
        disp_drv.init()
        disp_drv.buffer = disp_buf1
        disp_drv.flush_cb = SDL.monitor_flush
        disp_drv.hor_res = self.width
        disp_drv.ver_res = self.height
        disp_drv.register()

        # Register SDL mouse driver

        indev_drv = lv.indev_drv_t()
        indev_drv.init()
        indev_drv.type = lv.INDEV_TYPE.POINTER
        indev_drv.read_cb = SDL.mouse_read
        indev_drv.register()
        self.type = "SDL"
        print("Running the SDL lvgl version")
    def init_gui_SDL(self):

        import SDL
        SDL.init(w=self.width, h=self.height, auto_refresh=False)
        self.event_loop = lv_utils.event_loop(refresh_cb=SDL.refresh)

        # Register SDL display driver.

        disp_buf1 = lv.disp_draw_buf_t()
        buf1_1 = bytearray(self.width * 10)
        disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
        disp_drv = lv.disp_drv_t()
        disp_drv.init()
        disp_drv.draw_buf = disp_buf1
        disp_drv.flush_cb = SDL.monitor_flush
        disp_drv.hor_res = self.width
        disp_drv.ver_res = self.height
        disp_drv.register()

        # Register SDL mouse driver

        indev_drv = lv.indev_drv_t()
        indev_drv.init()
        indev_drv.type = lv.INDEV_TYPE.POINTER
        indev_drv.read_cb = SDL.mouse_read
        indev_drv.register()

        self.type = "SDL"
        print("Running the SDL lvgl version")
Example #12
0
def init():
    """
    GUI initialization function. 
    Should be called once in the very beginning.
    """

    # init the gui library
    lv.init()
    # init the hardware library
    SDL.init()

    # Register SDL display driver
    disp_buf1 = lv.disp_buf_t()
    buf1_1 = bytearray(HOR_RES*10)
    lv.disp_buf_init(disp_buf1,buf1_1, None, len(buf1_1)//4)
    disp_drv = lv.disp_drv_t()
    lv.disp_drv_init(disp_drv)
    disp_drv.buffer = disp_buf1
    disp_drv.flush_cb = SDL.monitor_flush
    disp_drv.hor_res = HOR_RES
    disp_drv.ver_res = VER_RES
    lv.disp_drv_register(disp_drv)

    # Regsiter SDL mouse driver
    indev_drv = lv.indev_drv_t()
    lv.indev_drv_init(indev_drv) 
    indev_drv.type = lv.INDEV_TYPE.POINTER;
    indev_drv.read_cb = SDL.mouse_read;
    lv.indev_drv_register(indev_drv);

    # Set up material theme
    # First argument (210) is a hue - theme color shift,
    # Second - default font to use. Builtin: roboto_16, roboto_28
    th = lv.theme_material_init(210, lv.font_roboto_22)
    lv.theme_set_current(th)

    # Create a screen and load it
    # To access active screen use lv.scr_act()
    scr = lv.obj()
    lv.scr_load(scr)

    # Initialize the styles
    styles["title"] = lv.style_t()
    # Title style - just a default style with larger font
    lv.style_copy(styles["title"], lv.style_plain)
    styles["title"].text.font = lv.font_roboto_28
Example #13
0
    def __init__(self, *args):

        if len(args) == 1:
            arg = args[0]
            if isinstance(arg, Rect):
                object.__setattr__(self, '_r', copy.copy(arg._r))
                return
            elif isinstance(arg, SDL.SDL_Rect):
                object.__setattr__(self, '_r', copy.copy(arg))
                return
            elif hasattr(arg, 'rect'):
                arg = arg.rect
                if callable(arg):
                    arg = arg()
                self.__init__(arg)
                return
            elif hasattr(arg, '__len__'):
                args = arg
            else:
                raise TypeError('Argument must be rect style object')
        if len(args) == 4:
            if args[2] < 0 or args[3] < 0:
                object.__setattr__(
                    self, '_r',
                    _RectProxy((int(args[0]), int(args[1]), int(args[2]),
                                int(args[3]))))
            else:
                object.__setattr__(
                    self, '_r',
                    SDL.SDL_Rect(int(args[0]), int(args[1]), int(args[2]),
                                 int(args[3])))
        elif len(args) == 2:
            if args[1][0] < 0 or args[1][1] < 0:
                object.__setattr__(
                    self, '_r',
                    _RectProxy((int(args[0][0]), int(args[0][1]),
                                int(args[1][0]), int(args[1][1]))))
            else:
                object.__setattr__(
                    self, '_r',
                    SDL.SDL_Rect(int(args[0][0]), int(args[0][1]),
                                 int(args[1][0]), int(args[1][1])))
        else:
            raise TypeError('Argument must be rect style object')
Example #14
0
 def normalize(self):
     if self._r.w < 0:
         self._r.x += self._r.w
         self._r.w = -self._r.w
     if self._r.h < 0:
         self._r.y += self._r.h
         self._r.h = -self._r.h
     if isinstance(self._r, _RectProxy):
         object.__setattr__(
             self, '_r',
             SDL.SDL_Rect(self._r.x, self._r.y, self._r.w, self._r.h))
Example #15
0
    def init_gui_SDL(self):

        import SDL
        SDL.init()

        # Register SDL display driver.

        disp_drv = lv.disp_drv_t()
        lv.disp_drv_init(disp_drv)
        disp_drv.disp_flush = SDL.monitor_flush
        disp_drv.disp_fill = SDL.monitor_fill
        disp_drv.disp_map = SDL.monitor_map
        lv.disp_drv_register(disp_drv)

        # Regsiter SDL mouse driver

        indev_drv = lv.indev_drv_t()
        lv.indev_drv_init(indev_drv) 
        indev_drv.type = lv.INDEV_TYPE.POINTER;
        indev_drv.read = SDL.mouse_read;
        lv.indev_drv_register(indev_drv);
Example #16
0
def init(autoupdate=True):
    import lvgl as lv
    import SDL

    HOR_RES = 480
    VER_RES = 800
    """
    GUI initialization function. 
    Should be called once in the very beginning.
    """

    # init the gui library
    lv.init()
    # init the hardware library
    SDL.init()

    # Register SDL display driver
    disp_buf1 = lv.disp_buf_t()
    buf1_1 = bytearray(HOR_RES * 10)
    lv.disp_buf_init(disp_buf1, buf1_1, None, len(buf1_1) // 4)
    disp_drv = lv.disp_drv_t()
    lv.disp_drv_init(disp_drv)
    disp_drv.buffer = disp_buf1
    disp_drv.flush_cb = SDL.monitor_flush
    disp_drv.hor_res = HOR_RES
    disp_drv.ver_res = VER_RES
    lv.disp_drv_register(disp_drv)

    # Regsiter SDL mouse driver
    indev_drv = lv.indev_drv_t()
    lv.indev_drv_init(indev_drv)
    indev_drv.type = lv.INDEV_TYPE.POINTER
    indev_drv.read_cb = SDL.mouse_read
    lv.indev_drv_register(indev_drv)

    scr = lv.obj()
    lv.scr_load(scr)
    if autoupdate:
        import SDL
        SDL.enable_autoupdate()
Example #17
0
    def init_gui_SDL(self):
        import SDL

        SDL.init()

        # Register SDL display driver.
        disp_buf1 = lv.disp_buf_t()
        buf1_1 = bytes(480 * 10)
        disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
        disp_drv = lv.disp_drv_t()
        disp_drv.init()
        disp_drv.buffer = disp_buf1
        disp_drv.flush_cb = SDL.monitor_flush
        disp_drv.hor_res = 240
        disp_drv.ver_res = 320
        disp_drv.register()

        # Register SDL mouse driver
        indev_drv = lv.indev_drv_t()
        indev_drv.init()
        indev_drv.type = lv.INDEV_TYPE.POINTER
        indev_drv.read_cb = SDL.mouse_read
        indev_drv.register()
Example #18
0
            # Initialize ILI9341 display
            disp = ili9431()

            # Register xpt2046 touch driver
            touch = xpt2046()
        except:
            print(
                "Not running a supported lvgl enabled version of Micropython. Giving up..."
            )
            sys.exit()

except:
    try:
        import SDL
        SDL.init(w=240, h=240)

        # Register SDL display driver.

        disp_buf1 = lv.disp_buf_t()
        buf1_1 = bytes(240 * 10)
        disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
        disp_drv = lv.disp_drv_t()
        disp_drv.init()
        disp_drv.buffer = disp_buf1
        disp_drv.flush_cb = SDL.monitor_flush
        disp_drv.hor_res = 240
        disp_drv.ver_res = 240
        disp_drv.register()

        # Register SDL mouse driver
Example #19
0
#!/opt/bin/lv_micropython
import lvgl as lv
import time
import SDL
lv.init()

LV_DEMO_WIDGETS_SLIDESHOW = 0
LV_THEME_DEFAULT_COLOR_PRIMARY = lv.color_hex(0x01a2b1)
LV_THEME_DEFAULT_COLOR_SECONDARY = lv.color_hex(0x44d1b6)

LV_LED_BRIGHT_MIN = 120
LV_LED_BRIGHT_MAX = 255

SDL.init(w=480, h=320)

LV_DPI = 130
LV_ANIM_REPEAT_INFINITE = -1

# Register SDL display driver.

disp_buf1 = lv.disp_buf_t()
buf1_1 = bytes(480 * 10)
disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
disp_drv = lv.disp_drv_t()
disp_drv.init()
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = SDL.monitor_flush
disp_drv.hor_res = 480
disp_drv.ver_res = 320
disp_drv.register()
Example #20
0
 def clip(self, x, y, w, h):
     destrect = SDL.SDL_Rect(x, self.height - y - h, w, h)
     SDL.SDL_SetClipRect(self.screen, SDL.pointer(destrect))
Example #21
0
 def _get_as_parameter_(self):
     return SDL.SDL_Rect(self.x, self.y, self.w, self.h)
                   power=-1,
                   backlight=-1,
                   asynchronous=True,
                   initialize=True)
    touch = xpt2046()

except ImportError:
    pass

# Try to initialize SDL
try:
    import SDL

    # Initialize driver

    SDL.init(w=HOR_RES, h=VER_RES, auto_refresh=False)
    event_loop = lv_utils.event_loop(refresh_cb=SDL.refresh, asynchronous=True)

    # Register SDL display driver.

    disp_buf1 = lv.disp_draw_buf_t()
    buf1_1 = bytearray(HOR_RES * 10)
    disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
    disp_drv = lv.disp_drv_t()
    disp_drv.init()
    disp_drv.draw_buf = disp_buf1
    disp_drv.flush_cb = SDL.monitor_flush
    disp_drv.hor_res = HOR_RES
    disp_drv.ver_res = VER_RES
    disp_drv.register()
Example #23
0
import usys as sys
sys.path.append(
    '')  # See: https://github.com/micropython/micropython/issues/6419

import ustruct as struct

import lodepng as png
import lvgl as lv
from lv_utils import event_loop

lv.init()
lv.log_register_print_cb(lambda msg: print('%s' % msg))

if not event_loop.is_running():
    import SDL
    SDL.init()

    # Register SDL display driver.

    disp_buf1 = lv.disp_draw_buf_t()
    buf1_1 = bytes(480 * 10)
    disp_buf1.init(buf1_1, None, len(buf1_1) // 4)
    disp_drv = lv.disp_drv_t()
    disp_drv.init()
    disp_drv.draw_buf = disp_buf1
    disp_drv.flush_cb = SDL.monitor_flush
    disp_drv.hor_res = 480
    disp_drv.ver_res = 320
    disp_drv.register()

    # Regsiter SDL mouse driver
Example #24
0
#!/usr/bin/python
# updated nov 2011
import os, sys, time
import SDL as sdl

sdl.Init(sdl.SDL_INIT_JOYSTICK)

n = sdl.NumJoysticks()
assert n

joy = sdl.JoystickOpen(0)
print(joy, dir(joy))

print('running loop')
for i in range(2800):
    time.sleep(0.01)
    sdl.JoystickUpdate()
    for j in range(joy.NumAxes()):
        print('axis', j, joy.GetAxis(j) / 32767.0)  # -32768 to 32767
    for j in range(joy.NumButtons()):
        print('button', j, joy.GetButton(j))
    for j in range(joy.NumHats()):
        print('hat', j, joy.GetHat(j))

sdl.Quit()
Example #25
-1
    def event_loop(self):
        self.running = True
        ev = SDL.SDL_Event()
        while self.running:
            self.on_draw()
            self.flip()
            while SDL.SDL_WaitEvent(SDL.pointer(ev)) == 1:
                if ev.type == SDL.SDL_KEYDOWN:
                    self.controller.process_key_press(ev.key.keysym.sym,
                                                      ev.key.keysym.mod)
                    break
                elif ev.type == SDL.SDL_MOUSEMOTION:
                    pass
                elif ev.type == SDL.SDL_QUIT:
                    self.quit()
                elif ev.type == SDL.SDL_USEREVENT:
                    argid = int(ev.user.data1)
                    user_data = self.event_data.pop(argid)
#                    print "User event! code=%d data1=%s user_data=%s" % (ev.user.code, ev.user.data1, str(user_data))
                    func_name = self.event_code_to_callback[ev.user.code]
                    callback = getattr(self, func_name)
                    retval = callback(*user_data)
                    if retval == "force redraw":
                        break
                
            UpdateManager.process_tasks()
Example #26
-1
def main_loop():
	ev = SDL.SDL_Event()	
	oldtime = SDL.SDL_GetTicks()
	global screen

	image = SDL.IMG_Load('example2.png')
	if not image:
		print "failed to load image"
		return
	
	maxfps = 100
	
	global quit
	while not quit:
		SDL.SDL_BlitSurface(image, None, screen, None)
		SDL.SDL_Flip( screen )
		while SDL.SDL_PollEvent(SDL.pointer(ev)) == 1:
			handle_event(ev)
			
		newtime = SDL.SDL_GetTicks()
		dt = newtime - oldtime
		oldtime = newtime
		
		waittime = 1000 / maxfps - dt
		if waittime > 0:
			SDL.SDL_Delay(waittime)