def __init__(self, i2c_dev=0, sda=21, scl=22, freq=400000, addr=0x38, width=-1, height=-1,
inv_x=False, inv_y=False, swap_xy=False):
if not lv.is_initialized():
lv.init()
self.width, self.height = width, height
self.inv_x, self.inv_y, self.swap_xy = inv_x, inv_y, swap_xy
self.i2c = I2C(i2c_dev, sda=Pin(sda), scl=Pin(scl), freq=freq)
self.addr = addr
try:
print("FT6X36 touch IC ready (fw id 0x{0:X} rel {1:d}, lib {2:X})".format( \
int.from_bytes(self.i2c.readfrom_mem(self.addr, 0xA6, 1), "big"), \
int.from_bytes(self.i2c.readfrom_mem(self.addr, 0xAF, 1), "big"), \
int.from_bytes(self.i2c.readfrom_mem(self.addr, 0xA1, 2), "big") \
))
except:
print("FT6X36 touch IC not responding")
return
self.point = lv.point_t( {'x': 0, 'y': 0} )
self.points = [lv.point_t( {'x': 0, 'y': 0} ), lv.point_t( {'x': 0, 'y': 0} )]
self.state = lv.INDEV_STATE.RELEASED
self.indev_drv = lv.indev_drv_t()
self.indev_drv.init()
self.indev_drv.type = lv.INDEV_TYPE.POINTER
self.indev_drv.read_cb = self.callback
self.indev_drv.register()
def start(port=80):
if espidf.mdns_init() == 0 and espidf.mdns_hostname_set(
'littleblockly') == 0:
print("mdns: littleblockly.local")
# setup input driver to send click events
drv = lv.indev_drv_t()
drv.init()
drv.type = lv.INDEV_TYPE.POINTER
drv.read_cb = input_callback
drv.register()
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
addr = socket.getaddrinfo("0.0.0.0", port)[0][4]
server_socket.bind(addr)
server_socket.listen(5)
server_socket.setsockopt(socket.SOL_SOCKET, 20,
accept_http_connect) # <- ????
for i in (network.AP_IF, network.STA_IF):
wlan = network.WLAN(i)
if wlan.active():
print("Web server started on {}:{}".format(wlan.ifconfig()[0],
port))
return server_socket
def init_gui_esp32(self):
import lvesp32
import ILI9341 as ili
# Initialize ILI9341 display
disp = ili.display(miso=5, mosi=18, clk=19, cs=13, dc=12, rst=4, backlight=2)
disp.init()
# Register display driver
disp_drv = lv.disp_drv_t()
lv.disp_drv_init(disp_drv)
disp_drv.disp_flush = disp.flush
disp_drv.disp_fill = disp.fill
lv.disp_drv_register(disp_drv)
# Register raw resistive touch driver
import rtch
touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
touch.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read = touch.read;
lv.indev_drv_register(indev_drv);
def init_gui_esp32(self):
import lvesp32
import ILI9341 as ili
# Initialize ILI9341 display
disp = ili.display(miso=5, mosi=18, clk=19, cs=13, dc=12, rst=4, backlight=2)
disp.init()
# Register 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 = disp.flush
disp_drv.hor_res = 240
disp_drv.ver_res = 320
lv.disp_drv_register(disp_drv)
# Register raw resistive touch driver
import rtch
touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
touch.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read_cb = touch.read;
lv.indev_drv_register(indev_drv);
def init_gui_stm32(self):
import rk043fn48h as lcd
import lvstm32
hres = 480
vres = 272
# Register display driver
self.tick = lvstm32.lvstm32()
lcd.init(w=hres, h=vres)
disp_buf1 = lv.disp_buf_t()
buf1_1 = lcd.framebuffer(1)
buf1_2 = lcd.framebuffer(2)
disp_buf1.init(buf1_1, buf1_2, len(buf1_1) // lv.color_t.SIZE)
disp_drv = lv.disp_drv_t()
disp_drv.init()
disp_drv.buffer = disp_buf1
disp_drv.flush_cb = lcd.flush
disp_drv.gpu_blend_cb = lcd.gpu_blend
disp_drv.gpu_fill_cb = lcd.gpu_fill
disp_drv.hor_res = hres
disp_drv.ver_res = vres
disp_drv.register()
# Register touch sensor
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = lcd.ts_read
indev_drv.register()
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)
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()
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_stm32(self):
import rk043fn48h as lcd
hres = 480
vres = 272
# Register display driver
self.event_loop = event_loop()
lcd.init(w=hres, h=vres)
disp_buf1 = lv.disp_draw_buf_t()
buf1_1 = bytearray(hres * 50 * lv.color_t.__SIZE__)
buf1_2 = bytearray(hres * 50 * lv.color_t.__SIZE__)
disp_buf1.init(buf1_1, buf1_2, len(buf1_1) // lv.color_t.__SIZE__)
disp_drv = lv.disp_drv_t()
disp_drv.init()
disp_drv.draw_buf = disp_buf1
disp_drv.flush_cb = lcd.flush
disp_drv.hor_res = hres
disp_drv.ver_res = vres
disp_drv.register()
# Register touch sensor
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = lcd.ts_read
indev_drv.register()
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")
def registerEncoderDriver(self):
self._encdev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._encdev_drv)
self._encdev_drv.type = lv.INDEV_TYPE.ENCODER
self._encdev_drv.read_cb = self.getEncoderReader()
self._encDriver = lv.indev_drv_register(self._encdev_drv)
return self._keyDriver
def registerKeyDriver(self):
self._keydev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._keydev_drv)
self._keydev_drv.type = lv.INDEV_TYPE.KEYPAD
self._keydev_drv.read_cb = self.getKeyReader()
self._keyDriver = lv.indev_drv_register(self._keydev_drv)
return self._keyDriver
def _register_indev_drv(self):
# Register touch screen driver
self._indev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._indev_drv)
self._indev_drv.type = lv.INDEV_TYPE.POINTER
self._indev_drv.read_cb = self._tft.read
self._indev = lv.indev_drv_register(self._indev_drv)
return
def registerDriver(self):
self._indev_drv = lv.indev_drv_t()
lv.indev_drv_init(self._indev_drv)
self._indev_drv.type = self._devType
self._indev_drv.read_cb = self.getReader()
self._driver = lv.indev_drv_register(self._indev_drv)
self.extraRegistration()
return self._driver
def register_input_callback(self):
# setup input driver to send click events
self.drv = lv.indev_drv_t()
self.drv.init()
self.drv.type = lv.INDEV_TYPE.POINTER
self.drv.read_cb = self.input_callback
self.drv.register()
self.mstate = None
def init_gui_esp32(self):
self.last_x = 0
self.last_y = 0
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = self.read_touch
indev_drv.register()
def init_gui(self):
import lvgl as lv
import lvgl_helper as lv_h
import lcd
import time
from machine import I2C
config_touchscreen_support = True
board_m1n = False
i2c = I2C(I2C.I2C0, freq=400000, scl=30, sda=31)
if not board_m1n:
lcd.init()
else:
lcd.init(type=2, freq=20000000)
if config_touchscreen_support:
import touchscreen as ts
ts.init(i2c)
lv.init()
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(320 * 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 = lv_h.flush
if board_m1n:
disp_drv.hor_res = 240
disp_drv.ver_res = 240
else:
disp_drv.hor_res = 320
disp_drv.ver_res = 240
lv.disp_drv_register(disp_drv)
if config_touchscreen_support:
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = lv_h.read
lv.indev_drv_register(indev_drv)
# lv.log_register_print_cb(lv_h.log)
lv.log_register_print_cb(lambda level, path, line, msg: print(
'%s(%d): %s' % (path, line, msg)))
# Create the main screen and load it.
self.screen_main = Screen_Main(self)
lv.scr_load(self.screen_main)
def __init__(self,
miso=-1,
mosi=-1,
clk=-1,
cs=25,
spihost=esp.HSPI_HOST,
half_duplex=True,
mhz=5,
max_cmds=16,
cal_x0=3783,
cal_y0=3948,
cal_x1=242,
cal_y1=423,
transpose=True,
samples=3):
# Initializations
if not lv.is_initialized():
lv.init()
disp = lv.disp_t.__cast__(None)
self.screen_width = disp.get_hor_res()
self.screen_height = disp.get_ver_res()
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.spihost = spihost
self.half_duplex = half_duplex
self.mhz = mhz
self.max_cmds = max_cmds
self.cal_x0 = cal_x0
self.cal_y0 = cal_y0
self.cal_x1 = cal_x1
self.cal_y1 = cal_y1
self.transpose = transpose
self.samples = samples
self.touch_count = 0
self.touch_cycles = 0
self.spi_init()
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = self.read
indev_drv.register()
def __init__(self,
miso=-1,
mosi=-1,
clk=-1,
cs=25,
spihost=esp.HSPI_HOST,
mhz=5,
transpose=False,
touch_margin=100):
# Initializations
self.screen_width = lv.disp_get_hor_res(lv.disp_t.cast(None))
self.screen_height = lv.disp_get_ver_res(lv.disp_t.cast(None))
self.miso = miso
self.mosi = mosi
self.clk = clk
self.cs = cs
self.spihost = spihost
self.mhz = mhz
self.cal_x0 = None
self.transpose = transpose
self.touch_margin = touch_margin
self.touch_count = 0
self.touch_cycles = 0
self.spi_init()
# Prepare buffer with commands to send to device
nc = len(self.CMDS)
self.buflen = 2 * nc * REP + 1 # +1 for final CMD_OFF
self.txbuf = esp.heap_caps_malloc(self.buflen, esp.MALLOC_CAP.DMA)
txbuf = self.txbuf.__dereference__(self.buflen)
for c in range(nc):
for r in range(REP):
txbuf[(c * REP + r) * 2 +
0] = self.CMDS[c] # first byte is command, second is 0
txbuf[(c * REP + r) * 2 + 1] = 0
txbuf[2 * nc * REP] = CMD_OFF
# print("xpt2046 txbuf:", ["%02x" % v for v in txbuf])
self.rxbuf = esp.heap_caps_malloc(self.buflen, esp.MALLOC_CAP.DMA)
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = self.read
lv.indev_drv_register(indev_drv)
print("xpt2046 touch initialized")
def __init__(self):
# Initializations
self.i2c = I2C(1, sda=Pin(21), scl=Pin(22), freq=100000)
self.int = Pin(FT_INT_PIN, Pin.IN)
disp = lv.disp_t.cast(None)
self.screen_width = disp.get_hor_res()
self.screen_height = disp.get_ver_res()
indev_drv = lv.indev_drv_t()
indev_drv.init()
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = self.read
indev_drv.register()
self.reg_write_byte(0xA4, b"\x00")
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
def __init__(self, encoder, group=None):
def input_callback(drv, data):
data.enc_diff = encoder.diff
if encoder.pressed:
data.state = lv.INDEV_STATE.PR
else:
data.state = lv.INDEV_STATE.REL
gc.collect()
return False
self.drv = lv.indev_drv_t()
self.encoder = encoder
lv.indev_drv_init(self.drv)
self.drv.type = lv.INDEV_TYPE.ENCODER
self.drv.read_cb = input_callback
self.win_drv = lv.indev_drv_register(self.drv)
self.group = group
def __init__(self):
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytearray(390 * 32)
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 = display.flush
disp_drv.hor_res = 390
disp_drv.ver_res = 390
lv.disp_drv_register(disp_drv)
touchscreen.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = touchscreen.touchscreen_read
lv.indev_drv_register(indev_drv)
def __init__(self, scr=None, cursor=None, device='/dev/input/mice'):
# Open evdev and initialize members
self.evdev = open(device, 'rb')
self.poll = select.poll()
self.poll.register(self.evdev.fileno())
self.scr = scr if scr else lv.scr_act()
self.cursor = cursor if cursor else crosshair_cursor(self.scr)
self.hor_res = self.scr.get_width()
self.ver_res = self.scr.get_height()
# Register LVGL indev driver
self.indev_drv = lv.indev_drv_t()
self.indev_drv.init()
self.indev_drv.type = lv.INDEV_TYPE.POINTER
self.indev_drv.read_cb = self.mouse_read
self.indev = self.indev_drv.register()
def init_gui_esp32(self):
import lvesp32
# Initialize ILI9341 display
from ili9341 import ili9341
self.disp = ili9341()
# Register raw resistive touch driver
import rtch
self.touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
self.touch.init()
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER;
indev_drv.read_cb = self.touch.read;
lv.indev_drv_register(indev_drv);
def __init__(self,
sda=21,
scl=22,
freq=400000,
width=-1,
height=-1,
inv_x=False,
inv_y=False,
swap_xy=False):
if not lv.is_initialized():
lv.init()
self.width, self.height = width, height
self.inv_x, self.inv_y, self.swap_xy = inv_x, inv_y, swap_xy
self.touch = ft6336u(sda=Pin(sda), scl=Pin(scl), freq=freq)
try:
status = self.touch.check()
print("FT6X36 touch IC ready (fw id 0x{0:X} rel {1:d}, lib {2:X})".format( \
status[0], \
status[1], \
status[2] \
))
except:
print("FT6X36 touch IC not responding")
return
self.point = lv.point_t({'x': 0, 'y': 0})
self.points = [
lv.point_t({
'x': 0,
'y': 0
}), lv.point_t({
'x': 0,
'y': 0
})
]
self.state = lv.INDEV_STATE.RELEASED
self.indev_drv = lv.indev_drv_t()
self.indev_drv.init()
self.indev_drv.type = lv.INDEV_TYPE.POINTER
self.indev_drv.read_cb = self.callback
self.indev_drv.register()
def screen_init():
sda_pin = machine.Pin(23)
scl_pin = machine.Pin(32)
i2c = machine.I2C(id=1, scl=scl_pin, sda=sda_pin, speed=400000)
ts.init(i2c)
tft.init(tft.ST7789, width=240, invrot=3, rot=1, bgr=False, height=240, miso=2, mosi=19, clk=18, cs=5, dc=27,
speed=40000000, color_bits=tft.COLOR_BITS16, backl_pin=12, backl_on=1)
tft.clear(tft.RED)
time.sleep(1)
tft.clear(tft.GREEN)
time.sleep(1)
tft.clear(tft.BLUE)
time.sleep(1)
lv.init()
disp_buf1 = lv.disp_buf_t()
buf1_1 = bytes(240 * 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 = lv_h.flush
disp_drv.hor_res = 240
disp_drv.ver_res = 240
lv.disp_drv_register(disp_drv)
indev_drv = lv.indev_drv_t()
lv.indev_drv_init(indev_drv)
indev_drv.type = lv.INDEV_TYPE.POINTER
indev_drv.read_cb = lv_h.read
lv.indev_drv_register(indev_drv)
scr = lv.obj()
btn = lv.btn(scr)
btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
label = lv.label(btn)
label.set_text("Button")
lv.scr_load(scr)
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);
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()
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()
