Esempio n. 1
0
 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)
Esempio n. 2
0
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()