Changeset 348 for trunk/game


Ignore:
Timestamp:
10/25/09 16:23:17 (10 years ago)
Author:
eliedebrauwer
Message:

Ticket #97. Fix by eliedebrauwer, extended options menu with he possibility to have a windowed-resolution list and a fullscreen-resolution list and to switch between both using the dialogue checkbox. fixes[s:trac, t:97]

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/game/scripts/hud.py

    r346 r348  
    8383        self.events_to_map = {"menuButton":self.displayMenu,} 
    8484        self.hud.mapEvents(self.events_to_map)  
    85         # set HUD size accoriding to screen size 
     85        # set HUD size according to screen size 
    8686        screen_width = int(self.settings.readSetting('ScreenWidth')) 
    8787        self.hud.findChild(name="mainHudWindow").size = (screen_width, 65) 
     
    215215        self.help_dialog.show() 
    216216 
     217    def switchResolutions(self): 
     218        """ Sync the contents of the resolution box (windowed or fullscreen 
     219            resolutions to the selection made in the Fullscreen checkbox. 
     220            @return: None""" 
     221             
     222        if self.options_menu.collectData('FullscreenBox'): 
     223            self.options_menu.distributeInitialData({ 
     224                                'ResolutionBox' : self.resolutions_fullscreen 
     225                                                     }) 
     226        else: 
     227            self.options_menu.distributeInitialData({ 
     228                                'ResolutionBox' : self.resolutions_windowed 
     229                                                     }) 
     230         
    217231    def initializeOptionsMenu(self): 
    218         """Initalize the options menu. 
    219            @return: None""" 
     232        """Initialize the options menu, this will generate a list of fullscreen 
     233           resolutions and a list of windowed resolutions. Next to this the  
     234           current active settings are read and also selected in the matching 
     235           widgets. 
     236           @return: None""" 
     237            
    220238        self.options_menu = pychan.loadXML("gui/hud_options.xml") 
    221239        self.options_events = {"applyButton":self.applyOptions, 
    222240                               "closeButton":self.options_menu.hide, 
    223241                               "defaultsButton":self.setToDefaults, 
     242                               "FullscreenBox": self.switchResolutions, 
    224243                               "InitialVolumeSlider":self.updateVolumeText} 
    225244         
    226245        settings = self.engine.getSettings() 
     246        # The settings need to be set to fullscreen for the call to  
     247        # getPossibleResolutions() to function. 
    227248        current_fullscreen = settings.isFullScreen() 
    228249        settings.setFullScreen(True) 
    229         available_resolutions = settings.getPossibleResolutions() 
    230  
    231         # Filter too small resolutions 
    232         self.resolutions=[] 
    233         for x in available_resolutions: 
    234             if x[0]>=1024 and x[1]>=768: 
    235                 self.resolutions.append(str(x[0])+'x'+str(x[1])) 
    236  
     250         
     251        available_fullscreen_resolutions = settings.getPossibleResolutions() 
     252        available_windowed_resolutions = ((1920, 1200), (1920, 1080), \ 
     253                                          (1856, 1392), (1792, 1344), \ 
     254                                          (1680, 1050), (1600, 1200), \ 
     255                                          (1600, 1024), (1440,  900), \ 
     256                                          (1400, 1050), (1360,  768), \ 
     257                                          (1280, 1024), (1280,  960), \ 
     258                                          (1152,  864), (1024,  768)) 
     259        # Filter too small resolutions from the fullscreen resolutions 
     260        self.resolutions_fullscreen = [] 
     261        for x in available_fullscreen_resolutions: 
     262            if x[0] >= 1024 and x[1] >= 768: 
     263                self.resolutions_fullscreen.append(str(x[0]) + 'x' + str(x[1])) 
     264 
     265        # Filter too large resolution from the windowed resolutions  
     266        self.resolutions_windowed = [] 
     267        for x in available_windowed_resolutions: 
     268            if x[0] <= available_fullscreen_resolutions[0][0] and \ 
     269            x[1] <= available_fullscreen_resolutions[0][1]: 
     270                self.resolutions_windowed.append(str(x[0]) + 'x' + str(x[1]))         
     271         
    237272        settings.setFullScreen(current_fullscreen) 
    238273        self.render_backends = ['OpenGL', 'SDL'] 
     
    243278        initial_volume_text = str('Initial Volume: %.0f%s' % 
    244279                                (int(initial_volume*10), "%")) 
    245         self.options_menu.distributeInitialData({ 
    246                 'ResolutionBox': self.resolutions, 
    247                 'RenderBox': self.render_backends, 
     280        initial_data_to_distribute = {     
     281                'RenderBox'          : self.render_backends, 
    248282                'InitialVolumeLabel' : initial_volume_text 
    249                 }) 
     283                } 
    250284 
    251285        s_fullscreen = self.settings.readSetting(name="FullScreen") 
     
    254288        s_volume = initial_volume 
    255289 
     290        # Find the current active resolution so we can select it  
    256291        screen_width = self.settings.readSetting(name="ScreenWidth") 
    257292        screen_height = self.settings.readSetting(name="ScreenHeight") 
    258293        index_res = str(screen_width + 'x' + screen_height) 
    259294        try: 
    260             s_resolution = self.resolutions.index(index_res) 
     295            if int(s_fullscreen) == 0: 
     296                s_resolution = self.resolutions_windowed.index(index_res) 
     297            else: 
     298                s_resolution = self.resolutions_fullscreen.index(index_res) 
    261299            resolution_in_list = True 
    262300        except: 
    263301            resolution_in_list = False 
    264  
     302             
    265303        data_to_distribute = { 
    266                 'FullscreenBox':int(s_fullscreen),  
    267                 'SoundsBox':int(s_sounds), 
    268                 'RenderBox': s_render, 
    269                 'InitialVolumeSlider':s_volume 
     304                'FullscreenBox'      : int(s_fullscreen),  
     305                'SoundsBox'          : int(s_sounds), 
     306                'RenderBox'          : s_render, 
     307                'InitialVolumeSlider': s_volume 
    270308                } 
    271309 
     310        if int(s_fullscreen) == 0: 
     311            initial_data_to_distribute['ResolutionBox'] = self.resolutions_windowed 
     312        else: 
     313            initial_data_to_distribute['ResolutionBox'] = self.resolutions_fullscreen 
     314             
    272315        if (resolution_in_list == True): 
    273316            data_to_distribute['ResolutionBox'] = s_resolution 
    274317 
     318        self.options_menu.distributeInitialData(initial_data_to_distribute) 
    275319        self.options_menu.distributeData(data_to_distribute) 
    276  
    277320        self.options_menu.mapEvents(self.options_events) 
    278321 
     
    432475        enable_sound = self.options_menu.collectData('SoundsBox') 
    433476        screen_resolution = self.options_menu.collectData('ResolutionBox') 
    434         partition = self.resolutions[screen_resolution].partition('x') 
     477        if enable_fullscreen: 
     478            partition = self.resolutions_fullscreen[screen_resolution].partition('x') 
     479        else: 
     480            partition = self.resolutions_windowed[screen_resolution].partition('x') 
    435481        screen_width = partition[0] 
    436482        screen_height = partition[2] 
Note: See TracChangeset for help on using the changeset viewer.