Changeset 420


Ignore:
Timestamp:
12/01/09 20:41:32 (10 years ago)
Author:
saritor
Message:

Patch by saritor.

  • This patch re-introduces basic parts of the hud back into the new architecture.
Location:
branches/gui_overhaul
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/gui_overhaul/run.py

    r418 r420  
    2525 
    2626import fife_compat, fife, fifelog 
    27 import pychan 
    2827from scripts import world 
    2928from scripts import engine 
     
    104103        self.world.quitFunction = self.listener.quitGame 
    105104        self.model.loadMap("main-map", str(TDS.readSetting("MapFile"))) 
    106         pychan.init(self.engine, debug = True) 
    107105 
    108106    def loadSettings(self): 
  • branches/gui_overhaul/scripts/gui/gui_manager.py

    r377 r420  
    1818import fife 
    1919import pychan 
     20from scripts.gui.gui_modules.hud import GUIHud 
    2021 
    2122class GUIManager(object): 
    2223    """Manager of all the GUIModules.""" 
    2324     
    24     def __init__(self): 
    25         """Initialize all the GUI elements""" 
    26         self.modules = {}          # Dictionary of all GUIModules mapping class name to object. 
    27         self.current_module = None # currently active GUIModule 
     25    def __init__(self, engine, data, settings): 
     26        """Initialize all the GUI elements 
     27           @type engine: fife.Engine 
     28           @param engine: An instance of the FIFE engine 
     29           @type data: Engine 
     30           @param data: PARPG Engine 
     31           @type settings: settings.Settings 
     32           @param The settings data 
     33           @return: None""" 
     34        pychan.init(engine, debug = True) 
     35        self.engine = engine 
     36        self.data = data 
     37        self.settings = settings 
     38        # Dictionary of all GUIModules mapping class name to object. 
     39        self.modules = {"GUIHud":GUIHud(engine, data, self, "gui/hud.xml")}           
     40        # currently active GUIModule         
     41        self.current_module = self.modules["GUIHud"] 
     42         
     43    def set_current_module(self): 
     44        """Sets the current module""" 
     45        #self.current_module = self.modules["GUIHud"] 
     46        pass 
    2847                 
    2948    def show_current_module(self): 
    3049        """Performs all the necessary clean-up before showing self.current_module 
    3150        then displays current_module.""" 
    32         pass 
     51        self.current_module.show() 
    3352         
    3453    def hide_current_module(self): 
    3554        """Performs all the necessary clean-up before hiding self.current_module 
    3655        then hides current_module.""" 
    37         pass 
     56        self.current_module.hide() 
  • branches/gui_overhaul/scripts/gui/gui_module.py

    r377 r420  
    2222    """Module template class.""" 
    2323     
    24     def __init__(self, blocking = False, blockable = False, **kwargs): 
    25         """Initialize the module.""" 
    26         self.blocking = blocking 
    27         self.blockable = blockable 
     24    def __init__(self, engine, data, manager, filename): 
     25        """Initialize the module. 
     26           @type engine: fife.Engine 
     27           @param engine: An instance of FIFE's engine 
     28           @type data: Engine 
     29           @param data: An instance of PARPG's engine 
     30           @type manager: GUIManager 
     31           @param manager: The GUIManager responsible for maintaining modules 
     32           @type parent: String 
     33           @param parent: The class name of the parent module to this module 
     34           @type filename: String 
     35           @param filename: The GUI's XML file 
     36           @return: None""" 
     37        self.engine = engine 
     38        self.data = data 
     39        self.manager = manager 
     40        self.root_gui = pychan.loadXML(filename) 
    2841 
    2942    def show(self): 
    3043        """Display the module.""" 
    31         pass 
     44        self.root_gui.show() 
    3245     
    3346    def hide(self): 
    3447        """Hide the module.""" 
    35         pass 
     48        self.root_gui.hide() 
  • branches/gui_overhaul/scripts/gui/gui_modules/hud.py

    r418 r420  
    2020import pychan 
    2121import pychan.widgets as widgets 
     22from scripts.gui.gui_module import GUIModule 
    2223from pychan.tools import callbackWithArguments as cbwa 
    23 from scripts.gui.filebrowser import FileBrowser 
    24 from scripts.gui.context_menu import ContextMenu 
    25 from scripts.gui import inventorygui 
    26 from scripts.gui.popups import ExaminePopup, ContainerGUI 
    27 from scripts.gui.dialoguegui import DialogueGUI 
    28  
    29 class Hud(object): 
    30     """Main Hud class""" 
    31     def __init__(self, engine, settings, inv_model, data, callbacks): 
    32         """Initialise the instance. 
    33            @type engine: fife.Engine 
    34            @param engine: An instance of the fife engine 
    35            @type settings: settings.Setting 
    36            @param settings: The settings data 
    37            @type inv_model: dict 
    38            @type callbacks: dict 
    39            @param callbacks: a dict of callbacks 
    40                saveGame: called when the user clicks on Save 
    41                loadGame: called when the user clicks on Load 
    42                quitGame: called when the user clicks on Quit 
    43            @return: None""" 
    44         pychan.init(engine, debug = True) 
    45  
    46         # TODO: perhaps this should not be hard-coded here 
    47         self.hud = pychan.loadXML("gui/hud.xml") 
    48         self.engine = engine 
    49         self.settings = settings 
    50         self.data = data 
    51  
    52         inv_callbacks = { 
    53             'refreshReadyImages': self.refreshReadyImages, 
    54             'toggleInventoryButton': self.toggleInventoryButton, 
    55         } 
    5624 
    5725 
    58         self.inventory = inventorygui.InventoryGUI(self.engine, \ 
    59                                                    inv_model, inv_callbacks) 
    60  
    61         self.refreshReadyImages() 
    62  
    63         self.save_game_callback = callbacks['saveGame'] 
    64         self.load_game_callback = callbacks['loadGame'] 
    65         self.quit_callback      = callbacks['quitGame'] 
    66  
    67         self.box_container = None 
    68         self.examine_box = None 
    69  
    70         self.actions_box = self.hud.findChild(name="actionsBox") 
    71         self.actions_text = [] 
    72         self.menu_displayed = False 
    73         self.initializeHud() 
    74         self.initializeMainMenu() 
    75         self.initializeContextMenu() 
    76         self.initializeOptionsMenu() 
    77         self.initializeHelpMenu() 
    78         self.initializeEvents() 
    79         self.initializeQuitDialog() 
    80  
    81     def initializeHud(self): 
    82         """Initialize and show the main HUD 
    83            @return: None""" 
    84         self.events_to_map = {"menuButton":self.displayMenu,} 
    85         self.hud.mapEvents(self.events_to_map)  
     26class GUIHud(GUIModule): 
     27    """Main Hud class""" 
     28     
     29    def __init__(self, engine, data, manager, filename): 
     30        GUIModule.__init__(self, engine, data, manager, filename) 
     31         
    8632        # set HUD size according to screen size 
    87         screen_width = int(self.settings.readSetting('ScreenWidth')) 
    88         self.hud.findChild(name="mainHudWindow").size = (screen_width, 65) 
    89         self.hud.findChild(name="inventoryButton").position = \ 
     33        screen_width = int(manager.settings.readSetting('ScreenWidth')) 
     34        self.root_gui.findChild(name="mainHudWindow").size = (screen_width, 65) 
     35        self.root_gui.findChild(name="inventoryButton").position = \ 
    9036                                                    (screen_width-59, 7) 
    9137        # add ready slots 
    92         ready1 = self.hud.findChild(name='hudReady1') 
    93         ready2 = self.hud.findChild(name='hudReady2') 
    94         ready3 = self.hud.findChild(name='hudReady3') 
    95         ready4 = self.hud.findChild(name='hudReady4') 
    96         actions_scroll_area = self.hud.findChild(name='actionsScrollArea') 
     38        ready1 = self.root_gui.findChild(name='hudReady1') 
     39        ready2 = self.root_gui.findChild(name='hudReady2') 
     40        ready3 = self.root_gui.findChild(name='hudReady3') 
     41        ready4 = self.root_gui.findChild(name='hudReady4') 
     42        actions_scroll_area = self.root_gui.findChild(name='actionsScrollArea') 
    9743        if (screen_width <=800) : 
    9844            gap = 0 
     
    10854 
    10955        # and finally add an actions box 
    110         self.hud.findChild(name="actionsBox").min_size = (actions_width, 0) 
     56        self.root_gui.findChild(name="actionsBox").min_size = (actions_width, 0) 
    11157        actions_scroll_area.min_size = (actions_width, 55) 
    11258        actions_scroll_area.max_size = (actions_width, 55) 
    11359        # now it should be OK to display it all 
    114         self.hud.show() 
    115  
    116     def refreshActionsBox(self): 
    117         """Refresh the actions box so that it displays the contents of 
    118            self.actions_text 
    119            @return: None""" 
    120         self.actions_box.items = self.actions_text 
    121  
    122     def addAction(self, action): 
    123         """Add an action to the actions box. 
    124            @type action: string 
    125            @param action: The text that you want to display in the actions box 
    126            @return: None""" 
    127         self.actions_text.insert(0, action) 
    128         self.refreshActionsBox() 
    129  
    130     def showHUD(self): 
    131         """Show the HUD. 
    132            @return: None""" 
    133         self.hud.show() 
    134  
    135     def hideHUD(self): 
    136         """Hide the HUD. 
    137            @return: None""" 
    138         self.hud.hide() 
    139  
    140     def initializeContextMenu(self): 
    141         """Initialize the Context Menu 
    142            @return: None""" 
    143         self.context_menu = ContextMenu (self.engine, [], (0,0)) 
    144         self.context_menu.hide() 
    145  
    146     def showContextMenu(self, data, pos): 
    147         """Display the Context Menu with data at pos 
    148            @type data: list 
    149            @param data: data to pass to context menu 
    150            @type pos: tuple 
    151            @param pos: tuple of x and y coordinates 
    152            @return: None""" 
    153         self.context_menu = ContextMenu(self.engine, data, pos) 
    154  
    155     def hideContextMenu(self): 
    156         """Hides the context menu 
    157            @return: None""" 
    158         self.context_menu.hide() 
    159  
    160     def initializeMainMenu(self): 
    161         """Initalize the main menu. 
    162            @return: None""" 
    163         self.main_menu = pychan.loadXML("gui/hud_main_menu.xml") 
    164         self.menu_events = {"resumeButton":self.hideMenu,  
    165                             "optionsButton":self.displayOptions, 
    166                             "helpButton":self.displayHelp} 
    167         self.main_menu.mapEvents(self.menu_events) 
    168  
    169     def displayMenu(self): 
    170         """Displays the main in-game menu. 
    171            @return: None""" 
    172         if (self.menu_displayed == False): 
    173             self.main_menu.show() 
    174             self.menu_displayed = True 
    175         elif (self.menu_displayed == True): 
    176             self.hideMenu() 
    177  
    178     def hideMenu(self): 
    179         """Hides the main in-game menu. 
    180            @return: None""" 
    181         self.main_menu.hide() 
    182         self.menu_displayed = False 
    183  
    184  
    185     def initializeHelpMenu(self): 
    186         """Initialize the help menu 
    187            @return: None""" 
    188         self.help_dialog = pychan.loadXML("gui/help.xml") 
    189         help_events = {"closeButton":self.help_dialog.hide} 
    190         self.help_dialog.mapEvents(help_events) 
    191         main_help_text = u"Welcome to Post-Apocalyptic RPG or PARPG![br][br]"\ 
    192         "This game is still in development, so please expect for there to be "\ 
    193         "bugs and[br]feel free to tell us about them at "\ 
    194         "http://www.forums.parpg.net.[br]This game uses a "\ 
    195         "\"Point 'N' Click\" interface, which means that to move around,[br]"\ 
    196         "just click where you would like to go and your character will move "\ 
    197         "there.[br]PARPG also utilizes a context menu. To access this, just "\ 
    198         "right click anywhere[br]on the screen and a menu will come up. This "\ 
    199         "menu will change depending on[br]what you have clicked on, hence "\ 
    200         "it's name \"context menu\".[br][br]" 
    201          
    202         k_text = u" Keybindings"  
    203         k_text += "[br] A : Add a test action to the actions display" 
    204         k_text += "[br] I : Toggle the inventory screen" 
    205         k_text += "[br] F5 : Take a screenshot" 
    206         k_text += "[br]      (saves to <parpg>/screenshots/)" 
    207         k_text += "[br] Q : Quit the game" 
    208         self.help_dialog.distributeInitialData({ 
    209                 "MainHelpText":main_help_text, 
    210                 "KeybindText":k_text 
    211                 }) 
    212  
    213     def displayHelp(self): 
    214         """Display the help screen. 
    215            @return: None""" 
    216         self.help_dialog.show() 
    217  
    218     def switchResolutions(self): 
    219         """ Sync the contents of the resolution box (windowed or fullscreen 
    220             resolutions to the selection made in the Fullscreen checkbox. 
    221             @return: None""" 
    222              
    223         if self.options_menu.collectData('FullscreenBox'): 
    224             self.options_menu.distributeInitialData({ 
    225                                 'ResolutionBox' : self.resolutions_fullscreen 
    226                                                      }) 
    227         else: 
    228             self.options_menu.distributeInitialData({ 
    229                                 'ResolutionBox' : self.resolutions_windowed 
    230                                                      }) 
    231          
    232     def initializeOptionsMenu(self): 
    233         """Initialize the options menu, this will generate a list of fullscreen 
    234            resolutions and a list of windowed resolutions. Next to this the  
    235            current active settings are read and also selected in the matching 
    236            widgets. 
    237            @return: None""" 
    238             
    239         self.options_menu = pychan.loadXML("gui/hud_options.xml") 
    240         self.options_events = {"applyButton":self.applyOptions, 
    241                                "closeButton":self.options_menu.hide, 
    242                                "defaultsButton":self.setToDefaults, 
    243                                "FullscreenBox": self.switchResolutions, 
    244                                "InitialVolumeSlider":self.updateVolumeText} 
    245          
    246         settings = self.engine.getSettings() 
    247         # The settings need to be set to fullscreen for the call to  
    248         # getPossibleResolutions() to function. 
    249         current_fullscreen = settings.isFullScreen() 
    250         settings.setFullScreen(True) 
    251          
    252         available_fullscreen_resolutions = settings.getPossibleResolutions() 
    253         available_windowed_resolutions = ((1920, 1200), (1920, 1080), \ 
    254                                           (1856, 1392), (1792, 1344), \ 
    255                                           (1680, 1050), (1600, 1200), \ 
    256                                           (1600, 1024), (1440,  900), \ 
    257                                           (1400, 1050), (1360,  768), \ 
    258                                           (1280, 1024), (1280,  960), \ 
    259                                           (1152,  864), (1024,  768)) 
    260         # Filter too small resolutions from the fullscreen resolutions 
    261         self.resolutions_fullscreen = [] 
    262         for x in available_fullscreen_resolutions: 
    263             if x[0] >= 1024 and x[1] >= 768: 
    264                 self.resolutions_fullscreen.append(str(x[0]) + 'x' + str(x[1])) 
    265  
    266         # Filter too large resolution from the windowed resolutions  
    267         self.resolutions_windowed = [] 
    268         for x in available_windowed_resolutions: 
    269             if x[0] <= available_fullscreen_resolutions[0][0] and \ 
    270             x[1] <= available_fullscreen_resolutions[0][1]: 
    271                 self.resolutions_windowed.append(str(x[0]) + 'x' + str(x[1]))         
    272          
    273         settings.setFullScreen(current_fullscreen) 
    274         self.render_backends = ['OpenGL', 'SDL'] 
    275         self.render_number = 0 
    276         if (str(self.settings.readSetting('RenderBackend')) == "SDL"): 
    277             self.render_number = 1 
    278         initial_volume = float(self.settings.readSetting('InitialVolume')) 
    279         initial_volume_text = str('Initial Volume: %.0f%s' % 
    280                                 (int(initial_volume*10), "%")) 
    281         initial_data_to_distribute = {     
    282                 'RenderBox'          : self.render_backends, 
    283                 'InitialVolumeLabel' : initial_volume_text 
    284                 } 
    285  
    286         s_fullscreen = self.settings.readSetting(name="FullScreen") 
    287         s_sounds = self.settings.readSetting(name="PlaySounds") 
    288         s_render = self.render_number 
    289         s_volume = initial_volume 
    290  
    291         # Find the current active resolution so we can select it  
    292         screen_width = self.settings.readSetting(name="ScreenWidth") 
    293         screen_height = self.settings.readSetting(name="ScreenHeight") 
    294         index_res = str(screen_width + 'x' + screen_height) 
    295         try: 
    296             if int(s_fullscreen) == 0: 
    297                 s_resolution = self.resolutions_windowed.index(index_res) 
    298             else: 
    299                 s_resolution = self.resolutions_fullscreen.index(index_res) 
    300             resolution_in_list = True 
    301         except: 
    302             resolution_in_list = False 
    303              
    304         data_to_distribute = { 
    305                 'FullscreenBox'      : int(s_fullscreen),  
    306                 'SoundsBox'          : int(s_sounds), 
    307                 'RenderBox'          : s_render, 
    308                 'InitialVolumeSlider': s_volume 
    309                 } 
    310  
    311         if int(s_fullscreen) == 0: 
    312             initial_data_to_distribute['ResolutionBox'] = self.resolutions_windowed 
    313         else: 
    314             initial_data_to_distribute['ResolutionBox'] = self.resolutions_fullscreen 
    315              
    316         if (resolution_in_list == True): 
    317             data_to_distribute['ResolutionBox'] = s_resolution 
    318  
    319         self.options_menu.distributeInitialData(initial_data_to_distribute) 
    320         self.options_menu.distributeData(data_to_distribute) 
    321         self.options_menu.mapEvents(self.options_events) 
    322  
    323     def saveGame(self): 
    324         """ Called when the user wants to save the game. 
    325             @return: None""" 
    326         save_browser = FileBrowser(self.engine, 
    327                                    self.save_game_callback, 
    328                                    save_file=True, 
    329                                    gui_xml_path="gui/savebrowser.xml", 
    330                                    extensions = ('.dat')) 
    331         save_browser.showBrowser() 
    332              
    333     def newGame(self): 
    334         """Called when user request to start a new game. 
    335            @return: None""" 
    336         print 'new game' 
    337  
    338     def loadGame(self): 
    339         """ Called when the user wants to load a game. 
    340             @return: None""" 
    341         load_browser = FileBrowser(self.engine, 
    342                                    self.load_game_callback, 
    343                                    save_file=False, 
    344                                    gui_xml_path='gui/loadbrowser.xml', 
    345                                    extensions=('.dat')) 
    346         load_browser.showBrowser() 
    347      
    348     def initializeQuitDialog(self): 
    349         """Creates the quit confirmation dialog 
    350            @return: None""" 
    351         self.quit_window = pychan.widgets.Window(title=unicode("Quit?"), \ 
    352                                                  min_size=(200,0)) 
    353  
    354         hbox = pychan.widgets.HBox() 
    355         are_you_sure = "Are you sure you want to quit?" 
    356         label = pychan.widgets.Label(text=unicode(are_you_sure)) 
    357         yes_button = pychan.widgets.Button(name="yes_button",  
    358                                            text=unicode("Yes"), 
    359                                            min_size=(90,20), 
    360                                            max_size=(90,20)) 
    361         no_button = pychan.widgets.Button(name="no_button", 
    362                                           text=unicode("No"), 
    363                                           min_size=(90,20), 
    364                                           max_size=(90,20)) 
    365  
    366         self.quit_window.addChild(label) 
    367         hbox.addChild(yes_button) 
    368         hbox.addChild(no_button) 
    369         self.quit_window.addChild(hbox) 
    370  
    371         events_to_map = { "yes_button": self.quit_callback, 
    372                           "no_button":  self.quit_window.hide } 
    373          
    374         self.quit_window.mapEvents(events_to_map) 
    375  
    376  
    377     def quitGame(self): 
    378         """Called when user requests to quit game. 
    379            @return: None""" 
    380  
    381         self.quit_window.show() 
    382  
    383     def toggleInventoryButton(self): 
    384         """Manually toggles the inventory button. 
    385            @return: None""" 
    386         button = self.hud.findChild(name="inventoryButton") 
    387         if button.toggled == 0: 
    388             button.toggled = 1 
    389         else: 
    390             button.toggled = 0 
    391  
    392     def toggleInventory(self, toggleImage=True): 
    393         """Display's the inventory screen 
    394            @return: None""" 
    395  
    396         self.inventory.toggleInventory(toggleImage) 
    397  
    398     def refreshReadyImages(self): 
    399         """Make the Ready slot images on the HUD be the same as those  
    400            on the inventory 
    401            @return: None""" 
    402         self.setImages(self.hud.findChild(name="hudReady1"), 
    403                        self.inventory.getImage("Ready1").up_image) 
    404  
    405         self.setImages(self.hud.findChild(name="hudReady2"), 
    406                        self.inventory.getImage("Ready2").up_image) 
    407  
    408         self.setImages(self.hud.findChild(name="hudReady3"), 
    409                        self.inventory.getImage("Ready3").up_image) 
    410  
    411         self.setImages(self.hud.findChild(name="hudReady4"), 
    412                        self.inventory.getImage("Ready4").up_image) 
    413  
    414     def setImages(self, widget, image): 
    415         """Set the up, down, and hover images of an Imagebutton. 
    416            @type widget: pychan.widget 
    417            @param widget: widget to set 
    418            @type image: string 
    419            @param image: image to use 
    420            @return: None""" 
    421         widget.up_image = image 
    422         widget.down_image = image 
    423         widget.hover_image = image 
    424  
    425     def initializeEvents(self): 
    426         """Intialize Hud events 
    427            @return: None""" 
    428         events_to_map = {} 
    429  
    430         # when we click the toggle button don't change the image 
    431         events_to_map["inventoryButton"] = cbwa(self.toggleInventory, False) 
    432         events_to_map["saveButton"] = self.saveGame 
    433         events_to_map["loadButton"] = self.loadGame 
    434  
    435         hud_ready_buttons = ["hudReady1", "hudReady2", \ 
    436                              "hudReady3", "hudReady4"] 
    437  
    438         for item in hud_ready_buttons: 
    439             events_to_map[item] = cbwa(self.readyAction, item) 
    440  
    441         self.hud.mapEvents(events_to_map) 
    442  
    443         menu_events = {} 
    444         menu_events["newButton"] = self.newGame 
    445         menu_events["quitButton"] = self.quitGame 
    446         menu_events["saveButton"] = self.saveGame 
    447         menu_events["loadButton"] = self.loadGame 
    448         self.main_menu.mapEvents(menu_events) 
    449  
    450     def updateVolumeText(self): 
    451         """ 
    452         Update the initial volume label to reflect the value of the slider 
    453         """ 
    454         volume = float(self.options_menu.collectData("InitialVolumeSlider")) 
    455         volume_label = self.options_menu.findChild(name="InitialVolumeLabel") 
    456         volume_label.text = unicode("Initial Volume: %.0f%s" % 
    457                                     (int(volume*10), "%")) 
    458  
    459     def requireRestartDialog(self): 
    460         """Show a dialog asking the user to restart PARPG in order for their 
    461            changes to take effect. 
    462            @return: None""" 
    463         require_restart_dialog = pychan.loadXML('gui/hud_require_restart.xml') 
    464         require_restart_dialog.mapEvents(\ 
    465                                 {'okButton':require_restart_dialog.hide}) 
    466         require_restart_dialog.show() 
    467  
    468     def applyOptions(self): 
    469         """Apply the current options. 
    470            @return: None""" 
    471         # At first no restart is required 
    472         self.require_restart = False 
    473  
    474         # get the current values of each setting from the options menu 
    475         enable_fullscreen = self.options_menu.collectData('FullscreenBox') 
    476         enable_sound = self.options_menu.collectData('SoundsBox') 
    477         screen_resolution = self.options_menu.collectData('ResolutionBox') 
    478         if enable_fullscreen: 
    479             partition = self.resolutions_fullscreen[screen_resolution].partition('x') 
    480         else: 
    481             partition = self.resolutions_windowed[screen_resolution].partition('x') 
    482         screen_width = partition[0] 
    483         screen_height = partition[2] 
    484         render_backend = self.options_menu.collectData('RenderBox') 
    485         initial_volume = self.options_menu.collectData('InitialVolumeSlider') 
    486         initial_volume = "%.1f" % initial_volume 
    487  
    488         # get the options that are being used right now from settings.xml 
    489         s_fullscreen = self.settings.readSetting('FullScreen') 
    490         s_sounds = self.settings.readSetting('PlaySounds') 
    491         s_render = self.settings.readSetting('RenderBackend') 
    492         s_volume = self.settings.readSetting('InitialVolume') 
    493  
    494         s_screen_height = self.settings.readSetting('ScreenHeight') 
    495         s_screen_width = self.settings.readSetting('ScreenWidth') 
    496         s_resolution = s_screen_width + 'x' + s_screen_height 
    497  
    498         # On each: 
    499         # - Check to see whether the option within the xml matches the 
    500         #   option within the options menu 
    501         # - If they do not match, set the option within the xml to 
    502         #   to be what is within the options menu 
    503         # - Require a restart 
    504  
    505         if (int(enable_fullscreen) != int(s_fullscreen)): 
    506             self.setOption('FullScreen', int(enable_fullscreen)) 
    507             self.require_restart = True 
    508              
    509         if (int(enable_sound) != int(s_sounds)): 
    510             self.setOption('PlaySounds', int(enable_sound)) 
    511             self.require_restart = True 
    512  
    513         if (screen_resolution != s_resolution): 
    514             self.setOption('ScreenWidth', int(screen_width)) 
    515             self.setOption('ScreenHeight', int(screen_height)) 
    516             self.require_restart = True 
    517  
    518         # Convert the number from the list of render backends to 
    519         # the string that FIFE wants for its settings.xml 
    520         if (render_backend == 0): 
    521             render_backend = 'OpenGL' 
    522         else: 
    523             render_backend = 'SDL' 
    524  
    525         if (render_backend != str(s_render)): 
    526             self.setOption('RenderBackend', render_backend) 
    527             self.require_restart = True 
    528  
    529         if (initial_volume != float(s_volume)): 
    530             self.setOption('InitialVolume', initial_volume) 
    531             self.require_restart = True 
    532          
    533         # Write all the settings to settings.xml 
    534         self.settings.tree.write('settings.xml') 
    535          
    536         # If the changes require a restart, popup the dialog telling 
    537         # the user to do so 
    538         if (self.require_restart): 
    539             self.requireRestartDialog() 
    540         # Once we are done, we close the options menu 
    541         self.options_menu.hide() 
    542  
    543     def setOption(self, name, value): 
    544         """Set an option within the xml. 
    545            @type name: string 
    546            @param name: The name of the option within the xml 
    547            @type value: any 
    548            @param value: The value that the option 'name' should be set to 
    549            @return: None""" 
    550         element = self.settings.root_element.find(name) 
    551         if(element != None): 
    552             if(value != element.text): 
    553                 element.text = str(value) 
    554         else: 
    555             print 'Setting,', name, 'does not exist!' 
    556  
    557     def setToDefaults(self): 
    558         """Reset all the options to the options in settings-dist.xml. 
    559            @return: None""" 
    560         shutil.copyfile('settings-dist.xml', 'settings.xml') 
    561         self.requireRestartDialog() 
    562         self.options_menu.hide() 
    563  
    564     def displayOptions(self): 
    565         """Display the options menu. 
    566            @return: None""" 
    567         self.options_menu.show() 
    568      
    569     def readyAction(self, ready_button): 
    570         """ Called when the user selects a ready button from the HUD """ 
    571         text = "Used the item from %s" % ready_button 
    572         self.addAction(text) 
    573          
    574     def createBoxGUI(self, title, items = [], events = ()): 
    575         """Creates a window to display the contents of a box 
    576            @type title: string 
    577            @param title: The title for the window 
    578            @param items: The contents of the box 
    579            @param events: The events of the window 
    580            @return: A new ContainerGui""" 
    581         box_container = ContainerGUI(self.engine, \ 
    582                                               unicode(title), items) 
    583         box_container.container_gui.mapEvents(events) 
    584         return box_container 
    585  
    586     def hideContainer(self): 
    587         """Hide the container box 
    588            @return: None""" 
    589         if self.box_container: 
    590             self.box_container.hideContainer() 
    591  
    592     def createExamineBox(self, title, desc): 
    593         """Create an examine box. It displays some textual description of an 
    594            object 
    595            @type title: string 
    596            @param title: The title of the examine box 
    597            @type desc: string 
    598            @param desc: The main body of the examine box 
    599            @return: None""" 
    600  
    601         if self.examine_box is not None: 
    602             self.examine_box.closePopUp() 
    603         self.examine_box = ExaminePopup(self.engine, title, desc) 
    604         self.examine_box.showPopUp() 
    605  
    606     def showDialogue(self, npc): 
    607         """Show the NPC dialogue window 
    608            @type npc: actors.NonPlayerCharacter 
    609            @param npc: the npc that we are having a dialogue with 
    610            @return: None""" 
    611         dialogue = DialogueGUI( 
    612                     npc, 
    613                     self.data.game_state.quest_engine, 
    614                     self.data.game_state.PC) 
    615         dialogue.initiateDialogue() 
  • branches/gui_overhaul/scripts/gui/gui_modules/inventorygui.py

    r377 r420  
    4343                   Function that will toggle the state of the inventory button 
    4444           @return: None""" 
    45         pychan.init(engine, debug = True) 
    4645        self.engine = engine 
    4746        self.readyCallback = callbacks['refreshReadyImages'] 
  • branches/gui_overhaul/scripts/gui/gui_modules/popups.py

    r377 r420  
    3838        """ 
    3939        self.engine = engine 
    40         pychan.init(self.engine, debug=True) 
    4140         
    4241        self.container_gui = pychan.loadXML("gui/container_base.xml") 
     
    261260        """ 
    262261        self.engine = engine 
    263         pychan.init(self.engine, debug=True) 
    264262 
    265263        self.examine_window = pychan.widgets.\ 
  • branches/gui_overhaul/scripts/world.py

    r418 r420  
    2727#from scripts.gui import hud 
    2828#from scripts.gui.popups import * 
     29from scripts.gui.gui_manager import GUIManager 
    2930from pychan.tools import callbackWithArguments as cbwa 
    3031from map import Map 
     
    9394            'quitGame': self.quitGame, 
    9495        } 
     96        self.gui_manager = GUIManager(self.engine, self.data, TDS) 
     97        self.gui_manager.set_current_module() 
     98        self.gui_manager.show_current_module() 
    9599        #self.hud = hud.Hud(self.engine, TDS, inv_model, self.data, hud_callbacks) 
    96100     
     
    196200        if(key_val == key.M): 
    197201            self.sounds.toggleMusic() 
     202        # Testing the hide/show methods. 
     203        if(key_val == key.H): 
     204            print "Hiding HUD" 
     205            self.gui_manager.hide_current_module() 
     206        if(key_val == key.S): 
     207            print "Showing HUD" 
     208            self.gui_manager.show_current_module() 
    198209 
    199210    def mouseReleased(self, evt): 
Note: See TracChangeset for help on using the changeset viewer.