def __init__(self, test=False, interface=''): '''Initialize the SSDP server.''' log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('datagram_received', 'new_device', 'removed_device', 'log') self.known = {} self._callbacks = {} self.test = test if not self.test: self.port = reactor.listenMulticast( SSDP_PORT, self, listenMultiple=True, interface=interface, ) self.port.joinGroup(SSDP_ADDR, interface=interface) self.resend_notify_loop = task.LoopingCall(self.resendNotify) self.resend_notify_loop.start(777.0, now=False) self.check_valid_loop = task.LoopingCall(self.check_valid) self.check_valid_loop.start(333.0, now=False) self.active_calls = []
def __init__(self, service, dbus_device, bus): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.service = service self.dbus_device = dbus_device # get the service name self.type = self.service.service_type.split(':')[3] bus_name = dbus.service.BusName(CDS_SERVICE, bus) device_id = dbus_device.id self.path = (OBJECT_PATH + '/devices/' + device_id + '/services/' + 'CDS') dbus.service.Object.__init__( self, bus, bus_name=bus_name, object_path=self.path, ) self.debug(f'DBusService {service} {self.type}') if isinstance(self.service, EventDispatcher): self.service.bind(state_variable_changed=self.variable_changed) self.subscribeStateVariables()
def __init__(self, size=(DEFAULT_WIDTH, DEFAULT_HEIGHT), title='MegaMinerAI Bland Title Text', fullscreen=False): self.window = Window(width=size[0], height=size[1], caption=title, visible=True, fullscreen=fullscreen, resizable=True, style=Window.WINDOW_STYLE_DEFAULT, vsync=False, display=None, context=None, config=None) self.updates = [] # Set up the event dispatcher self.ed = EventDispatcher() self.ed.register_class_for_events(self) # Build the game loader self.loader = gameloader.GameLoader(self.ed) #Build the renderer self.renderer = renderer.Renderer() # Request updates self.request_update_on_draw(self.renderer.init_frame, 0) self.request_update_on_draw(self.renderer.draw_frame, 100)
def __init__(self, coherence, backend, **kwargs): EventDispatcher.__init__(self) self.coherence = coherence if not hasattr(self, 'version'): self.version = int( kwargs.get('version', self.coherence.config.get('version', 2))) try: self.uuid = str(kwargs['uuid']) if not self.uuid.startswith('uuid:'): self.uuid = 'uuid:' + self.uuid except KeyError: from coherence.upnp.core.uuid import UUID self.uuid = UUID() urlbase = str(self.coherence.urlbase) if urlbase[-1] != '/': urlbase += '/' self.urlbase = urlbase + str(self.uuid)[5:] kwargs['urlbase'] = self.urlbase self.icons = kwargs.get('iconlist', kwargs.get('icons', [])) if len(self.icons) == 0: if 'icon' in kwargs: if isinstance(kwargs['icon'], dict): self.icons.append(kwargs['icon']) else: self.icons = kwargs['icon'] reactor.callLater(0.2, self.fire, backend, **kwargs)
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('device_client_detection_completed', ) self.device = device self.device.bind(embedded_device_client_detection_completed=self. embedded_device_notified) # noqa self.device_type = self.device.get_friendly_device_type() self.version = int(self.device.get_device_type_version()) self.icons = device.icons self.wan_device = None try: wan_device = self.device.get_embedded_device_by_type( 'WANDevice')[0] self.wan_device = WANDeviceClient(wan_device) except Exception as e: self.warning(f'Embedded WANDevice device not available, device not' f' implemented properly according to the UPnP' f' specification [error: {e}]') raise self.info(f'InternetGatewayDevice {device.get_friendly_name()}')
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('embedded_device_client_detection_completed') self.device = device self.device.bind(service_notified=self.service_notified) self.device_type = self.device.get_friendly_device_type() self.version = int(self.device.get_device_type_version()) self.icons = device.icons self.wan_ip_connection = None self.wan_ppp_connection = None for service in self.device.get_services(): if service.get_type() in [ 'urn:schemas-upnp-org:service:WANIPConnection:1' ]: self.wan_ip_connection = WANIPConnectionClient(service) if service.get_type() in [ 'urn:schemas-upnp-org:service:WANPPPConnection:1' ]: self.wan_ppp_connection = WANPPPConnectionClient(service) self.info(f'WANConnectionDevice {device.get_friendly_name()}') if self.wan_ip_connection: self.info('WANIPConnection service available') if self.wan_ppp_connection: self.info('WANPPPConnection service available')
def __init__(self, ssdp_server, test=False): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('datagram_received') self.ssdp_server = ssdp_server if not test: self.port = reactor.listenUDP(0, self) self.double_discover_loop = task.LoopingCall(self.double_discover) self.double_discover_loop.start(120.0)
def __init__(self, focus=None): """ """ #TODO: make it a singleton EventDispatcher.__init__(self) self._focus = focus self._blocking = 0 self._running = True self.__events = []
def __init__(self, *args, **kwargs): EventDispatcher.__init__(self) log.LogAble.__init__(self) self.register_event( 'response_flush', 'response_event', 'response_volume', 'response_mute', 'response_repeat', 'response_browse', )
def __init__(self, service): resource.Resource.__init__(self) log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('event_client_message_received') self.service = service self.subscribers = service.get_subscribers() try: self.backend_name = self.service.backend.name except AttributeError: self.backend_name = self.service.backend
def __init__(self, control_point): log.LogAble.__init__(self) resource.Resource.__init__(self) EventDispatcher.__init__(self) self.register_event('event_server_message_received') self.coherence = control_point.coherence self.control_point = control_point self.coherence.add_web_resource('events', self) global hostname, web_server_port hostname = self.coherence.hostname web_server_port = self.coherence.web_server_port self.info('EventServer ready...')
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('device_client_detection_completed', ) self.device = device self.device.bind(device_service_notified=self.service_notified) self.device_type = self.device.get_friendly_device_type() self.version = int(self.device.get_device_type_version()) self.icons = device.icons self.scheduled_recording = None self.connection_manager = None self.av_transport = None for service in self.device.get_services(): if service.get_type() in [ 'urn:schemas-upnp-org:service:ContentDirectory:1', 'urn:schemas-upnp-org:service:ContentDirectory:2' ]: self.content_directory = ContentDirectoryClient(service) if service.get_type() in [ 'urn:schemas-upnp-org:service:ConnectionManager:1', 'urn:schemas-upnp-org:service:ConnectionManager:2' ]: self.connection_manager = ConnectionManagerClient(service) if service.get_type() in [ 'urn:schemas-upnp-org:service:AVTransport:1', 'urn:schemas-upnp-org:service:AVTransport:2' ]: self.av_transport = AVTransportClient(service) if service.detection_completed: self.service_notified(service) self.info(f'MediaServer {device.get_friendly_name()}') if self.content_directory: self.info('ContentDirectory available') else: self.warning( 'ContentDirectory not available, device not implemented' ' properly according to the UPnP specification') return if self.connection_manager: self.info('ConnectionManager available') else: self.warning( 'ConnectionManager not available, device not implemented' ' properly according to the UPnP specification') return if self.av_transport: self.info('AVTransport (optional) available') if self.scheduled_recording: self.info('ScheduledRecording (optional) available')
def __init__(self, type, pattern, callback, timeout=0, oneshot=True): EventDispatcher.__init__(self) self.type = type self.pattern = pattern self.callback = callback self.timeout = timeout self.oneshot = oneshot if self.type == 'uuid' and self.pattern.startswith('uuid:'): self.pattern = self.pattern[5:] if isinstance(self.callback, str): # print(f'DeviceQuery: register event {self.callback}') self.register_event(self.callback)
def __init__( self, upnp_service, name, implementation, instance, send_events, data_type, allowed_values, ): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.service = upnp_service self.dispatch_events = [ f'state_variable_{name}_changed', 'state_variable_changed', ] self.dispatch_targets = [self] if isinstance(self.service, EventDispatcher): self.dispatch_targets.append(self.service) for target in self.dispatch_targets: for evt in self.dispatch_events: if evt not in target.event_dispatcher_event_callbacks: target.register_event(evt) self.name = name self.implementation = implementation self.instance = instance self.send_events = utils.means_true(send_events) self.never_evented = False self.data_type = data_type self.allowed_values = allowed_values if self.allowed_values is None: self.allowed_values = [] self.has_vendor_values = False self.allowed_value_range = None self.dependant_variable = None self.default_value = '' self.old_value = '' self.value = '' self.last_time_touched = None self._callbacks = [] if isinstance(self.service, service.ServiceServer): self.moderated = self.service.is_variable_moderated(name) self.updated = False
def __init__(self, parent=None, udn=None): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'device_detection_completed', 'device_remove_client', 'device_service_notified', 'device_got_client', ) self.parent = parent self.udn = udn # self.uid = self.usn[:-len(self.st)-2] self.friendly_name = '' self.device_type = '' self.upnp_version = 'n/a' self.friendly_device_type = '[unknown]' self.device_type_version = 0
def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._texture_dispatcher = EventDispatcher() self._object_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._texture_handler = TextureEditHandler(self, self._current_scene.children[0]) self._object_handler = TexturedObjectHandler(self, self._current_scene.children[1]) self._main_dispatcher.push_handlers(self._main_handler) self._texture_dispatcher.push_handlers(self._texture_handler) self._object_dispatcher.push_handlers(self._object_handler) glutSetWindow(self._window) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._main_dispatcher.handle_type('reshape')) self._menu_main = glutCreateMenu(self._main_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._main_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[0]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._texture_dispatcher.handle_type('reshape')) glutMouseFunc(self._texture_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._texture_dispatcher.handle_type('mouse_motion')) glutPassiveMotionFunc(self._texture_dispatcher.handle_type('mouse_motion')) self._menu_texture = glutCreateMenu(self._texture_dispatcher.handle_type('menu')) glutAddMenuEntry("Clear", self._texture_handler.get_menu_id('menu_clear')) glutAddMenuEntry("Quit", self._texture_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[1]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._object_dispatcher.handle_type('reshape')) glutMouseFunc(self._object_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._object_dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu(self._object_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._object_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1)
def __init__(self, server, *args, **kwargs): ''' Args: server (object): This usually should be an instance of our main class :class:`~coherence.base.Coherence` (the UPnP device that's hosting our backend). *args (list): A list with extra arguments for the backend. This, must be implemented into the subclass (if needed). **kwargs (dict): An unpacked dictionary with the backend's configuration. ''' self.config = kwargs self.server = server EventDispatcher.__init__(self) log.LogAble.__init__(self) Plugin.__init__(self) self.register_event('backend_init_completed', 'backend_init_failed')
def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._dispatcher = EventDispatcher() self._defaultHandler = DefaultHandler(self) self._dispatcher.push_handlers(self._defaultHandler) glutKeyboardFunc(self._dispatcher.handle_type('keyboard')) glutReshapeFunc(self._dispatcher.handle_type('reshape')) glutMouseFunc(self._dispatcher.handle_type('mouse_button')) glutMotionFunc(self._dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu(self._dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._defaultHandler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) self._menu_scene = glutCreateMenu(self._dispatcher.handle_type('menu')) glutSetMenu(self._menu_main) glutAddSubMenu("Scene", self._menu_scene) glutTimerFunc(1, self.update, 1) glutDisplayFunc(self.render)
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'embedded_device_client_detection_completed', ) self.device = device self.device.bind( embedded_device_client_detection_completed=self.embedded_device_notified, # noqa service_notified=self.service_notified ) self.device_type = self.device.get_friendly_device_type() self.version = int(self.device.get_device_type_version()) self.icons = device.icons self.wan_connection_device = None self.wan_common_interface_connection = None try: wan_connection_device = \ self.device.get_embedded_device_by_type( 'WANConnectionDevice')[0] self.wan_connection_device = WANConnectionDeviceClient( wan_connection_device) except Exception as er: self.warning( f'Embedded WANConnectionDevice device not available, device ' f'not implemented properly according to the UPnP ' f'specification [ERROR: {er}]') raise for service in self.device.get_services(): if service.get_type() in [ 'urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1']: self.wan_common_interface_connection = \ WANCommonInterfaceConfigClient(service) self.info(f'WANDevice {device.get_friendly_name()}')
def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._main_dispatcher.push_handlers(self._main_handler) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._main_dispatcher.handle_type('reshape')) glutMouseFunc(self._main_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._main_dispatcher.handle_type('mouse_motion')) glutPassiveMotionFunc(self._main_dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu(self._main_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._main_handler.get_menu_id('menu_quit')) glutAddMenuEntry("Raytrace", self._main_handler.get_menu_id('menu_raytrace')) glutAddMenuEntry("Take Screenshot", self._main_handler.get_menu_id('menu_take_screenshot')) glutAddMenuEntry("Toggle Mesh Visibility", self._main_handler.get_menu_id('menu_visibility')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1) glutDisplayFunc(self.render)
def __init__(self, coherence, auto_client=None): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('control_point_client_detected', 'control_point_client_removed') if not auto_client: auto_client = ['MediaServer', 'MediaRenderer'] self.coherence = coherence self.auto_client = auto_client self.coherence.bind( coherence_device_detection_completed=self.check_device, coherence_device_removed=self.remove_client, ) self.info('Coherence UPnP ControlPoint starting...') self.event_server = EventServer(self) self.coherence.add_web_resource('RPC2', XMLRPC(self)) for device in self.get_devices(): self.info(f'ControlPoint [check device]: {device}') self.check_device(device)
def __init__(self, config=None): # initialize only once if self.__initialized: return self.__initialized = True # supers log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'coherence_device_detection_completed', 'coherence_device_removed', 'coherence_root_device_removed', ) self.config = config or {} self.available_plugins = None self.external_address = None self.urlbase = None self.web_server_port = int(config.get('serverport', 8080)) self.setup_logger() self.setup_hostname() if self.hostname.startswith('127.'): # use interface detection via routing table as last resort def catch_result(hostname): self.hostname = hostname self.setup_part2() d = defer.maybeDeferred(get_host_address) d.addCallback(catch_result) else: self.setup_part2()
def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._texture_dispatcher = EventDispatcher() self._object_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._texture_handler = TextureEditHandler( self, self._current_scene.children[0]) self._object_handler = TexturedObjectHandler( self, self._current_scene.children[1]) self._main_dispatcher.push_handlers(self._main_handler) self._texture_dispatcher.push_handlers(self._texture_handler) self._object_dispatcher.push_handlers(self._object_handler) glutSetWindow(self._window) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._main_dispatcher.handle_type('reshape')) self._menu_main = glutCreateMenu( self._main_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._main_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[0]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._texture_dispatcher.handle_type('reshape')) glutMouseFunc(self._texture_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._texture_dispatcher.handle_type('mouse_motion')) glutPassiveMotionFunc( self._texture_dispatcher.handle_type('mouse_motion')) self._menu_texture = glutCreateMenu( self._texture_dispatcher.handle_type('menu')) glutAddMenuEntry("Clear", self._texture_handler.get_menu_id('menu_clear')) glutAddMenuEntry("Quit", self._texture_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[1]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._object_dispatcher.handle_type('reshape')) glutMouseFunc(self._object_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._object_dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu( self._object_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._object_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1)
def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._main_dispatcher.push_handlers(self._main_handler) glutKeyboardFunc(self._main_dispatcher.handle_type("keyboard")) glutReshapeFunc(self._main_dispatcher.handle_type("reshape")) glutMouseFunc(self._main_dispatcher.handle_type("mouse_button")) glutMotionFunc(self._main_dispatcher.handle_type("mouse_motion")) glutPassiveMotionFunc(self._main_dispatcher.handle_type("mouse_motion")) self._menu_main = glutCreateMenu(self._main_dispatcher.handle_type("menu")) glutAddMenuEntry("Quit", self._main_handler.get_menu_id("menu_quit")) glutAddMenuEntry("Raytrace", self._main_handler.get_menu_id("menu_raytrace")) glutAddMenuEntry("Take Screenshot", self._main_handler.get_menu_id("menu_take_screenshot")) glutAddMenuEntry("Toggle Mesh Visibility", self._main_handler.get_menu_id("menu_visibility")) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1) glutDisplayFunc(self.render)
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('device_client_detection_completed', ) self.device = device self.device.bind(device_service_notified=self.service_notified) self.device_type = self.device.get_friendly_device_type() self.version = int(self.device.get_device_type_version()) self.icons = device.icons self.rendering_control = None self.connection_manager = None self.av_transport = None for service in self.device.get_services(): if service.get_type() in [ 'urn:schemas-upnp-org:service:RenderingControl:1', 'urn:schemas-upnp-org:service:RenderingControl:2' ]: self.rendering_control = RenderingControlClient(service) if service.get_type() in [ 'urn:schemas-upnp-org:service:ConnectionManager:1', 'urn:schemas-upnp-org:service:ConnectionManager:2' ]: self.connection_manager = ConnectionManagerClient(service) if service.get_type() in [ 'urn:schemas-upnp-org:service:AVTransport:1', 'urn:schemas-upnp-org:service:AVTransport:2' ]: self.av_transport = AVTransportClient(service) if service.detection_completed: self.service_notified(service) self.info(f'MediaRenderer {device.get_friendly_name()}') if self.rendering_control: self.info('RenderingControl available') ''' actions = self.rendering_control.service.get_actions() print actions for action in actions: print 'Action:', action for arg in actions[action].get_arguments_list(): print ' ', arg ''' # self.rendering_control.list_presets() # self.rendering_control.get_mute() # self.rendering_control.get_volume() # self.rendering_control.set_mute(desired_mute=1) else: self.warning( 'RenderingControl not available, device not implemented' ' properly according to the UPnP specification') return if self.connection_manager: self.info('ConnectionManager available') # self.connection_manager.get_protocol_info() else: self.warning( 'ConnectionManager not available, device not implemented' ' properly according to the UPnP specification') return if self.av_transport: self.info('AVTransport (optional) available')
class Application(object): ''' This class creates a window with an OpenGL context, and contains hooks for components to call to request updates as apart of the 'game loop.' :param size: is a tuple representing the default size of the window (width, height). :type size: 2-tuple of integers :param title: is the title text at the top of the window. :type title: str :param fullscreen: tells the window to start fullscren or not. :type fullscreen: boolean ''' def __init__(self, size=(DEFAULT_WIDTH, DEFAULT_HEIGHT), title='MegaMinerAI Bland Title Text', fullscreen=False): self.window = Window(width=size[0], height=size[1], caption=title, visible=True, fullscreen=fullscreen, resizable=True, style=Window.WINDOW_STYLE_DEFAULT, vsync=False, display=None, context=None, config=None) self.updates = [] # Set up the event dispatcher self.ed = EventDispatcher() self.ed.register_class_for_events(self) # Build the game loader self.loader = gameloader.GameLoader(self.ed) #Build the renderer self.renderer = renderer.Renderer() # Request updates self.request_update_on_draw(self.renderer.init_frame, 0) self.request_update_on_draw(self.renderer.draw_frame, 100) @event_handler def on_run_gamelog(self, data): print('handler') game_name = data['gameName'].lower() path = os.path.join(config.PLUGIN_DIR, game_name, 'main.py') self.game = imp.load_source(game_name, path) self.game.load(self, data) return True def request_update_on_draw(self, procedure, order=50): ''' This method tells the application that whenever a draw occurs for the application, that *procedure* should be called. :param order: specifies when *procedure* should be called. All procedures with the same *order* will execute in a semi-random fashion after the previous *order* and before the next *order* value in the update queue. In general, all procedures should be called sometime before the :mod:`renderer`'s update() function is called. Procedures will be called with *order* from least to greatest. :type order: float or integer :param procedure: should not expect any arguments or an exception will be thrown. :type procedure: function or class method Example gameloop:: >>> app.request_update_on_draw(game.update_objects) >>> app.request_update_on_draw(game.do_input_stuff, 10) >>> app.request_update_on_draw(game.render_frame, 100) >>> app.run() 'processing user input' 'updating game objects' 'rendering frame' ''' self.updates += [(order, procedure)] self.updates.sort(key=lambda x: x[0]) def _update(self, dt): ''' This function is called at the start of every loop in the 'game loop.' It calls all the procedures that requested updates in the game loop. *dt* is the time since the last call. ''' # Forces a redraw # Trigger everything self.window.clear() for order, procedure in self.updates: procedure() def run(self, glog_list=[]): ''' This method starts the 'game loop.' It is a blocking function so at this, point all modules should have requested updates from the application or another thread should have been started. ''' self.ed.dispatch_event('on_load_gamelog_file', glog_list) pyglet.clock.schedule(self._update) pyglet.app.run()
def setUp(self): self.dispatcher = EventDispatcher() self.listener = EventListener()
class Application(object): def __init__(self): """Initialize a new application by creating a logger object and calling the required initialization methods. """ self._init_log() self._init_config(['cg1_defaults.conf']) self._init_windows() self._init_callbacks() self._init_scene() def __del__(self): self._log.info(u"Exiting...") def _init_log(self): logging.basicConfig(level=logging.DEBUG) self._log = logging.getLogger("Application") self._log.info(u"Starting up...") def _init_config(self, default_config_files): self._log.info(u"Initializing configuration...") config_files = list(default_config_files) parser = OptionParser() parser.add_option('-c', '--conf', dest='config_file', default=None, help=u"config file to use (besides cg1_defaults.conf)") (options, args) = parser.parse_args() if options.config_file: config_files.append(options.config_file) self._log.info(u"Reading config files %s...", config_files) self._config = SafeConfigParser() self._config.read(config_files) def _init_windows(self): self._log.info(u"Initializing windows...") glutInit([]) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) glutInitWindowSize(self._config.getint('window', 'width'), self._config.getint('window', 'height')) glutInitWindowPosition(self._config.getint('window', 'x'), self._config.getint('window', 'y')) self._window = glutCreateWindow(self._config.get('window', 'title')) def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._dispatcher = EventDispatcher() self._defaultHandler = DefaultHandler(self) self._dispatcher.push_handlers(self._defaultHandler) glutKeyboardFunc(self._dispatcher.handle_type('keyboard')) glutReshapeFunc(self._dispatcher.handle_type('reshape')) glutMouseFunc(self._dispatcher.handle_type('mouse_button')) glutMotionFunc(self._dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu(self._dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._defaultHandler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) self._menu_scene = glutCreateMenu(self._dispatcher.handle_type('menu')) glutSetMenu(self._menu_main) glutAddSubMenu("Scene", self._menu_scene) glutTimerFunc(1, self.update, 1) glutDisplayFunc(self.render) def _init_scene(self): self._current_scene = RobotScene(self) if self._current_scene: self._current_scene.init() self._defaultHandler._selected_node = self._current_scene glutSetMenu(self._menu_scene) def _add_node_menu_entry(node, prefix): glutAddMenuEntry(prefix + node.name + "", self._defaultHandler.get_menu_id('menu_scene_select_%u' % hash(node), [node, ])) return ([prefix + node.name + " / "], {}) self._current_scene.map(_add_node_menu_entry, [""], {}, True) def run(self): self._log.info(u"Running...") self._time = glutGet(GLUT_ELAPSED_TIME) glutMainLoop() def stop(self): self._log.info(u"Stopping...") sys.exit() def update(self, enabled): # update the current time time = glutGet(GLUT_ELAPSED_TIME) d_time = time - self._time self._time = time if enabled == 1: #self._log.debug(u"%u ms elapsed", d_time) if self._current_scene: self._current_scene.update(d_time) glutPostRedisplay() glutTimerFunc(int(1000/self._config.getint('general', 'framerate')) - (glutGet(GLUT_ELAPSED_TIME) - time), self.update, 1) def render(self): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) glLoadIdentity() gluLookAt(0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) if self._current_scene: self._current_scene.render() glutSwapBuffers()
def setUp(self): self.dispatcher = EventDispatcher()
def test_globalPropagation(self): dispatcher = EventDispatcher(True) self._registerListenerForPropagationTest(dispatcher) dispatcher.dispatch('test.propa', TestEvent('propa-')) self.assertEqual('propa-propa-', self.listener.testStr)
class LanderApp: def __init__(self, screen_w, screen_h): # # Initialize Screenworld # # pygame = Screenworld pygame.init() # DEBUG SCREEN_INFO print("INFO") print(pygame.display.Info()) print("MODES") print(pygame.display.list_modes(depth=0)) print("FULLSCREEN_MODES") print(pygame.display.list_modes(depth=0, flags=pygame.FULLSCREEN)) # set display mode and calculate _screen_size if screen_w == 0 and screen_h == 0: self._screen_size = (pygame.display.Info().current_w, pygame.display.Info().current_h) else: self._screen_size = (screen_w, screen_h) #self._screen = pygame.display.set_mode(self._screen_size, flags=pygame.FULLSCREEN) self._screen = pygame.display.set_mode(self._screen_size) # Frame rate self._fps = 60.0 # Number of physics steps per screen frame self._physics_steps_per_frame = 1 # Time steps self._dt = 1.0 / self._fps / self._physics_steps_per_frame #self._dt = 1. / self._fps # pygame frame clock self._clock = pygame.time.Clock() # # Initialize Game World # # Space = GameWorld self._space = pymunk.Space() # Gravity in m / s^2 self._space.gravity = (0.0, -9.81) # Phyicsworld damoing in 1-x % self._space.damping = 0.8 ## sleep time theshold #self.space.sleep_time_threshold = 0.3 # zoomfactor from physicsworld to pixelworld. 1 = show 100% of space.width on screen, 2=50% self._zoom = 2 # Physicsworld size in m self._space_size = (512, 320) # Camera POV in space in m from left,down self._space_pov = (256, 160) # Scale factor from space to screen. 1 m in space = <scale> pixel in screen #self._scale = Vec2d(self._screen_size).get_length() / Vec2d(self._space_size).get_length() self._scale = self._screen_size[0] / self._space_size[0] #print("SCALE: {0:f}".format(self._scale)) # viewrect of current cam in space self._space_viewrect = (0, 0, 0, 0) self._calc_space_viewrect() # # Initialize Game Options # # Drawing Option. Setting _is_is_drawing to False enables headless mode self._is_drawing = True # Use pymunk debug draw. Note: I can't use it because I implement a scroller, scaler and zoom # So I use my own drawing routines in the Entity-Subclasses #self._draw_options = pymunk.pygame_util.DrawOptions(self._screen) # Execution control self._is_running = True self._is_paused = True self._show_menu = True # # Create Game Entities # # GUI self._font = pygame.font.SysFont("DejaVuSans", 24) self._text = self._font.render("Touch the screen.", True, (255, 255, 255, 255)) self._text_w, self._text_h = self._text.get_size() self._add_hud() # Menu self.menu = Menu() # Static Scenery self.scenery = Scenery(self) # Player #self.player = Player(self._space, Vec2d(self._space_size)/2) self.player = Player(self, Vec2d(256, 160)) # Add Event Dispatcher for user input self.ev = EventDispatcher() def run(self): """ The main loop of the game. :return: None """ # Main loop while self._is_running: self._process_events() self._clear_screen() if not self._is_paused: ## Progress time forward #self._space.step(self._dt) for x in range(self._physics_steps_per_frame): self._space.step(self._dt) self.scenery.update() self.player.update() self._update_hud() # Delay fixed time between frames self._clock.tick(self._fps) #pygame.display.set_caption("fps: " + str(self._clock.get_fps())) self._draw_objects() ### All done, lets flip the display pygame.display.flip() def _process_events(self): """ Handle game and events like keyboard input. Call once per frame only. :return: None """ # Handle menu if self._show_menu: menu_choice = self.menu.update(self.menu, self) if menu_choice == "Play": self._show_menu = False self._is_paused = False #if menu_choice == "Options": # self.option_menu = if not self._is_paused: for event in self.ev.get(): if event["type"] == self.ev.BTNDN: self.player.input(event["idx"], 1) elif event["type"] == self.ev.BTNUP: self.player.input(event["idx"], 0) elif event["type"] == self.ev.QUIT or event[ "type"] == self.ev.ESCAPE: self._is_running = False elif event["type"] == self.ev.DRAW: self._is_drawing = not self._is_drawing elif event["type"] == self.ev.ZOOMINC: self.set_zoom(self.get_zoom() * 1.05) elif event["type"] == self.ev.ZOOMDEC: self.set_zoom(self.get_zoom() * 0.95) # self._text = self._font.render("Finder DOWN: {0:d}, {1:f}, {2:f}".format(f, x, y), True, (255, 255, 255, 255)) # self._text = self._font.render("Finder DOWN: {0:d}, {1:d}".format(pygame.display.Info().current_w, pygame.display.Info().current_h), True, (255, 255, 255, 255)) def _clear_screen(self): """ Clears the screen. :return: None """ self._screen.fill((0, 0, 0, 255)) def _draw_objects(self): """ Draw the objects. :return: None """ if self._show_menu: self.menu.draw(self._screen) elif not self._is_paused: ### Draw space #self._space.debug_draw(self._draw_options) self.scenery.draw(self) self.player.draw(self) def _add_hud(self): pass def _update_hud(self): #fps_str = "fps: " + str(self._clock.get_fps()) self._screen.blit(self._text, (self._screen_size[0] / 2 - self._text_w / 2, self._screen_size[1] / 2 - self._text_h / 2)) def to_screen(self, p): z = self._scale * self._zoom fx = 0.5 * self._space_size[0] / self._zoom fy = 0.5 * self._space_size[1] / self._zoom #x = (p[0] - self._space_pov[0]) * z + self._screen_size[0]/2 x = (p[0] - self._space_pov[0] + fx) * z #y = (p[1] - self._space_pov[1]) * z + self._screen_size[1]/2 y = (p[1] - self._space_pov[1] + fy) * z #print("s:{0:f}, z:{1:f}, p0:{2:f}, p1:{3:f}, wp0:{4:f}, wp1:{5:f}".format(world._scale, world._zoom, p[0], p[1], world._space_pov[0], world._space_pov[1])) return int(x), int(self._screen_size[1] - y) #def to_space(self): # pass #def get_mouse_in_space(self, surface): # pass # """Get position of the mouse pointer in pymunk coordinates. # p = pygame.mouse.get_pos() # return from_pygame(p, surface)""" def set_space_pov(self, pos): self._space_pov = pos self._calc_space_viewrect() def get__space_pov(self): return self._space_pov def _calc_space_viewrect(self): w = self._space_size[0] / self._zoom h = self._space_size[1] / self._zoom x = self._space_pov[0] - 0.5 * w y = self._space_pov[1] - 0.5 * h self._space_viewrect = (x, y, w, h) def get_space_viewrect(self): return self._space_viewrect def get_screen_pov(self): return self.to_screen(self._space_pov) def set_zoom(self, zoom): self._zoom = zoom self._calc_space_viewrect() def get_zoom(self): return self._zoom def set_scale(self, scale): self._scale = scale def get_scale(self): return self._scale
def __init__(self, screen_w, screen_h): # # Initialize Screenworld # # pygame = Screenworld pygame.init() # DEBUG SCREEN_INFO print("INFO") print(pygame.display.Info()) print("MODES") print(pygame.display.list_modes(depth=0)) print("FULLSCREEN_MODES") print(pygame.display.list_modes(depth=0, flags=pygame.FULLSCREEN)) # set display mode and calculate _screen_size if screen_w == 0 and screen_h == 0: self._screen_size = (pygame.display.Info().current_w, pygame.display.Info().current_h) else: self._screen_size = (screen_w, screen_h) #self._screen = pygame.display.set_mode(self._screen_size, flags=pygame.FULLSCREEN) self._screen = pygame.display.set_mode(self._screen_size) # Frame rate self._fps = 60.0 # Number of physics steps per screen frame self._physics_steps_per_frame = 1 # Time steps self._dt = 1.0 / self._fps / self._physics_steps_per_frame #self._dt = 1. / self._fps # pygame frame clock self._clock = pygame.time.Clock() # # Initialize Game World # # Space = GameWorld self._space = pymunk.Space() # Gravity in m / s^2 self._space.gravity = (0.0, -9.81) # Phyicsworld damoing in 1-x % self._space.damping = 0.8 ## sleep time theshold #self.space.sleep_time_threshold = 0.3 # zoomfactor from physicsworld to pixelworld. 1 = show 100% of space.width on screen, 2=50% self._zoom = 2 # Physicsworld size in m self._space_size = (512, 320) # Camera POV in space in m from left,down self._space_pov = (256, 160) # Scale factor from space to screen. 1 m in space = <scale> pixel in screen #self._scale = Vec2d(self._screen_size).get_length() / Vec2d(self._space_size).get_length() self._scale = self._screen_size[0] / self._space_size[0] #print("SCALE: {0:f}".format(self._scale)) # viewrect of current cam in space self._space_viewrect = (0, 0, 0, 0) self._calc_space_viewrect() # # Initialize Game Options # # Drawing Option. Setting _is_is_drawing to False enables headless mode self._is_drawing = True # Use pymunk debug draw. Note: I can't use it because I implement a scroller, scaler and zoom # So I use my own drawing routines in the Entity-Subclasses #self._draw_options = pymunk.pygame_util.DrawOptions(self._screen) # Execution control self._is_running = True self._is_paused = True self._show_menu = True # # Create Game Entities # # GUI self._font = pygame.font.SysFont("DejaVuSans", 24) self._text = self._font.render("Touch the screen.", True, (255, 255, 255, 255)) self._text_w, self._text_h = self._text.get_size() self._add_hud() # Menu self.menu = Menu() # Static Scenery self.scenery = Scenery(self) # Player #self.player = Player(self._space, Vec2d(self._space_size)/2) self.player = Player(self, Vec2d(256, 160)) # Add Event Dispatcher for user input self.ev = EventDispatcher()
class EventDispatcherTest(unittest.TestCase): '''Tests the event dispatcher''' def setUp(self): self.dispatcher = EventDispatcher() self.listener = EventListener() def test_dispatch(self): self.dispatcher.listen('test.dispatch', self.listener.onDispatch) self.dispatcher.dispatch('test.dispatch', TestEvent('dispatch')) self.assertEqual('dispatch', self.listener.testStr) def test_priority(self): self.dispatcher.listen('test.priority', self.listener.listenPriority('d'), 1) self.dispatcher.listen('test.priority', self.listener.listenPriority('a'), -2) self.dispatcher.listen('test.priority', self.listener.listenPriority('c')) self.dispatcher.listen('test.priority', self.listener.listenPriority('b'), -1) self.dispatcher.dispatch('test.priority') self.assertEqual('abcd', self.listener.testStr) def test_detach(self): self.dispatcher.listen('test.detach', self.listener.onDispatch) listener_id = self.dispatcher.listen('test.detach', self.listener.onDispatch) self.dispatcher.detach(listener_id) self.dispatcher.dispatch('test.detach', TestEvent('detach')) self.assertEqual('detach', self.listener.testStr) def test_dispatchWhenNoneListener(self): self.dispatcher.dispatch('alone') def test_getParent(self): self.assertEqual('test.parent', self.dispatcher.getParent('test.parent.child')) self.assertEqual(None, self.dispatcher.getParent('noparent')) with self.assertRaises(AssertionError): self.dispatcher.getParent('test.parent .childish') def test_propagation(self): self._registerListenerForPropagationTest(self.dispatcher) self.dispatcher.dispatch('test.propa', TestEvent('propa-'), True) self.assertEqual('propa-propa-', self.listener.testStr) def test_globalPropagation(self): dispatcher = EventDispatcher(True) self._registerListenerForPropagationTest(dispatcher) dispatcher.dispatch('test.propa', TestEvent('propa-')) self.assertEqual('propa-propa-', self.listener.testStr) def test_propagationOverriding(self): dispatcher = EventDispatcher(True) self._registerListenerForPropagationTest(dispatcher) dispatcher.dispatch('test.propa', TestEvent('propa-'), False) self.assertEqual('propa-', self.listener.testStr) def test_decorator(self): @self.dispatcher.on('test.decorator') def listener(e): self.listener.onDispatch(e) self.dispatcher.dispatch('test.decorator', TestEvent('decorator')) self.assertEqual('decorator', self.listener.testStr) def test_listenAll(self): self.dispatcher.listen('test.a', self.listener.onDispatch) self.dispatcher.listen('all', self.listener.onDispatch) self.dispatcher.dispatch('test.a', TestEvent('a')) self.dispatcher.dispatch('test.b', TestEvent('b')) self.dispatcher.dispatch('test.c', TestEvent('c')) self.dispatcher.dispatch('test.d', TestEvent('d')) self.dispatcher.dispatch('test.e', TestEvent('e')) self.assertEqual('aabcde', self.listener.testStr) def _registerListenerForPropagationTest(self, dispatcher): dispatcher.listen('test', self.listener.onDispatch) dispatcher.listen('test.propa', self.listener.onDispatch)
def test_propagationOverriding(self): dispatcher = EventDispatcher(True) self._registerListenerForPropagationTest(dispatcher) dispatcher.dispatch('test.propa', TestEvent('propa-'), False) self.assertEqual('propa-', self.listener.testStr)
def __init__(self, *args, **kwargs): EventDispatcher.__init__(self) log.LogAble.__init__(self)
class Application(object): ''' This class creates a window with an OpenGL context, and contains hooks for components to call to request updates as apart of the 'game loop.' :param size: is a tuple representing the default size of the window (width, height). :type size: 2-tuple of integers :param title: is the title text at the top of the window. :type title: str :param fullscreen: tells the window to start fullscren or not. :type fullscreen: boolean ''' def __init__(self, size=(DEFAULT_WIDTH, DEFAULT_HEIGHT), title='MegaMinerAI Bland Title Text', fullscreen=False): self.window = Window(width=size[0], height=size[1], caption=title, visible=True, fullscreen=fullscreen, resizable=True, style=Window.WINDOW_STYLE_DEFAULT, vsync=False, display=None, context=None, config=None) self.updates = [] # Set up the event dispatcher self.ed = EventDispatcher() self.ed.register_class_for_events(self) # Build the game loader self.loader = gameloader.GameLoader(self.ed) #Build the renderer self.renderer = renderer.Renderer() # Request updates self.request_update_on_draw(self.renderer.init_frame, 0) self.request_update_on_draw(self.renderer.draw_frame, 100) @event_handler def on_run_gamelog(self, data): print('handler') game_name = data['gameName'].lower() path = os.path.join(config.setting['plugin directory'], game_name, 'main.py') self.game = imp.load_source(game_name, path) self.game.load(self, data) return True def request_update_on_draw(self, procedure, order=50): ''' This method tells the application that whenever a draw occurs for the application, that *procedure* should be called. :param order: specifies when *procedure* should be called. All procedures with the same *order* will execute in a semi-random fashion after the previous *order* and before the next *order* value in the update queue. In general, all procedures should be called sometime before the :mod:`renderer`'s update() function is called. Procedures will be called with *order* from least to greatest. :type order: float or integer :param procedure: should not expect any arguments or an exception will be thrown. :type procedure: function or class method Example gameloop:: >>> app.request_update_on_draw(game.update_objects) >>> app.request_update_on_draw(game.do_input_stuff, 10) >>> app.request_update_on_draw(game.render_frame, 100) >>> app.run() 'processing user input' 'updating game objects' 'rendering frame' ''' self.updates += [(order, procedure)] self.updates.sort(key=lambda x: x[0]) def _update(self, dt): ''' This function is called at the start of every loop in the 'game loop.' It calls all the procedures that requested updates in the game loop. *dt* is the time since the last call. ''' # Forces a redraw # Trigger everything self.window.clear() for order, procedure in self.updates: procedure() def run(self, glog_list=[]): ''' This method starts the 'game loop.' It is a blocking function so at this, point all modules should have requested updates from the application or another thread should have been started. ''' self.ed.dispatch_event('on_load_gamelog_file', glog_list) pyglet.clock.schedule(self._update) pyglet.app.run()
class Application(object): def __init__(self): """Initialize a new application by creating a logger object and calling the required initialization methods. """ self._init_log() self._init_config(['cg1_defaults.conf']) self._init_windows() self._init_scene() self._init_callbacks() def __del__(self): self._log.info(u"Exiting...") def _init_log(self): logging.basicConfig(level=logging.DEBUG) self._log = logging.getLogger("Application") self._log.info(u"Starting up...") def _init_config(self, default_config_files): self._log.info(u"Initializing configuration...") config_files = list(default_config_files) parser = OptionParser() parser.add_option('-c', '--conf', dest='config_file', default=None, help=u"config file to use (besides cg1_defaults.conf)") (options, args) = parser.parse_args() if options.config_file: config_files.append(options.config_file) self._log.info(u"Reading config files %s...", config_files) self._config = SafeConfigParser() self._config.read(config_files) self._current_texture = Image.open(self._config.get('general', 'start_texture')) #sys.setrecursionlimit(4000) #self._log.info(u"Recursion limit is now %d." % sys.getrecursionlimit()) def _init_windows(self): self._log.info(u"Initializing windows...") glutInit([]) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) window_width = self._config.getint('window', 'width') window_height = self._config.getint('window', 'height') glutInitWindowSize(window_width, window_height) glutInitWindowPosition(self._config.getint('window', 'x'), self._config.getint('window', 'y')) self._window = glutCreateWindow(self._config.get('window', 'title')) self._subwindows = [] gap = self._config.getint('window', 'gap') self._subwindows.append(glutCreateSubWindow(self._window, gap, gap, (window_width-3*gap) / 2, (window_height-2*gap))) self._subwindows.append(glutCreateSubWindow(self._window, (window_width-3*gap) / 2 + 2*gap, gap, (window_width-3*gap) / 2, (window_height-2*gap))) glutSetWindow(self._window) def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._texture_dispatcher = EventDispatcher() self._object_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._texture_handler = TextureEditHandler(self, self._current_scene.children[0]) self._object_handler = TexturedObjectHandler(self, self._current_scene.children[1]) self._main_dispatcher.push_handlers(self._main_handler) self._texture_dispatcher.push_handlers(self._texture_handler) self._object_dispatcher.push_handlers(self._object_handler) glutSetWindow(self._window) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._main_dispatcher.handle_type('reshape')) self._menu_main = glutCreateMenu(self._main_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._main_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[0]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._texture_dispatcher.handle_type('reshape')) glutMouseFunc(self._texture_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._texture_dispatcher.handle_type('mouse_motion')) glutPassiveMotionFunc(self._texture_dispatcher.handle_type('mouse_motion')) self._menu_texture = glutCreateMenu(self._texture_dispatcher.handle_type('menu')) glutAddMenuEntry("Clear", self._texture_handler.get_menu_id('menu_clear')) glutAddMenuEntry("Quit", self._texture_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[1]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._object_dispatcher.handle_type('reshape')) glutMouseFunc(self._object_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._object_dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu(self._object_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._object_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1) def _init_scene(self): self._current_scene = InteractivelyTexturedScene(self) if self._current_scene: self._current_scene.init() glutSetWindow(self._window) glutDisplayFunc(self._current_scene.render) glutSetWindow(self._subwindows[0]) glutDisplayFunc(self._current_scene.children[0].render) glutSetWindow(self._subwindows[1]) glutDisplayFunc(self._current_scene.children[1].render) def run(self): self._log.info(u"Running...") self._time = glutGet(GLUT_ELAPSED_TIME) glutMainLoop() def stop(self): self._log.info(u"Stopping...") sys.exit() def update(self, enabled): # update the current time time = glutGet(GLUT_ELAPSED_TIME) d_time = time - self._time self._time = time if enabled == 1: #self._log.debug(u"%u ms elapsed", d_time) if self._current_scene: self._current_scene.update(d_time) glutTimerFunc(int(1000/self._config.getint('general', 'framerate')) - (glutGet(GLUT_ELAPSED_TIME) - time), self.update, 1)
class Application(object): def __init__(self): """Initialize a new application by creating a logger object and calling the required initialization methods. """ self._init_log() self._init_config(["cg1_defaults.conf"]) self._init_windows() self._init_callbacks() self._init_scene() def __del__(self): self._log.info(u"Exiting...") def _init_log(self): logging.basicConfig(level=logging.DEBUG) self._log = logging.getLogger("Application") self._log.info(u"Starting up...") def _init_config(self, default_config_files): self._log.info(u"Initializing configuration...") config_files = list(default_config_files) parser = OptionParser() parser.add_option( "-c", "--conf", dest="config_file", default=None, help=u"config file to use (besides cg1_defaults.conf)" ) (options, args) = parser.parse_args() if options.config_file: config_files.append(options.config_file) self._log.info(u"Reading config files %s...", config_files) self._config = SafeConfigParser() self._config.read(config_files) sys.setrecursionlimit(4000) self._log.info(u"Recursion limit is now %d." % sys.getrecursionlimit()) def _init_windows(self): self._log.info(u"Initializing windows...") glutInit([]) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) glutInitWindowSize(self._config.getint("window", "width"), self._config.getint("window", "height")) glutInitWindowPosition(self._config.getint("window", "x"), self._config.getint("window", "y")) self._window = glutCreateWindow(self._config.get("window", "title")) def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._main_dispatcher.push_handlers(self._main_handler) glutKeyboardFunc(self._main_dispatcher.handle_type("keyboard")) glutReshapeFunc(self._main_dispatcher.handle_type("reshape")) glutMouseFunc(self._main_dispatcher.handle_type("mouse_button")) glutMotionFunc(self._main_dispatcher.handle_type("mouse_motion")) glutPassiveMotionFunc(self._main_dispatcher.handle_type("mouse_motion")) self._menu_main = glutCreateMenu(self._main_dispatcher.handle_type("menu")) glutAddMenuEntry("Quit", self._main_handler.get_menu_id("menu_quit")) glutAddMenuEntry("Raytrace", self._main_handler.get_menu_id("menu_raytrace")) glutAddMenuEntry("Take Screenshot", self._main_handler.get_menu_id("menu_take_screenshot")) glutAddMenuEntry("Toggle Mesh Visibility", self._main_handler.get_menu_id("menu_visibility")) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1) glutDisplayFunc(self.render) def _init_scene(self): self._current_scene = RaytraceScene(self) if self._current_scene: self._current_scene.init() self._main_handler._selected_node = self._current_scene.mesh def run(self): self._log.info(u"Running...") OpenGL.ERROR_CHECKING = False self._time = glutGet(GLUT_ELAPSED_TIME) glutMainLoop() def stop(self): self._log.info(u"Stopping...") sys.exit() def update(self, enabled): # update the current time time = glutGet(GLUT_ELAPSED_TIME) d_time = time - self._time self._time = time if enabled == 1: # self._log.debug(u"%u ms elapsed", d_time) if self._current_scene: self._current_scene.update(d_time) glutPostRedisplay() glutTimerFunc( int(1000 / self._config.getint("general", "framerate")) - (glutGet(GLUT_ELAPSED_TIME) - time), self.update, 1, ) def render(self): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) glLoadIdentity() gluLookAt(0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) if self._current_scene: self._current_scene.render() glutSwapBuffers()
class Application(object): def __init__(self): """Initialize a new application by creating a logger object and calling the required initialization methods. """ self._init_log() self._init_config(['cg1_defaults.conf']) self._init_windows() self._init_callbacks() self._init_scene() def __del__(self): self._log.info(u"Exiting...") def _init_log(self): logging.basicConfig(level=logging.DEBUG) self._log = logging.getLogger("Application") self._log.info(u"Starting up...") def _init_config(self, default_config_files): self._log.info(u"Initializing configuration...") config_files = list(default_config_files) parser = OptionParser() parser.add_option( '-c', '--conf', dest='config_file', default=None, help=u"config file to use (besides cg1_defaults.conf)") (options, args) = parser.parse_args() if options.config_file: config_files.append(options.config_file) self._log.info(u"Reading config files %s...", config_files) self._config = SafeConfigParser() self._config.read(config_files) def _init_windows(self): self._log.info(u"Initializing windows...") glutInit([]) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) glutInitWindowSize(self._config.getint('window', 'width'), self._config.getint('window', 'height')) glutInitWindowPosition(self._config.getint('window', 'x'), self._config.getint('window', 'y')) self._window = glutCreateWindow(self._config.get('window', 'title')) def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._dispatcher = EventDispatcher() self._defaultHandler = DefaultHandler(self) self._dispatcher.push_handlers(self._defaultHandler) glutKeyboardFunc(self._dispatcher.handle_type('keyboard')) glutReshapeFunc(self._dispatcher.handle_type('reshape')) glutMouseFunc(self._dispatcher.handle_type('mouse_button')) glutMotionFunc(self._dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu(self._dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._defaultHandler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) self._menu_scene = glutCreateMenu(self._dispatcher.handle_type('menu')) glutSetMenu(self._menu_main) glutAddSubMenu("Scene", self._menu_scene) glutTimerFunc(1, self.update, 1) glutDisplayFunc(self.render) def _init_scene(self): self._current_scene = RobotScene(self) if self._current_scene: self._current_scene.init() self._defaultHandler._selected_node = self._current_scene glutSetMenu(self._menu_scene) def _add_node_menu_entry(node, prefix): glutAddMenuEntry( prefix + node.name + "", self._defaultHandler.get_menu_id( 'menu_scene_select_%u' % hash(node), [ node, ])) return ([prefix + node.name + " / "], {}) self._current_scene.map(_add_node_menu_entry, [""], {}, True) def run(self): self._log.info(u"Running...") self._time = glutGet(GLUT_ELAPSED_TIME) glutMainLoop() def stop(self): self._log.info(u"Stopping...") sys.exit() def update(self, enabled): # update the current time time = glutGet(GLUT_ELAPSED_TIME) d_time = time - self._time self._time = time if enabled == 1: #self._log.debug(u"%u ms elapsed", d_time) if self._current_scene: self._current_scene.update(d_time) glutPostRedisplay() glutTimerFunc( int(1000 / self._config.getint('general', 'framerate')) - (glutGet(GLUT_ELAPSED_TIME) - time), self.update, 1) def render(self): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) glLoadIdentity() gluLookAt(0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) if self._current_scene: self._current_scene.render() glutSwapBuffers()
def __init__(self, *args, **kwargs): EventDispatcher.__init__(self) self.register_event('control_client_command_received')
import config from eventdispatcher import EventDispatcher from eventreader import EventReader def block_to_dict(b): return { "full_text": str(b.full_text()), "markup": "pango", "name": type(b).__name__, "instance": str(id(b)) } if __name__ == "__main__": event_dispatcher = EventDispatcher(EventReader()) print(json.dumps({"version": 1, "click_events": True})) print("[") while True: for block in config.blocks: block.update() event_dispatcher.dispatch(config.blocks) serializable_block_content = list(map(block_to_dict, config.blocks)) print(json.dumps(serializable_block_content) + ",") sys.stdout.flush() time.sleep(0.25)
class Application(object): def __init__(self): """Initialize a new application by creating a logger object and calling the required initialization methods. """ self._init_log() self._init_config(['cg1_defaults.conf']) self._init_windows() self._init_scene() self._init_callbacks() def __del__(self): self._log.info(u"Exiting...") def _init_log(self): logging.basicConfig(level=logging.DEBUG) self._log = logging.getLogger("Application") self._log.info(u"Starting up...") def _init_config(self, default_config_files): self._log.info(u"Initializing configuration...") config_files = list(default_config_files) parser = OptionParser() parser.add_option( '-c', '--conf', dest='config_file', default=None, help=u"config file to use (besides cg1_defaults.conf)") (options, args) = parser.parse_args() if options.config_file: config_files.append(options.config_file) self._log.info(u"Reading config files %s...", config_files) self._config = SafeConfigParser() self._config.read(config_files) self._current_texture = Image.open( self._config.get('general', 'start_texture')) #sys.setrecursionlimit(4000) #self._log.info(u"Recursion limit is now %d." % sys.getrecursionlimit()) def _init_windows(self): self._log.info(u"Initializing windows...") glutInit([]) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) window_width = self._config.getint('window', 'width') window_height = self._config.getint('window', 'height') glutInitWindowSize(window_width, window_height) glutInitWindowPosition(self._config.getint('window', 'x'), self._config.getint('window', 'y')) self._window = glutCreateWindow(self._config.get('window', 'title')) self._subwindows = [] gap = self._config.getint('window', 'gap') self._subwindows.append( glutCreateSubWindow(self._window, gap, gap, (window_width - 3 * gap) / 2, (window_height - 2 * gap))) self._subwindows.append( glutCreateSubWindow(self._window, (window_width - 3 * gap) / 2 + 2 * gap, gap, (window_width - 3 * gap) / 2, (window_height - 2 * gap))) glutSetWindow(self._window) def _init_callbacks(self): self._log.info(u"Initializing callbacks...") self._main_dispatcher = EventDispatcher() self._texture_dispatcher = EventDispatcher() self._object_dispatcher = EventDispatcher() self._main_handler = DefaultHandler(self) self._texture_handler = TextureEditHandler( self, self._current_scene.children[0]) self._object_handler = TexturedObjectHandler( self, self._current_scene.children[1]) self._main_dispatcher.push_handlers(self._main_handler) self._texture_dispatcher.push_handlers(self._texture_handler) self._object_dispatcher.push_handlers(self._object_handler) glutSetWindow(self._window) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._main_dispatcher.handle_type('reshape')) self._menu_main = glutCreateMenu( self._main_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._main_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[0]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._texture_dispatcher.handle_type('reshape')) glutMouseFunc(self._texture_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._texture_dispatcher.handle_type('mouse_motion')) glutPassiveMotionFunc( self._texture_dispatcher.handle_type('mouse_motion')) self._menu_texture = glutCreateMenu( self._texture_dispatcher.handle_type('menu')) glutAddMenuEntry("Clear", self._texture_handler.get_menu_id('menu_clear')) glutAddMenuEntry("Quit", self._texture_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutSetWindow(self._subwindows[1]) glutKeyboardFunc(self._main_dispatcher.handle_type('keyboard')) glutReshapeFunc(self._object_dispatcher.handle_type('reshape')) glutMouseFunc(self._object_dispatcher.handle_type('mouse_button')) glutMotionFunc(self._object_dispatcher.handle_type('mouse_motion')) self._menu_main = glutCreateMenu( self._object_dispatcher.handle_type('menu')) glutAddMenuEntry("Quit", self._object_handler.get_menu_id('menu_quit')) glutAttachMenu(GLUT_RIGHT_BUTTON) glutTimerFunc(1, self.update, 1) def _init_scene(self): self._current_scene = InteractivelyTexturedScene(self) if self._current_scene: self._current_scene.init() glutSetWindow(self._window) glutDisplayFunc(self._current_scene.render) glutSetWindow(self._subwindows[0]) glutDisplayFunc(self._current_scene.children[0].render) glutSetWindow(self._subwindows[1]) glutDisplayFunc(self._current_scene.children[1].render) def run(self): self._log.info(u"Running...") self._time = glutGet(GLUT_ELAPSED_TIME) glutMainLoop() def stop(self): self._log.info(u"Stopping...") sys.exit() def update(self, enabled): # update the current time time = glutGet(GLUT_ELAPSED_TIME) d_time = time - self._time self._time = time if enabled == 1: #self._log.debug(u"%u ms elapsed", d_time) if self._current_scene: self._current_scene.update(d_time) glutTimerFunc( int(1000 / self._config.getint('general', 'framerate')) - (glutGet(GLUT_ELAPSED_TIME) - time), self.update, 1)
class TestCase(unittest.TestCase): def setUp(self): self.dispatcher = EventDispatcher() def tearDown(self): return def testInitialState(self): self.assertEqual({}, self.dispatcher.getListeners()) self.assertFalse(self.dispatcher.hasListener(PRE_FOO)) self.assertFalse(self.dispatcher.hasListener(POST_FOO)) def testAddListener(self): listener = TestEventListener() self.dispatcher.addListener(PRE_FOO, listener, 'preFoo') self.dispatcher.addListener(POST_FOO, listener, 'postFoo') self.dispatcher.hasListener(PRE_FOO) self.dispatcher.hasListener(POST_FOO) def testDispatch(self): listener = TestEventListener() self.dispatcher.addListener(PRE_FOO, listener, 'preFoo') self.dispatcher.addListener(POST_FOO, listener, 'postFoo') event = Event() self.dispatcher.dispatch(eventName=PRE_FOO, event=event) self.assertTrue(listener.preFooFired)