def __init__(self,
title,
width=1024,
height=768,
background_color=color.Smoke):
self.base_width = width
self.base_height = height
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(width, height)
glutInitWindowPosition((self.screen_width - width) // 2,
(self.screen_height - height) // 2)
glutCreateWindow(title)
glutKeyboardFunc(self.handle_key)
glutDisplayFunc(self._draw)
glutIdleFunc(self.handle_idle)
glutMouseFunc(self.handle_mouse)
glutSpecialFunc(self.handle_special_key)
glutReshapeFunc(self.handle_reshape)
glEnable(GL_DEPTH_TEST)
if background_color is not None:
self.fill_color(*color.Smoke, 1.)
def __init__(self, model):
"""Initialize input handlers and link given Model to the Input."""
self.__model = model
glutKeyboardFunc(lambda key, x, y: self.__handle_key(key, False))
glutKeyboardUpFunc(lambda key, x, y: self.__handle_key(key, True))
glutSpecialFunc(lambda key, x, y: self.__handle_special(key))
def __init__(self, model):
"""Initialize input handlers and link given Model to the Input."""
self.__model = model
glutKeyboardFunc(lambda key, x, y: self.__handle_key(key, False))
glutKeyboardUpFunc(lambda key, x, y: self.__handle_key(key, True))
glutSpecialFunc(lambda key, x, y: self.__handle_special(key))
def init(self, hide_window):
# Shift from ARGB to RGBA
self.color_palette = [((x << 8) & 0xFFFFFFFF) | 0x000000FF
for x in self.color_palette]
self.alphamask = 0x000000FF
self.color_format = u"RGB"
self.buffer_dims = (144, 160)
if not glutInit():
raise Exception("OpenGL couldn't initialize!")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self._scale, self._scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
if hide_window:
logger.warning("Hiding the window is not supported in OpenGL")
def register(self):
"""
注册glut的事件回调函数
"""
glutMouseFunc(self.handle_mouse_button)
glutMotionFunc(self.handle_mouse_move)
glutKeyboardFunc(self.handle_keystroke)
glutSpecialFunc(self.handle_keystroke)
def register(self):
""" register callbacks with glut """
glutMouseFunc(self.handle_mouse_button)
glutMotionFunc(self.handle_mouse_move)
glutKeyboardFunc(self.handle_keystroke)
glutSpecialFunc(self.handle_keystroke)
glutPassiveMotionFunc(None)
def register(self):
""" register callbacks with glut """
glutMouseFunc(self.handle_mouse_button)
glutMotionFunc(self.handle_mouse_move)
glutKeyboardFunc(self.handle_keystroke)
glutSpecialFunc(self.handle_keystroke)
glutPassiveMotionFunc(None)
def register(self):
print('进入register函数')
""" 注册glut的事件回调函数 """
glutMouseFunc(self.handle_mouse_button)
glutMotionFunc(self.handle_mouse_move)
glutKeyboardFunc(self.handle_keystroke)
print('尝试过调用self.handle_keystroke()函数')
glutSpecialFunc(self.handle_keystroke)
print('尝试第二次')
def init_opengl(self, width, height, x, y):
glutInit()
glutInitWindowPosition(x, y)
glutInitWindowSize(width, height)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE)
glutCreateWindow("Rainbow Alga")
glutDisplayFunc(self.render)
glutIdleFunc(self.render)
glutReshapeFunc(self.resize)
glutMouseFunc(self.mouse)
glutMotionFunc(self.drag)
glutKeyboardFunc(self.keyboard)
glutSpecialFunc(self.special_keyboard)
glClearDepth(1.0)
glClearColor(0.0, 0.0, 0.0, 0.0)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 3000)
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT)
# Lighting
light_ambient = (0.0, 0.0, 0.0, 1.0)
light_diffuse = (1.0, 1.0, 1.0, 1.0)
light_specular = (1.0, 1.0, 1.0, 1.0)
light_position = (-100.0, 100.0, 100.0, 0.0)
mat_ambient = (0.7, 0.7, 0.7, 1.0)
mat_diffuse = (0.8, 0.8, 0.8, 1.0)
mat_specular = (1.0, 1.0, 1.0, 1.0)
high_shininess = (100)
glEnable(GL_LIGHT0)
glEnable(GL_NORMALIZE)
glEnable(GL_COLOR_MATERIAL)
glEnable(GL_LIGHTING)
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient)
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse)
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular)
glLightfv(GL_LIGHT0, GL_POSITION, light_position)
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient)
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse)
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular)
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess)
# Transparency
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
def main():
#Load up the local settings
game_settings = load_settings()
#Network starts first since it gives us many of the parameters we need to initialize our game grid.
network = MasterNetworkMode(game_settings)
network.startNetwork()
#Client-side game related stuffs below
#This function will wait until the network thread either connects or times out
#This really shouldn't take more than a few hundred milliseconds at worst on a local connection
game_grid_params = network.getParameters()
if game_grid_params is None: #YOU DUN GOOFED UP NOW
print "Failed to initialize network thread. Quitting..."
exit(1)
'''
if game_settings["net_mode"] == "ClientMode":
print "Client recv params:"
print game_grid_params
'''
#Update our globals
update_params(game_grid_params)
#Get our player init data from the client thread.
init_player_data = network.getInitPlayerData()
client_connection_id = network.getConnectionID()
#initilize our game grid and SnakeManager objects using the data gathered above.
snakepit = SnakeManager(client_connection_id, init_player_data)
Game_Grid = Grid(snakepit, game_grid_params["GRID_SIDE_SIZE_PX"],
game_grid_params["WINDOW_SIZE"])
#Update our network side with the SnakeManager and Grid references
network.setSnakeReference(snakepit)
network.setGridReference(Game_Grid)
#class to handle the drawing of our various elements
#This has turned into more of a driver class for everything.
renderman = RenderManager(Game_Grid)
#Gl/Glut stuffs below
glinit("PyGLSnake-Multiplayer :: Connection ID: %s" % client_connection_id)
glutSpecialFunc(snakepit.keypressCallbackGLUT)
#glutDisplayFunc is the main callback function opengl calls when GLUT determines that the display must be redrawn
glutDisplayFunc(renderman.render_all_shapes)
glutTimerFunc(TICKRATE_MS, renderman.calc_movement_all_shapes, 0)
#Might want to get rid of this unless we plan to run it through the komodo profiler
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION)
#Start everything up
glutMainLoop()
def _initGL(self, extraArgs):
"""initializes OpenGL and creates the Window"""
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(self.size, self.size)
glutInitWindowPosition(self.initx, self.inity)
glutInit(extraArgs.split(" "))
glutCreateWindow(VERSIONSTRING.encode("ascii"))
glutDisplayFunc(self.Draw)
glutIdleFunc(glutPostRedisplay)
glutReshapeFunc(self.Reshape)
glutKeyboardFunc(self.HandleKeys)
glutSpecialFunc(self.HandleKeys)
glutMouseFunc(self.HandleMouse)
glClearColor(*(self.bgcolor + [0.0]))
glEnable(GL_LINE_SMOOTH)
glLineWidth(1.3)
def show_OpenGL(csg):
if not _have_OpenGL:
raise RuntimeError("PyOpenGL not available")
renderable = TestRenderable(csg)
glutInit()
glutInitWindowSize(640, 480)
renderable.win_id = glutCreateWindow("CSG Test")
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION)
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
glutDisplayFunc(renderable.display)
glutKeyboardFunc(renderable.keypress)
glutSpecialFunc(renderable.special_keypress)
renderable.init()
glutMainLoop()
def initialize(self):
"""Sets up the OpenGL window and binds input callbacks to it
"""
glutKeyboardFunc(self._on_key_down)
glutSpecialFunc(self._on_special_key_down)
# [Keyboard/Special]Up methods aren't supported on some old GLUT implementations
has_keyboard_up = False
has_special_up = False
try:
if bool(glutKeyboardUpFunc):
glutKeyboardUpFunc(self._on_key_up)
has_keyboard_up = True
if bool(glutSpecialUpFunc):
glutSpecialUpFunc(self._on_special_key_up)
has_special_up = True
except NullFunctionError:
# Methods aren't available on this GLUT version
pass
if not has_keyboard_up or not has_special_up:
# Warn on old GLUT implementations that don't implement much of the interface.
self._logger.warning(
"Warning: Old GLUT implementation detected - keyboard remote control of Vector disabled."
"We recommend installing freeglut. %s",
_glut_install_instructions())
self._is_keyboard_control_enabled = False
else:
self._is_keyboard_control_enabled = True
try:
GLUT_BITMAP_9_BY_15
except NameError:
self._logger.warning(
"Warning: GLUT font not detected. Help message will be unavailable."
)
glutMouseFunc(self._on_mouse_button)
glutMotionFunc(self._on_mouse_move)
glutPassiveMotionFunc(self._on_mouse_move)
glutIdleFunc(self._idle)
glutVisibilityFunc(self._visible)
def init(self):
# Shift from ARGB to RGBA
self.color_palette = [((x << 8) & 0xFFFFFFFF) | 0x000000FF for x in self.color_palette]
self.alphamask = 0x000000FF
self.color_format = u"RGB"
glutInit()
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self._scale, self._scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
def __init__(self, pyboy, mb, pyboy_argv):
super().__init__(pyboy, mb, pyboy_argv)
if not self.enabled():
return
if not glutInit():
raise Exception("OpenGL couldn't initialize!")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self.scale, self.scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
def init(self):
# Shift from ARGB to RGBA
self.color_palette = [((x << 8) & 0xFFFFFFFF) | 0x000000FF
for x in self.color_palette]
self.alphamask = 0x000000FF
self.color_format = u"RGB"
glutInit()
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self._scale, self._scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
def main():
init()
Game_Grid = Grid()
snake = Snake(Game_Grid)
#I didnt really want to use GLUT much but eh, I will work this out with standard libraries later
glutSpecialFunc(snake.keypress_callback_GLUT)
renderman = RenderManager(Game_Grid, snake)
glutDisplayFunc(renderman.render_all_shapes)
glutTimerFunc(TICKRATE_MS, renderman.calc_movement_all_shapes, 0)
#Tell Glut to continue execution after we exit the main loop
#Komodo's code profiler will not return any results unless you shut down just right
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION)
#set vsync
swap_control.wglSwapIntervalEXT(VSYNC)
#Start everything up
glutMainLoop()
def register_callbacks():
"""
Registers the following callbacks with GLUT:
- glutKeyboardFunc
- glutKeyboardUpFunc
- glutSpecialFunc
- glutSpecialUpFunc
- glutMotionFunc
- glutPassiveMotionFunc
- glutMouseFunc
"""
glutKeyboardFunc(_key_down)
glutKeyboardUpFunc(_key_up)
glutSpecialFunc(_special_down)
glutSpecialUpFunc(_special_up)
glutMotionFunc(_mouse_pos_listener)
glutPassiveMotionFunc(_mouse_pos_listener)
glutMouseFunc(_mouse_button_listener)
def __init__(self, hat):
self.hat = hat
self.config = hat.config['lcd']
default = {
'contrast': 60,
'invert': False,
'backlight': 200,
'flip': False,
'language': 'en',
'bigstep': 10,
'smallstep': 1,
'remote': False
}
for name in default:
if not name in self.config:
self.config[name] = default[name]
# set the driver to the one from hat eeprom
driver = 'default'
if self.hat.hatconfig:
driver = self.hat.hatconfig['lcd']['driver']
for pdriver in [
'nokia5110', 'jlx12864', 'glut', 'framebuffer', 'none'
]:
if pdriver in sys.argv:
sys.argv.remove(pdriver)
driver = pdriver
break
print('Using driver', driver)
use_glut = 'DISPLAY' in os.environ
self.use_glut = False
if driver == 'none':
screen = None
elif driver == 'nokia5110' or (driver == 'default' and not use_glut):
screen = ugfx.spiscreen(0)
elif driver == 'jlx12864':
screen = ugfx.spiscreen(1)
elif driver == 'glut' or (driver == 'default' and use_glut):
self.use_glut = True
print('using glut')
import glut
#screen = glut.screen((120, 210))
#screen = glut.screen((64, 128))
screen = glut.screen((48, 84))
#screen = glut.screen((96, 168))
from OpenGL.GLUT import glutKeyboardFunc, glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc, glutSpecialUpFunc
glutKeyboardFunc(self.glutkeydown)
glutKeyboardUpFunc(self.glutkeyup)
glutSpecialFunc(self.glutspecialdown)
glutSpecialUpFunc(self.glutspecialup)
# glutIgnoreKeyRepeat(True)
elif driver == 'framebuffer':
print('using framebuffer')
screen = ugfx.screen("/dev/fb0")
if screen.width > 480:
screen.width = 480
screen.height = min(screen.height, 640)
if screen:
w, h = screen.width, screen.height
mul = int(math.ceil(w / 48.0))
self.bw = 1 if w < 256 else False
width = min(w, 48 * mul)
self.surface = ugfx.surface(width, int(width * h / w), screen.bypp,
None)
# magnify to fill screen
self.mag = min(screen.width / self.surface.width,
screen.height / self.surface.height)
if self.mag != 1:
print('magnifying lcd surface to fit screen')
self.magsurface = ugfx.surface(screen)
self.invsurface = ugfx.surface(self.surface)
self.frameperiod = .25 # 4 frames a second possible
self.lastframetime = 0
else:
self.surface = None
self.frameperiod = 1
self.screen = screen
self.set_language(self.config['language'])
self.range_edit = False
self.modes = {
'compass': self.have_compass,
'gps': self.have_gps,
'wind': self.have_wind,
'true wind': self.have_true_wind
}
self.modes_list = ['compass', 'gps', 'wind', 'true wind'] # in order
self.watchlist = [
'ap.enabled', 'ap.mode', 'ap.pilot', 'ap.heading_command',
'gps.source', 'wind.source', 'servo.controller', 'servo.flags',
'imu.compass.calibration', 'imu.compass.calibration.sigmapoints',
'imu.compass.calibration.locked', 'imu.alignmentQ',
'rudder.calibration_state'
]
self.initial_gets = [
'servo.speed.min', 'servo.speed.max', 'servo.max_current',
'servo.period', 'imu.alignmentCounter'
]
self.create_mainmenu()
self.display_page = self.display_control
self.connecting_dots = 0
self.keypad = [False, False, False, False, False, False, False, False]
self.keypadup = list(self.keypad)
self.blink = black, white
self.control = False # used to keep track of what is drawn on screen to avoid redrawing it
self.wifi = False
def register(self):
""" to rigister glut's event-callback-function"""
glutMouseFunc(self.handle_mouse_button)
glutMotionFunc(self.handle_mouse_move)
glutKeyboardFunc(self.handle_keystroke)
glutSpecialFunc(self.handle_keystroke)
def __init__(self):
print(str(bool(glutInit)))
print("hello and weolcome")
print(
"if you see an error next try the unofficial binaries of pyopengl")
print("initializing glut etc")
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH)
glutInitWindowSize(640, 480)
glutCreateWindow(name)
print("set blend function")
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
print("set colours and lights")
glClearColor(0., 0., 0., 1.)
glShadeModel(GL_SMOOTH)
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glEnable(GL_LIGHTING)
print("set light 1")
lightZeroPosition = [10., 4., 10., 1.]
lightZeroColor = [0.9, 1.0, 0.9, 1.0] #green tinged
glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition)
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor)
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.2)
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05)
glEnable(GL_LIGHT0)
print("set light 2")
lightZeroPosition2 = [-10., -4., 10., 1.]
lightZeroColor2 = [1.0, 0.9, 0.9, 1.0] #green tinged
glLightfv(GL_LIGHT1, GL_POSITION, lightZeroPosition2)
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightZeroColor2)
glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 0.2)
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.05)
glEnable(GL_LIGHT1)
#initialization of letters
print("initialzing letters")
self.letters = Letters.Letters()
#for game models
print("making model lists")
MakeLists()
print("ignore key repeat")
glutIgnoreKeyRepeat(1)
print("attach glut events to functions")
glutSpecialFunc(self.keydownevent)
glutSpecialUpFunc(self.keyupevent)
glutReshapeFunc(self.reshape)
glutKeyboardFunc(self.keydownevent)
glutKeyboardUpFunc(self.keyupevent)
glutDisplayFunc(self.display)
#glutIdleFunc(self.display)
print("initial projection")
glMatrixMode(GL_PROJECTION)
gluPerspective(60.0, 640.0 / 480., 1., 50.)
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
print("generating level")
self.level = generateLevel(0)
print("keys set up")
self.initkey("zxdcfvqaopm")
self.animate()
print("about to loop...")
glutMainLoop()
return
def special_func(cls, callback):
glutSpecialFunc(callback)
def __init__(self, config):
if config:
self.config = config['lcd']
else:
self.config = {}
self.pipe = False
self.poller = False
self.voltage = False
default = {
'contrast': 60,
'invert': False,
'backlight': 20,
'hue': 214,
'flip': False,
'language': 'en',
'bigstep': 10,
'smallstep': 1,
'buzzer': 2
}
for name in default:
if not name in self.config:
self.config[name] = default[name]
global driver
# set the driver to the one read from hat eeprom, or specified in hat.conf
if config and 'hat' in config:
if driver == 'default':
driver = config['hat']['lcd']['driver']
self.host = config['host']
else:
self.host = False
self.battery_voltage = 0
use_tft = True if micropython else False
self.keypress = False
use_glut = not use_tft and 'DISPLAY' in os.environ
self.surface = None
self.use_glut = False
print('lcd driver', driver, use_tft, use_glut)
if driver == 'none':
page = None
screen = None
self.bw = None
elif driver == 'tft' or (driver == 'default' and use_tft):
import gc
if gc.mem_free() > 1e6: # larger ttgo display
screen = ugfx.surface(240, 320, 1)
else:
screen = ugfx.surface(136, 240, 1)
self.surface = screen
elif driver == 'nokia5110' or (driver == 'default' and not use_glut):
screen = ugfx.spiscreen(0)
elif driver == 'jlx12864':
screen = ugfx.spiscreen(1)
elif driver == 'glut' or (driver == 'default' and use_glut):
self.use_glut = True
print('using glut')
import glut
# emulate which screen resolution?
#screen = glut.screen((240, 320))
screen = glut.screen((136, 240))
#screen = glut.screen((48, 84))
#screen = glut.screen((96, 168))
from OpenGL.GLUT import glutKeyboardFunc, glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc, glutSpecialUpFunc
glutKeyboardFunc(self.glutkeydown)
glutKeyboardUpFunc(self.glutkeyup)
glutSpecialFunc(self.glutspecialdown)
glutSpecialUpFunc(self.glutspecialup)
self.glutkeytime = False
# glutIgnoreKeyRepeat(True)
elif driver == 'framebuffer':
print('using framebuffer')
screen = ugfx.screen("/dev/fb0")
if screen.width > 480:
print('warning huge width')
#screen.width = 480
#screen.height= min(screen.height, 640)
if screen:
self.bw = 1 if screen.width < 120 else False
self.mag = 1
if not self.surface:
w, h = screen.width, screen.height
self.surface = ugfx.surface(w, h, screen.bypp, None)
# magnify to fill screen
self.mag = min(screen.width / self.surface.width,
screen.height / self.surface.height)
if self.mag != 1:
print('magnifying lcd surface to fit screen')
self.magsurface = ugfx.surface(screen)
self.invsurface = ugfx.surface(self.surface)
else:
self.surface = None
self.screen = screen
set_language(self.config['language'])
self.client = False
self.connect()
self.menu = False
self.page = connecting(self)
self.need_refresh = True
self.keypad = []
for i in range(NUM_KEYS):
self.keypad.append(Key())
self.blink = black, white # two cursor states
self.data_update = False
def main():
print 'init...'
screen = None
for arg in sys.argv:
if 'nokia5110' in arg:
sys.argv.remove(arg)
print 'using nokia5110'
screen = ugfx.nokia5110screen()
if not screen:
if use_glut:
screen = glut.screen((120, 210))
#screen = glut.screen((64, 128))
#screen = glut.screen((48, 84))
else:
screen = ugfx.screen("/dev/fb0")
if screen.width == 416 and screen.height == 656:
# no actual device or display
print 'no actual screen, running headless'
screen = None
if screen.width > 480:
screen.width = 480
screen.height= min(screen.height, 640)
lcdclient = LCDClient(screen)
if screen:
# magnify to fill screen
mag = min(screen.width / lcdclient.surface.width, screen.height / lcdclient.surface.height)
if mag != 1:
print "magnifying lcd surface to fit screen"
magsurface = ugfx.surface(screen)
invsurface = ugfx.surface(lcdclient.surface)
def idle():
if screen:
lcdclient.display()
surface = lcdclient.surface
if lcdclient.config['invert']:
invsurface.blit(surface, 0, 0)
surface = invsurface
surface.invert(0, 0, surface.width, surface.height)
if mag != 1:
magsurface.magnify(surface, mag)
surface = magsurface
# mag = 2
#surface.magnify(mag)
screen.blit(surface, 0, 0, lcdclient.config['flip'])
screen.refresh()
if 'contrast' in lcdclient.config:
screen.contrast = int(lcdclient.config['contrast'])
lcdclient.idle()
if use_glut:
from OpenGL.GLUT import glutMainLoop
from OpenGL.GLUT import glutIdleFunc
from OpenGL.GLUT import glutKeyboardFunc
from OpenGL.GLUT import glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc
from OpenGL.GLUT import glutSpecialUpFunc
glutKeyboardFunc(lcdclient.glutkeydown)
glutKeyboardUpFunc(lcdclient.glutkeyup)
glutSpecialFunc(lcdclient.glutspecialdown)
glutSpecialUpFunc(lcdclient.glutspecialup)
glutIdleFunc(idle)
# glutIgnoreKeyRepeat(True)
glutMainLoop()
else:
while True:
idle()
def __init__(self, hat):
self.hat = hat
if hat:
self.config = hat.config['lcd']
elif micropython:
from config_esp32 import read_config
self.config = read_config()
else:
self.config = {}
default = {
'contrast': 60,
'invert': False,
'backlight': 20,
'flip': False,
'language': 'en',
'bigstep': 10,
'smallstep': 1
}
for name in default:
if not name in self.config:
self.config[name] = default[name]
# set the driver to the one from hat eeprom
driver = 'default'
if self.hat and 'hat' in self.hat.config:
driver = self.hat.config['hat']['lcd']['driver']
self.host = self.hat.client.config['host']
else:
self.host = False
for pdriver in [
'nokia5110', 'jlx12864', 'glut', 'framebuffer', 'tft', 'none'
]:
if pdriver in sys.argv:
print('overriding driver', driver, ' to command line', pdriver)
sys.argv.remove(pdriver)
driver = pdriver
break
self.battery_voltage = 0
use_tft = True if micropython else False
if not use_tft:
use_glut = 'DISPLAY' in os.environ
self.use_glut = False
self.surface = None
if driver == 'none':
page = None
elif driver == 'tft' or (driver == 'default' and use_tft):
screen = ugfx.surface(136, 240, 1)
self.surface = screen
elif driver == 'nokia5110' or (driver == 'default' and not use_glut):
screen = ugfx.spiscreen(0)
elif driver == 'jlx12864':
screen = ugfx.spiscreen(1)
elif driver == 'glut' or (driver == 'default' and use_glut):
self.use_glut = True
print('using glut')
import glut
# emulate which screen resolution?
#screen = glut.screen((240, 320))
screen = glut.screen((136, 240))
#screen = glut.screen((48, 84))
#screen = glut.screen((96, 168))
from OpenGL.GLUT import glutKeyboardFunc, glutKeyboardUpFunc
from OpenGL.GLUT import glutSpecialFunc, glutSpecialUpFunc
glutKeyboardFunc(self.glutkeydown)
glutKeyboardUpFunc(self.glutkeyup)
glutSpecialFunc(self.glutspecialdown)
glutSpecialUpFunc(self.glutspecialup)
self.glutkeytime = False
# glutIgnoreKeyRepeat(True)
elif driver == 'framebuffer':
print('using framebuffer')
screen = ugfx.screen("/dev/fb0")
if screen.width > 480:
print('warning huge width')
#screen.width = 480
#screen.height= min(screen.height, 640)
if screen:
self.bw = 1 if screen.width < 120 else False
self.mag = 1
if not self.surface:
w, h = screen.width, screen.height
self.surface = ugfx.surface(w, h, screen.bypp, None)
# magnify to fill screen
self.mag = min(screen.width / self.surface.width,
screen.height / self.surface.height)
if self.mag != 1:
print('magnifying lcd surface to fit screen')
self.magsurface = ugfx.surface(screen)
self.invsurface = ugfx.surface(self.surface)
else:
self.surface = None
self.lastframetime = 0
self.screen = screen
set_language(self.config['language'])
self.client = False
self.connect()
self.menu = False
self.page = connecting(self)
self.need_refresh = True
self.keypad = []
for i in range(NUM_KEYS):
self.keypad.append(Key())
self.blink = black, white # two cursor states
self.data_update = False
