def _discover(self):
'''Create lists of all plugins present'''
# TODO non-hook plugins
# find user hooks
self._plugins_user = {}
for uhook in self._get_executables(
os.path.join(os.getenv('HOME'), '.disper', 'hooks')):
name = os.path.splitext(os.path.split(uhook)[1])[0]
self._plugins_user[name] = Hook(self.disper, uhook)
self.log.info('Available user hooks: ' + ', '.join(self._plugins_user))
# find system hooks
self._plugins_system = {}
for uhook in self._get_executables(
os.path.join(self.disper.prefix_share, 'hooks')):
name = os.path.splitext(os.path.split(uhook)[1])[0]
self._plugins_system[name] = Hook(self.disper, uhook)
self.log.info('Available system hooks: ' +
', '.join(self._plugins_user))
# Now create global list of plugins where user plugins get precedence
self._plugins = {}
for i in self._plugins_system:
self._plugins[i] = self._plugins_system[i]
for i in self._plugins_user:
self._plugins[i] = self._plugins_user[i]
def __init__(self):
# pygame.init is used to deploy the background
pygame.init()
# self.screen will display a window with 1200 by 700 screen size
self.settings = Settings(self)
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.screen_rect = self.screen.get_rect()
# bg_colour will give a background colour
self.bg_colour = self.settings.bg_colour
# self.captions will create a title at the top of the window
pygame.display.set_caption('Blue Sky')
self.fish = Fish(self)
self.seaweeds = pygame.sprite.Group()
self.worms = pygame.sprite.Group()
self.hook = Hook(self)
self.line = Line(self)
self.stats = GameStats(self)
self._create_fleet()
self._create_worms()
self.clock = pygame.time.Clock()
self.counter = 0
pygame.time.set_timer(pygame.USEREVENT, 1000)
self.play = Button(self, 'Play')
self.sb = Score(self)
def __init__(self):
self.hook = Hook(Vector(250, 250))
self.line = Line(200, (251, 100), 2, self.hook)
self.length = math.sqrt((self.line.begin[0] - self.line.end[0]) *
(self.line.begin[0] - self.line.end[0]) +
(self.line.begin[1] - self.line.end[1]) *
(self.line.begin[1] - self.line.end[1]))
def __init__(self):
self.lock = Lock()
self.ringer = Ringer(5)
self.hook = Hook(22, self)
self.sipClient = SipClient(self)
self.dialplate = Dialplate(17, 27, self)
self.number = ""
self.dialTimer = None
def init_game():
pygame.init()
game_settings = Settings()
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height),
pygame.FULLSCREEN)
# screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height))
ship = Ship(screen)
stats = GameStats(game_settings)
friend = Friend(screen)
enemy = Enemy(screen)
enemy_2 = Enemy_2(screen)
enemy_3 = Enemy_3(screen)
enemy_4 = Enemy_4(screen)
enemy_5 = Enemy_5(screen)
enemy_6 = Enemy_6(screen)
enemy_7 = Enemy_7(screen)
enemy_8 = Enemy_8(screen)
enemy_9 = Enemy_9(screen)
hook = Hook(screen)
background = Background(screen)
pygame.display.set_caption("Peter Pan")
bullets = Group()
enemies = Group()
enemies.add(enemy, enemy_2, enemy_3, enemy_4, enemy_5, enemy_6, enemy_7,
enemy_8, enemy_9, hook)
friends = Group()
friends.add(friend)
ships = Group()
ships.add(ship)
#g_f.create_fleet(game_settings, screen, ship)
button = Button(screen, game_settings, "Play")
sb = Scoreboard(game_settings, screen, stats)
while True:
g_f.chek_events(game_settings, ship, screen, bullets, button, stats,
enemies, sb)
g_f.update_screen(background, ships, bullets, enemies, screen, button,
friends, stats, sb)
if stats.game_active:
g_f.update_bullets(bullets, enemies, ships, friends, hook, stats,
sb, screen)
g_f.aliens_move(enemies, screen, friends, ships, bullets, ship)
ship.update()
ship.blitme()
def __init__(self, name, shm_prefix, test_class):
self.hook = Hook("vpp-papi-provider")
self.name = name
self.shm_prefix = shm_prefix
self.test_class = test_class
jsonfiles = []
install_dir = os.getenv('VPP_TEST_INSTALL_PATH')
for root, dirnames, filenames in os.walk(install_dir):
for filename in fnmatch.filter(filenames, '*.api.json'):
jsonfiles.append(os.path.join(root, filename))
self.papi = VPP(jsonfiles)
self._events = deque()
def hook(self, request, hookName):
try:
logger.info("Hook called: " + hookName)
#make sure json is valid and unprettified
body = json.dumps(json.loads(request.content.read()))
H = Hook(hookName, body)
result = yield H.d
returnValue(result)
except ValueError, e:
logger.error(hookName + " Called with invalid JSON")
logger.debug(e)
raise NotFound()
def __init__(self, name, test_class, read_timeout):
self.hook = Hook(test_class)
self.name = name
self.test_class = test_class
self._expect_api_retval = self._zero
self._expect_stack = []
# install_dir is a class attribute. We need to set it before
# calling the constructor.
VPPApiClient.apidir = os.getenv('VPP_INSTALL_PATH')
self.vpp = VPPApiClient(logger=test_class.logger,
read_timeout=read_timeout,
use_socket=True,
server_address=test_class.get_api_sock_path())
self._events = queue.Queue()
def __init__(self, name, shm_prefix, test_class, read_timeout):
self.hook = Hook("vpp-papi-provider")
self.name = name
self.shm_prefix = shm_prefix
self.test_class = test_class
self._expect_api_retval = self._zero
self._expect_stack = []
jsonfiles = []
install_dir = os.getenv('VPP_TEST_INSTALL_PATH')
for root, dirnames, filenames in os.walk(install_dir):
for filename in fnmatch.filter(filenames, '*.api.json'):
jsonfiles.append(os.path.join(root, filename))
self.vpp = VPP(jsonfiles, logger=test_class.logger,
read_timeout=read_timeout)
self._events = deque()
def _load_hooks(self, plugin, name, filters: str = None):
self.log.debug(f"Loading {name}'s hooks" +
(f" Filtered to {filters}" if filters else ""))
for func in plugin.__dict__.values():
# self.log.debug(f"checking {func} in {plugin}")
if not hasattr(func, "_IsHook"):
continue
hooks = getattr(func, "_IsHook")
for hook, perm in hooks:
if filters is not None and not fnmatch(hook, filters):
self.log.debug(
f"SKIPPING {hook}: {func}, does not match filter ('{filters}'): '{hook}''"
)
continue
self.log(f"loading new hook {hook}: {func}" +
(f" Hook requested {perm}" if perm else ""))
self.hooks[hook].append(Hook(name, func, perm))
delattr(func, "_IsHook")
def __init__(self, name, shm_prefix, test_class, read_timeout):
self.hook = Hook(test_class)
self.name = name
self.shm_prefix = shm_prefix
self.test_class = test_class
self._expect_api_retval = self._zero
self._expect_stack = []
# install_dir is a class attribute. We need to set it before
# calling the constructor.
VPPApiClient.apidir = os.getenv('VPP_INSTALL_PATH')
use_socket = False
try:
if os.environ['SOCKET'] == '1':
use_socket = True
except KeyError:
pass
self.vpp = VPPApiClient(logger=test_class.logger,
read_timeout=read_timeout,
use_socket=use_socket,
server_address=test_class.api_sock)
self._events = deque()
def __init__(self, display=None, desktops=None, loop=None):
self.log = Log("WM")
# INIT SOME BASIC STUFF
self.hook = Hook()
self.windows = {} # mapping between window id and Window
self.win2desk = {}
if not display:
display = os.environ.get("DISPLAY")
try:
self._conn = xcffib.connect(display=display)
except xcffib.ConnectionException:
sys.exit("cannot connect to %s" % display)
self.atoms = AtomVault(self._conn)
self.desktops = desktops or [Desktop()]
self.cur_desktop = self.desktops[0]
self.cur_desktop.show()
# CREATE ROOT WINDOW
xcb_setup = self._conn.get_setup()
xcb_screens = [i for i in xcb_setup.roots]
self.xcb_default_screen = xcb_screens[self._conn.pref_screen]
root_wid = self.xcb_default_screen.root
self.root = Window(self, wid=root_wid, atoms=self.atoms, mapped=True)
self.windows[root_wid] = self.root
# for desktop in self.desktops:
# desktop.windows.append(self.root)
self.root.set_attr(
eventmask=(
EventMask.StructureNotify
| EventMask.SubstructureNotify
| EventMask.FocusChange
# | EventMask.SubstructureRedirect
| EventMask.EnterWindow
# | EventMask.LeaveWindow
# | EventMask.PropertyChange
| EventMask.OwnerGrabButton
)
)
# INFORM X WHICH FEATURES WE SUPPORT
self.root.props[self.atoms._NET_SUPPORTED] = [self.atoms[a] for a in SUPPORTED_ATOMS]
# PRETEND TO BE A WINDOW MANAGER
supporting_wm_check_window = self.create_window(-1, -1, 1, 1)
supporting_wm_check_window.props['_NET_WM_NAME'] = "SWM"
self.root.props['_NET_SUPPORTING_WM_CHECK'] = supporting_wm_check_window.wid
self.root.props['_NET_NUMBER_OF_DESKTOPS'] = len(self.desktops)
self.root.props['_NET_CURRENT_DESKTOP'] = 0
# TODO: set cursor
# EVENTS THAT HAVE LITTLE USE FOR US...
self.ignoreEvents = {
"KeyRelease",
"ReparentNotify",
# "CreateNotify",
# DWM handles this to help "broken focusing windows".
# "MapNotify",
"ConfigureNotify",
"LeaveNotify",
"FocusOut",
"FocusIn",
"NoExposure",
}
# KEYBOARD
self.kbd = Keyboard(xcb_setup, self._conn)
self.mouse = Mouse(conn=self._conn, root=self.root)
# FLUSH XCB BUFFER
self.xsync() # apply settings
# the event loop is not yet there, but we might have some pending
# events...
self._xpoll()
# TODO: self.grabMouse
# NOW IT'S TIME TO GET PHYSICAL SCREEN CONFIGURATION
self.xrandr = Xrandr(root=self.root, conn=self._conn)
# TODO: self.update_net_desktops()
# SETUP EVENT LOOP
if not loop:
loop = asyncio.new_event_loop()
self._eventloop = loop
self._eventloop.add_signal_handler(signal.SIGINT, self.stop)
self._eventloop.add_signal_handler(signal.SIGTERM, self.stop)
self._eventloop.add_signal_handler(signal.SIGCHLD, self.on_sigchld)
self._eventloop.set_exception_handler(
lambda loop, ctx: self.log.error(
"Got an exception in {}: {}".format(loop, ctx))
)
fd = self._conn.get_file_descriptor()
self._eventloop.add_reader(fd, self._xpoll)
# HANDLE STANDARD EVENTS
self.hook.register("MapRequest", self.on_map_request)
self.hook.register("MapNotify", self.on_map_notify)
self.hook.register("UnmapNotify", self.on_window_unmap)
self.hook.register("KeyPress", self.on_key_press)
# self.hook.register("KeyRelease", self.on_key_release)
# self.hook.register("CreateNotify", self.on_window_create)
self.hook.register("PropertyNotify", self.on_property_notify)
self.hook.register("ClientMessage", self.on_client_message)
self.hook.register("DestroyNotify", self.on_window_destroy)
self.hook.register("EnterNotify", self.on_window_enter)
self.hook.register("ConfigureRequest", self.on_configure_window)
self.hook.register("MotionNotify", self.on_mouse_event)
self.hook.register("ButtonPress", self.on_mouse_event)
self.hook.register("ButtonRelease", self.on_mouse_event)
def __init__(self, name, shm_prefix):
self.hook = Hook("vpp-papi-provider")
self.name = name
self.shm_prefix = shm_prefix
def test_hook(self):
hook = Hook(self.hook_pin)
def create_enemies(screen, enemies):
enemy = Enemy(screen)
enemy_2 = Enemy_2(screen)
hook = Hook(screen)
enemies.add(enemy, enemy_2, hook)
if platform.system() == 'Linux':
print('If the screen brightness is not restored properly after '
'exit, specify\nin atexit.sh how reset your screen '
'calibration.\n')
atexit_sh = os.path.join(app_path, 'atexit.sh')
if not os.path.isfile(atexit_sh):
with open(atexit_sh, mode='w') as f:
f.write('#!/bin/bash\n')
f.write('# This script is executed when the app exits.\n')
f.write('#\n')
f.write('# Examples:\n')
f.write('# xgamma -gamma 1.0\n')
f.write('# xcalib -display $DISPLAY -screen 0 '
'~/path/to/profile.icc\n')
f.write('# xrandr --output DVI-0 --gamma 1.0:1.0:1.0\n')
os.chmod(atexit_sh, 0o755)
def call_atexit_sh():
if platform.system() == 'Linux':
subprocess.check_call([atexit_sh])
atexit.register(call_atexit_sh)
print("PLEASE CLOSE THE APP WITH CTRL+C!\n")
with Hook(app, enable=app.enable_hook):
app.run()
