def on_play(self, instance, value):
if not value:
Logger.info('Recorder: Stop playing %r' % self.filename)
EventLoop.remove_input_provider(self)
return
if not exists(self.filename):
Logger.error('Recorder: Unable to found %r file, play aborted.' % (
self.filename))
return
with open(self.filename, 'r') as fd:
data = fd.read().splitlines()
if len(data) < 2:
Logger.error('Recorder: Unable to play %r, file truncated.' % (
self.filename))
return
if data[0] != '#RECORDER1.0':
Logger.error('Recorder: Unable to play %r, invalid header.' % (
self.filename))
return
# decompile data
self.play_data = [literal_eval(x) for x in data[1:]]
self.play_time = time()
self.play_me = {}
Logger.info('Recorder: Start playing %d events from %r' %
(len(self.play_data), self.filename))
EventLoop.add_input_provider(self)
def probe(self):
inputs = get_inputs(self.input_path)
inputs = [x for x in inputs if x.has_capability(ABS_MT_POSITION_X)]
for device in inputs:
Logger.info('ProbeSysfs: found device: %s at %s' % (
device.name, device.device))
# must ignore ?
if self.match:
if not match(self.match, device.name, IGNORECASE):
Logger.warning('ProbeSysfs: device not match the'
' rule in config, ignoring.')
continue
d = device.device
devicename = self.device % dict(name=d.split(sep)[-1])
provider = MotionEventFactory.get(self.provider)
if provider is None:
Logger.info('ProbeSysfs: unable to found provider %s' %
self.provider)
Logger.info('ProbeSysfs: fallback on hidinput')
provider = MotionEventFactory.get('hidinput')
if provider is None:
Logger.critical('ProbeSysfs: no input provider found'
' to handle this device !')
continue
instance = provider(devicename, '%s,%s' % (device.device,
','.join(self.args)))
if instance:
from kivy.base import EventLoop
EventLoop.add_input_provider(instance)
def _register_input_provider():
global telenium_input, NCISMotionEvent, NCISINputProvider
if telenium_input:
return
from kivy.input.motionevent import MotionEvent
from kivy.input.provider import MotionEventProvider
class NCISMotionEvent(MotionEvent):
def depack(self, args):
self.is_touch = True
self.sx, self.sy = args[:2]
super(NCISMotionEvent, self).depack(args)
class NCISInputProvider(MotionEventProvider):
events = []
def update(self, dispatch_fn):
while self.events:
event = self.events.pop(0)
dispatch_fn(*event)
telenium_input = NCISInputProvider('ncis', None)
from kivy.base import EventLoop
EventLoop.add_input_provider(telenium_input)
def create_window(self, *largs):
if self._fake_fullscreen:
if not self.borderless:
self.fullscreen = self._fake_fullscreen = False
elif not self.fullscreen or self.fullscreen == 'auto':
self.borderless = self._fake_fullscreen = False
if self.fullscreen == 'fake':
self.borderless = self._fake_fullscreen = True
Logger.warning("The 'fake' fullscreen option has been "
"deprecated, use Window.borderless or the "
"borderless Config option instead.")
if not self.initialized:
if self.position == 'auto':
pos = None, None
elif self.position == 'custom':
pos = self.left, self.top
# setup !
w, h = self._size
resizable = Config.getboolean('graphics', 'resizable')
gl_size = self._win.setup_window(pos[0], pos[1], w, h,
self.borderless, self.fullscreen,
resizable)
# never stay with a None pos, application using w.center
# will be fired.
self._pos = (0, 0)
else:
w, h = self._size
self._win.resize_window(w, h)
self._win.set_border_state(self.borderless)
self._win.set_fullscreen_mode(self.fullscreen)
super(WindowSDL, self).create_window()
# auto add input provider
Logger.info('Window: auto add sdl input provider')
from kivy.base import EventLoop
SDL2MotionEventProvider.win = self
EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
# set window icon before calling set_mode
try:
filename_icon = self.icon or Config.get('kivy', 'window_icon')
if filename_icon == '':
logo_size = 32
if platform == 'macosx':
logo_size = 512
elif platform == 'win':
logo_size = 64
filename_icon = 'kivy-icon-{}.png'.format(logo_size)
filename_icon = resource_find(
join(kivy_data_dir, 'logo', filename_icon))
self.set_icon(filename_icon)
except:
Logger.exception('Window: cannot set icon')
def probe(self):
global EventLoop
from kivy.base import EventLoop
inputs = get_inputs(self.input_path)
Logger.debug('ProbeSysfs: using probesysfs!')
use_mouse = self.should_use_mouse()
if not self.select_all:
inputs = [
x for x in inputs
if x.has_capability(ABS_MT_POSITION_X) and (
use_mouse or not x.is_mouse)
]
for device in inputs:
Logger.debug('ProbeSysfs: found device: %s at %s' %
(device.name, device.device))
# must ignore ?
if self.match:
if self.use_regex:
if not match(self.match, device.name, IGNORECASE):
Logger.debug('ProbeSysfs: device not match the'
' rule in config, ignoring.')
continue
else:
if self.match not in device.name:
continue
Logger.info('ProbeSysfs: device match: %s' % device.device)
d = device.device
devicename = self.device % dict(name=d.split(sep)[-1])
provider = MotionEventFactory.get(self.provider)
if provider is None:
Logger.info('ProbeSysfs: Unable to find provider %s' %
self.provider)
Logger.info('ProbeSysfs: fallback on hidinput')
provider = MotionEventFactory.get('hidinput')
if provider is None:
Logger.critical('ProbeSysfs: no input provider found'
' to handle this device !')
continue
instance = provider(
devicename, '%s,%s' % (device.device, ','.join(self.args)))
if instance:
EventLoop.add_input_provider(instance)
def create_window(self, *largs):
use_fake = self.fullscreen == 'fake'
use_fullscreen = False
if self.fullscreen in ('auto', True):
use_fullscreen = self.fullscreen
if not self.initialized:
if self.position == 'auto':
pos = None, None
elif self.position == 'custom':
pos = self.left, self.top
# setup !
w, h = self._size
gl_size = self._win.setup_window(pos[0], pos[1], w, h, use_fake,
use_fullscreen)
# never stay with a None pos, application using w.center
# will be fired.
self._pos = (0, 0)
else:
w, h = self._size
self._win.resize_window(w, h)
super(WindowSDL, self).create_window()
# auto add input provider
Logger.info('Window: auto add sdl input provider')
from kivy.base import EventLoop
SDL2MotionEventProvider.win = self
EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
# set window icon before calling set_mode
try:
filename_icon = self.icon or Config.get('kivy', 'window_icon')
if filename_icon == '':
logo_size = 32
if platform == 'macosx':
logo_size = 512
elif platform == 'win':
logo_size = 64
filename_icon = 'kivy-icon-{}.png'.format(logo_size)
filename_icon = resource_find(
join(kivy_data_dir, 'logo', filename_icon))
self.set_icon(filename_icon)
except:
Logger.exception('Window: cannot set icon')
def probe(self):
global EventLoop
from kivy.base import EventLoop
inputs = get_inputs(self.input_path)
Logger.debug('ProbeSysfs: using probesysfs!')
use_mouse = self.should_use_mouse()
if not self.select_all:
inputs = [x for x in inputs if
x.has_capability(ABS_MT_POSITION_X) and
(use_mouse or not x.is_mouse)]
for device in inputs:
Logger.debug('ProbeSysfs: found device: %s at %s' % (
device.name, device.device))
# must ignore ?
if self.match:
if self.use_regex:
if not match(self.match, device.name, IGNORECASE):
Logger.debug('ProbeSysfs: device not match the'
' rule in config, ignoring.')
continue
else:
if self.match not in device.name:
continue
Logger.info('ProbeSysfs: device match: %s' % device.device)
d = device.device
devicename = self.device % dict(name=d.split(sep)[-1])
provider = MotionEventFactory.get(self.provider)
if provider is None:
Logger.info('ProbeSysfs: unable to found provider %s' %
self.provider)
Logger.info('ProbeSysfs: fallback on hidinput')
provider = MotionEventFactory.get('hidinput')
if provider is None:
Logger.critical('ProbeSysfs: no input provider found'
' to handle this device !')
continue
instance = provider(devicename, '%s,%s' % (
device.device, ','.join(self.args)))
if instance:
EventLoop.add_input_provider(instance)
def create_window(self, *largs):
use_fake = self.fullscreen == 'fake'
use_fullscreen = False
if self.fullscreen in ('auto', True):
use_fullscreen = self.fullscreen
if not self.initialized:
if self.position == 'auto':
pos = None, None
elif self.position == 'custom':
pos = self.left, self.top
# setup !
w, h = self._size
gl_size = self._win.setup_window(pos[0], pos[1], w, h,
use_fake, use_fullscreen)
# never stay with a None pos, application using w.center
# will be fired.
self._pos = (0, 0)
else:
w, h = self._size
self._win.resize_window(w, h)
super(WindowSDL, self).create_window()
# auto add input provider
Logger.info('Window: auto add sdl input provider')
from kivy.base import EventLoop
SDL2MotionEventProvider.win = self
EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
# set window icon before calling set_mode
try:
filename_icon = self.icon or Config.get('kivy', 'window_icon')
if filename_icon == '':
logo_size = 32
if platform == 'macosx':
logo_size = 512
elif platform == 'win':
logo_size = 64
filename_icon = 'kivy-icon-{}.png'.format(logo_size)
filename_icon = resource_find(
join(kivy_data_dir, 'logo', filename_icon))
self.set_icon(filename_icon)
except:
Logger.exception('Window: cannot set icon')
def create_window(self):
use_fake = True
use_fullscreen = False
# never stay with a None pos, application using w.center will be fired.
self._pos = (0, 0)
# setup !
w, h = self._size
self._size = sdl.setup_window(w, h, use_fake, use_fullscreen)
super(WindowSDL, self).create_window()
# auto add input provider
Logger.info('Window: auto add sdl input provider')
from kivy.base import EventLoop
SDLMotionEventProvider.win = self
EventLoop.add_input_provider(SDLMotionEventProvider('sdl', ''))
def build(self):
global _gpmon_scm
ctlsw = self.kwargs['ctlsw'] if self.kwargs.has_key('ctlsw') else False
if self.kwargs.has_key('tashp') and self.kwargs['tashp']:
Config.set('graphics', 'width', TASHP_SCREEN_SIZE[0])
Config.set('graphics', 'height', TASHP_SCREEN_SIZE[1])
_gpmon_scm = TashpScreenManager(iperfaddr=self.kwargs['iperfaddr'],
iperfport=self.kwargs['iperfport'],
size=TASHP_SCREEN_SIZE)
EventLoop.add_input_provider(_gpmon_scm)
else:
Config.set('graphics', 'width', SCREEN_SIZE[0])
Config.set('graphics', 'height', SCREEN_SIZE[1])
_gpmon_scm = GpmonScreenManager(ctlsw=ctlsw, size=SCREEN_SIZE)
_gpmon_scm.ipcsock = ListenIpcSocket(**self.kwargs)
_gpmon_scm.active_domain_switch = -1
EventLoop.add_input_provider(_gpmon_scm.ipcsock)
return _gpmon_scm
def create_window(self):
use_fake = True
use_fullscreen = False
# never stay with a None pos, application using w.center will be fired.
self._pos = (0, 0)
# setup !
w, h = self._size
self._size = sdl.setup_window(w, h, use_fake, use_fullscreen)
super(WindowSDL, self).create_window()
# auto add input provider
Logger.info('Window: auto add sdl input provider')
from kivy.base import EventLoop
SDLMotionEventProvider.win = self
EventLoop.add_input_provider(SDLMotionEventProvider('sdl', ''))
def setUp(self):
super().setUp()
self.etype = None
self.motion_event = None
self.touch_event = None
self.button_widget = None
from kivy.input.providers.mouse import MouseMotionEventProvider
self.mouse = mouse = MouseMotionEventProvider('mouse', '')
from kivy.base import EventLoop
win = EventLoop.window
win.mouse_pos = (0.0, 0.0)
win.rotation = 0
win.system_size = (320, 240)
mouse.start()
EventLoop.add_input_provider(mouse)
win.fbind('on_motion', self.on_motion)
# Patch `win.on_close` method to prevent EventLoop from removing
# window from event listeners list.
self.old_on_close = win.on_close
win.on_close = lambda *args: None
def register_input_provider():
global telenium_input
telenium_input = TeleniumInputProvider("telenium", None)
from kivy.base import EventLoop
EventLoop.add_input_provider(telenium_input)
def register_input_provider():
global telenium_input
telenium_input = TeleniumInputProvider("telenium", None)
from kivy.base import EventLoop
EventLoop.add_input_provider(telenium_input)
def create_window(self, *largs):
if self._fake_fullscreen:
if not self.borderless:
self.fullscreen = self._fake_fullscreen = False
elif not self.fullscreen or self.fullscreen == 'auto':
self.borderless = self._fake_fullscreen = False
if self.fullscreen == 'fake':
self.borderless = self._fake_fullscreen = True
Logger.warning("The 'fake' fullscreen option has been "
"deprecated, use Window.borderless or the "
"borderless Config option instead.")
if not self.initialized:
if self.position == 'auto':
pos = None, None
elif self.position == 'custom':
pos = self.left, self.top
# ensure we have an event filter
self._win.set_event_filter(self._event_filter)
# setup window
w, h = self.system_size
resizable = Config.getboolean('graphics', 'resizable')
state = (Config.get('graphics', 'window_state')
if self._is_desktop else None)
self.system_size = _size = self._win.setup_window(
pos[0], pos[1], w, h, self.borderless, self.fullscreen,
resizable, state, self.get_gl_backend_name())
# calculate density
sz = self._win._get_gl_size()[0]
self._density = density = sz / _size[0]
if self._is_desktop and self.size[0] != _size[0]:
self.dpi = density * 96.
# never stay with a None pos, application using w.center
# will be fired.
self._pos = (0, 0)
self._set_minimum_size()
self._set_allow_screensaver()
if state == 'hidden':
self._focus = False
else:
w, h = self.system_size
self._win.resize_window(w, h)
self._win.set_border_state(self.borderless)
self._win.set_fullscreen_mode(self.fullscreen)
super(WindowSDL, self).create_window()
# set mouse visibility
self._set_cursor_state(self.show_cursor)
if self.initialized:
return
# auto add input provider
Logger.info('Window: auto add sdl2 input provider')
from kivy.base import EventLoop
SDL2MotionEventProvider.win = self
EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
# set window icon before calling set_mode
try:
filename_icon = self.icon or Config.get('kivy', 'window_icon')
if filename_icon == '':
logo_size = 32
if platform == 'macosx':
logo_size = 512
elif platform == 'win':
logo_size = 64
filename_icon = 'kivy-icon-{}.png'.format(logo_size)
filename_icon = resource_find(
join(kivy_data_dir, 'logo', filename_icon))
self.set_icon(filename_icon)
except:
Logger.exception('Window: cannot set icon')
def create_window(self, *largs):
if self._fake_fullscreen:
if not self.borderless:
self.fullscreen = self._fake_fullscreen = False
elif not self.fullscreen or self.fullscreen == 'auto':
self.borderless = self._fake_fullscreen = False
if self.fullscreen == 'fake':
self.borderless = self._fake_fullscreen = True
Logger.warning("The 'fake' fullscreen option has been "
"deprecated, use Window.borderless or the "
"borderless Config option instead.")
if not self.initialized:
if self.position == 'auto':
pos = None, None
elif self.position == 'custom':
pos = self.left, self.top
# ensure we have an event filter
self._win.set_event_filter(self._event_filter)
# setup window
w, h = self.system_size
resizable = Config.getboolean('graphics', 'resizable')
state = (Config.get('graphics', 'window_state')
if self._is_desktop else None)
self.system_size = _size = self._win.setup_window(
pos[0], pos[1], w, h, self.borderless,
self.fullscreen, resizable, state)
# calculate density
sz = self._win._get_gl_size()[0]
self._density = density = sz / _size[0]
if self._is_desktop and self.size[0] != _size[0]:
self.dpi = density * 96.
# never stay with a None pos, application using w.center
# will be fired.
self._pos = (0, 0)
self._set_minimum_size()
if state == 'hidden':
self._focus = False
else:
w, h = self.system_size
self._win.resize_window(w, h)
self._win.set_border_state(self.borderless)
self._win.set_fullscreen_mode(self.fullscreen)
super(WindowSDL, self).create_window()
# set mouse visibility
self._set_cursor_state(self.show_cursor)
if self.initialized:
return
# auto add input provider
Logger.info('Window: auto add sdl2 input provider')
from kivy.base import EventLoop
SDL2MotionEventProvider.win = self
EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
# set window icon before calling set_mode
try:
filename_icon = self.icon or Config.get('kivy', 'window_icon')
if filename_icon == '':
logo_size = 32
if platform == 'macosx':
logo_size = 512
elif platform == 'win':
logo_size = 64
filename_icon = 'kivy-icon-{}.png'.format(logo_size)
filename_icon = resource_find(
join(kivy_data_dir, 'logo', filename_icon))
self.set_icon(filename_icon)
except:
Logger.exception('Window: cannot set icon')
def create_window(self, *largs):
if self._fake_fullscreen:
if not self.borderless:
self.fullscreen = self._fake_fullscreen = False
elif not self.fullscreen or self.fullscreen == 'auto':
self.custom_titlebar = \
self.borderless = self._fake_fullscreen = False
elif self.custom_titlebar:
if platform == 'win':
# use custom behaviour
# To handle aero snapping and rounded corners
self.borderless = False
if self.fullscreen == 'fake':
self.borderless = self._fake_fullscreen = True
Logger.warning("The 'fake' fullscreen option has been "
"deprecated, use Window.borderless or the "
"borderless Config option instead.")
if not self.initialized:
if self.position == 'auto':
pos = None, None
elif self.position == 'custom':
pos = self.left, self.top
# ensure we have an event filter
self._win.set_event_filter(self._event_filter)
# setup window
w, h = self.system_size
resizable = Config.getboolean('graphics', 'resizable')
state = (Config.get('graphics', 'window_state')
if self._is_desktop else None)
self.system_size = _size = self._win.setup_window(
pos[0], pos[1], w, h, self.borderless, self.fullscreen,
resizable, state, self.get_gl_backend_name())
# calculate density/dpi
if platform == 'win':
from ctypes import windll
self._density = 1.
try:
hwnd = windll.user32.GetActiveWindow()
self.dpi = float(windll.user32.GetDpiForWindow(hwnd))
except AttributeError:
pass
else:
sz = self._win._get_gl_size()[0]
self._density = density = sz / _size[0]
if self._is_desktop and self.size[0] != _size[0]:
self.dpi = density * 96.
# never stay with a None pos, application using w.center
# will be fired.
self._pos = (0, 0)
self._set_minimum_size()
self._set_allow_screensaver()
if state == 'hidden':
self._focus = False
else:
w, h = self.system_size
self._win.resize_window(w, h)
if platform == 'win':
if self.custom_titlebar:
# check dragging+resize or just dragging
if Config.getboolean('graphics', 'resizable'):
import win32con
import ctypes
self._win.set_border_state(False)
# make windows dispatch,
# WM_NCCALCSIZE explicitly
ctypes.windll.user32.SetWindowPos(
self._win.get_window_info().window,
win32con.HWND_TOP, *self._win.get_window_pos(),
*self.system_size, win32con.SWP_FRAMECHANGED)
else:
self._win.set_border_state(True)
else:
self._win.set_border_state(self.borderless)
else:
self._win.set_border_state(self.borderless
or self.custom_titlebar)
self._win.set_fullscreen_mode(self.fullscreen)
super(WindowSDL, self).create_window()
# set mouse visibility
self._set_cursor_state(self.show_cursor)
if self.initialized:
return
# auto add input provider
Logger.info('Window: auto add sdl2 input provider')
from kivy.base import EventLoop
SDL2MotionEventProvider.win = self
EventLoop.add_input_provider(SDL2MotionEventProvider('sdl', ''))
# set window icon before calling set_mode
try:
filename_icon = self.icon or Config.get('kivy', 'window_icon')
if filename_icon == '':
logo_size = 32
if platform == 'macosx':
logo_size = 512
elif platform == 'win':
logo_size = 64
filename_icon = 'kivy-icon-{}.png'.format(logo_size)
filename_icon = resource_find(
join(kivy_data_dir, 'logo', filename_icon))
self.set_icon(filename_icon)
except:
Logger.exception('Window: cannot set icon')
if platform == 'win' and self._win_dpi_watch is None:
self._win_dpi_watch = _WindowsSysDPIWatch(window=self)
self._win_dpi_watch.start()
