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._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, 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_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)
