def wire_up_screen_controls(self):
'''
Set up all of the screen controls, so that the user can zoom in/out
and select which layers they wish to view.
'''
screen_width = self.sky_renderer.render_state.screen_width
screen_height = self.sky_renderer.render_state.screen_height
self.pref_buttons = PreferencesButton(self.view)
self.zoom_button = ZoomButton(self.view)
position_y = ((screen_height - 336) / 2) + 1
self.pref_buttons.setGeometry(QtCore.QRect(1, position_y, 55, 336))
position_x = ((screen_width - 221) / 2) + 1
position_y = ((screen_height - 31) * 9/10) + 1
self.zoom_button.setGeometry(QtCore.QRect(position_x, position_y, 221, 31))
self.pref_buttons_fader = WidgetFader(self.pref_buttons, 2500)
self.zoom_button_fader = WidgetFader(self.zoom_button, 2500)
self.map_mover = MapMover(self.model, self.controller, self.shared_prefs,
screen_height)
self.DRZ_detector = DRZDetector(self.map_mover, self.show_menus_func)
class SkyPython(QMainWindow):
'''
The central widget and heart of the application.
Performs all of the initialization of components
and contains updates and event handling.
'''
class RendererModelUpdateClosure():
'''
A runnable class that updates the state of the
model after a change has occurred. Is placed
on the event queue.
'''
def run(self):
pointing = self.model.get_pointing()
direction_x = pointing.gc_line_of_sight.x
direction_y = pointing.gc_line_of_sight.y
direction_z = pointing.gc_line_of_sight.z
up_x = pointing.gc_perpendicular.x
up_y = pointing.gc_perpendicular.y
up_z = pointing.gc_perpendicular.z
self.renderer_controller.queue_set_view_orientation(direction_x, direction_y, direction_z, \
up_x, up_y, up_z)
acceleration = self.model.acceleration
self.renderer_controller.queue_text_angle(math.atan2(-acceleration.x, -acceleration.y))
self.renderer_controller.queue_viewer_up_direction(self.model.get_zenith().copy())
field_of_view = self.model.field_of_view
self.renderer_controller.queue_field_of_view(field_of_view)
def __init__(self, m_model, controller):
'''
constructor
'''
self.model = m_model
self.renderer_controller = controller
layer_manager = None
model = None
controller = None
sky_renderer = None
renderer_controller = None
def pref_change(self, prefs, manager, layers, event):
'''
If a preference button has been pressed, change
the preferences according to the selection..
'''
for layer in layers:
prefs.PREFERENCES[layer] = not prefs.PREFERENCES[layer]
manager.on_shared_preference_change(prefs, layer)
return True
def eventFilter(self, source, event):
'''
Check if the event is a button press in the UI, if not
then check if it was a mouse or key press in DRZ_detector.
'''
pref_pressed = self.pref_buttons.checkForButtonPress(source, event)
zoom_pressed = self.zoom_button.checkForButtonPress(source, event, self.controller)
if pref_pressed or zoom_pressed:
self.show_menus_func()
if pref_pressed:
self.pref_change(self.shared_prefs, self.layer_manager,
pref_pressed, event)
else:
update = self.DRZ_detector.on_motion_event(event)
if pref_pressed or zoom_pressed or update:
self.update_rendering()
return True
return QMainWindow.eventFilter(self, source, event)
def initialize_model_view_controller(self):
'''
Set up the graphics view/scene and set the GLWidget.
Also sets up the the model and the controller for the model.
'''
self.model = AstronomerModel(ZMDC())
# There is no onResume in python so start the controller group here
self.controller = create_controller_group(self.shared_prefs)
self.controller.set_model(self.model)
self.controller.start()
self.layer_manager = instantiate_layer_manager(self.model, self.shared_prefs)
self.view = QGraphicsView()
self.scene = QGraphicsScene()
if self.DEBUG_MODE != None:
self.sky_renderer = SkyRenderer(self.DEBUG_MODE)
else:
self.sky_renderer = SkyRenderer()
self.sky_renderer.setAutoFillBackground(False)
# set up the view with the glwidget inside
self.view.setViewport(self.sky_renderer)
self.view.setScene(self.scene)
self.setCentralWidget(self.view)
self.renderer_controller = RendererController(self.sky_renderer, None)
self.renderer_controller.add_update_closure(\
self.RendererModelUpdateClosure(self.model, self.renderer_controller))
self.layer_manager.register_with_renderer(self.renderer_controller)
self.wire_up_screen_controls()
# NOTE: THIS BOOLEAN WILL NEED TO BE REMOVED EVENTUALLY
self.magnetic_switcher = MDCS(self.model, self.USE_AUTO_MODE)
self.run_queue()
def wire_up_screen_controls(self):
'''
Set up all of the screen controls, so that the user can zoom in/out
and select which layers they wish to view.
'''
screen_width = self.sky_renderer.render_state.screen_width
screen_height = self.sky_renderer.render_state.screen_height
self.pref_buttons = PreferencesButton(self.view)
self.zoom_button = ZoomButton(self.view)
position_y = ((screen_height - 336) / 2) + 1
self.pref_buttons.setGeometry(QtCore.QRect(1, position_y, 55, 336))
position_x = ((screen_width - 221) / 2) + 1
position_y = ((screen_height - 31) * 9/10) + 1
self.zoom_button.setGeometry(QtCore.QRect(position_x, position_y, 221, 31))
self.pref_buttons_fader = WidgetFader(self.pref_buttons, 2500)
self.zoom_button_fader = WidgetFader(self.zoom_button, 2500)
self.map_mover = MapMover(self.model, self.controller, self.shared_prefs,
screen_height)
self.DRZ_detector = DRZDetector(self.map_mover, self.show_menus_func)
def show_menus_func(self):
self.pref_buttons_fader.make_active()
self.zoom_button_fader.make_active()
def update_rendering(self):
'''
re-render the sky and run updates
'''
self.sky_renderer.updateGL()
self.run_queue()
self.sky_renderer.updateGL()
def run_queue(self):
'''
In the absence of another thread doing updates,
force the updates by running all the runnables on the queue
'''
num = len(list(self.renderer_controller.queuer.queue))
while num > 0:
runnable = self.renderer_controller.queuer.get()
runnable.run()
self.renderer_controller.queuer.task_done()
num -= 1
def __init__(self, debug_index=None):
'''
Set up all state and control that the application requires.
'''
QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_AcceptTouchEvents)
self.DEBUG_MODE = debug_index
self.USE_AUTO_MODE = False
self.shared_prefs = SharedPreferences()
self.initialize_model_view_controller()
self.controller.set_auto_mode(self.USE_AUTO_MODE)
# put the window at the screen position (100, 30)
# with size 480 by 800
self.setGeometry(100, 30, 480, 800)
self.show()
# every 5 seconds re-render the sky and run updates
self.update_rendering()
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.update_rendering)
self.timer.setInterval(5000)
self.timer.start()