Beispiel #1
0
    def buildCommPanel(self):
        """This method will add the jowstgui.ChatPanel widget and the player
           wrestler tree to the match setup dialog"""
        commPanelSzr = wxBoxSizer(wxHORIZONTAL)
        # Import here to avoid recursive jowstgui import on startup
        from gui.jowstgui import ChatPanel
        self.chatPanel = ChatPanel(self, self.chatCB)
        commPanelSzr.Add(self.chatPanel, 2, wxEXPAND|wxLEFT, border=5)
        commPanelSzr.Add((2, 0))

        # Build player/wrestler tree
        self.pwTree = wxTreeCtrl(self, -1, size=(200, -1),
                                 style=wxTR_HIDE_ROOT)
        
        self.treeRoot = self.pwTree.AddRoot("Players")
        self.pwTree.SetItemBold(self.treeRoot)
        self.controlGUI.pwTree = self.pwTree
        commPanelSzr.Add(self.pwTree, 1, wxEXPAND|wxRIGHT, border=5)

        self.mainSzr.Add(commPanelSzr, 0, wxEXPAND) #|wxLEFT|wxRIGHT, border=5)
Beispiel #2
0
class MatchSetupDialog(wxDialog, wxPanel):
    def __init__(self, setupObj, chatCB=None, panel_parent=None):
        if not panel_parent:
            wxDialog.__init__(self, None, -1, "Match Setup")
        else:
            wxPanel.__init__(self, panel_parent, -1)
            
        self.controlGUI = MatchControlGUI(self)
        self.controlGUI.pwTree = None
        self.setupObj = setupObj
        self.chatCB = chatCB
        self.msParamDict = {}
        self.state = None
        self.mainSzr = wxBoxSizer(wxVERTICAL)
        self.playerMap = {}

        if panel_parent:
            # Layout Match Setup Dialog
            self.mainSzr.Fit(self)
            self.SetSizer(self.mainSzr)
            self.SetAutoLayout(1)
            self.mainSzr.Layout()

    def buildMatchControlGUI(self):
        self.controlGUI.buildMatchControlGUI(self.setupObj)
        self.mainSzr.Add(self.controlGUI.matchSetupSzr, 0, wxEXPAND)

    def enableWidgetEvents(self): self.controlGUI.enableWidgetEvents()
    def enableWidgets(self, enable=1): self.controlGUI.enableWidgets(enable)
    def setTeams(self, team1, team2, is_interactive):
        self.controlGUI.setTeams(team1, team2, is_interactive)

    def setAllCPU(self, val):
        self.controlGUI.setAllCPU(val)

    def setPrefs(self, prefs):
        self.controlGUI.setPrefs(prefs)
        
    def disableWidgets(self, widgets):
        self.controlGUI.disableWidgets(widgets)
        
    def disableAddDeleteButtons(self):
        self.controlGUI.disableAddDeleteButtons()

    def deleteMembers(self, team):
        """Remove All members for a given team from the match setup UI"""
        self.controlGUI.deleteMembers(teamnum=team)
        
    def buildCommPanel(self):
        """This method will add the jowstgui.ChatPanel widget and the player
           wrestler tree to the match setup dialog"""
        commPanelSzr = wxBoxSizer(wxHORIZONTAL)
        # Import here to avoid recursive jowstgui import on startup
        from gui.jowstgui import ChatPanel
        self.chatPanel = ChatPanel(self, self.chatCB)
        commPanelSzr.Add(self.chatPanel, 2, wxEXPAND|wxLEFT, border=5)
        commPanelSzr.Add((2, 0))

        # Build player/wrestler tree
        self.pwTree = wxTreeCtrl(self, -1, size=(200, -1),
                                 style=wxTR_HIDE_ROOT)
        
        self.treeRoot = self.pwTree.AddRoot("Players")
        self.pwTree.SetItemBold(self.treeRoot)
        self.controlGUI.pwTree = self.pwTree
        commPanelSzr.Add(self.pwTree, 1, wxEXPAND|wxRIGHT, border=5)

        self.mainSzr.Add(commPanelSzr, 0, wxEXPAND) #|wxLEFT|wxRIGHT, border=5)
        
    def handleChatMessage(self, playername, msg):
        self.chatPanel.receiveMsg(playername, msg)
        
    # This should be the last call when building a match setup dialog
    def addButtons(self, starttext="Start Match", canceltext="Cancel",
                   disconnect=0):        
        self.disconnect = disconnect
        # Start Match and Cancel Buttons
        okCancelSzr = wxBoxSizer(wxHORIZONTAL)
        okCancelSzr.Add(wxButton(self, wxID_OK, starttext))
        EVT_BUTTON(self, wxID_OK, self.OnOk)
        okCancelSzr.Add((10, 0))
        okCancelSzr.Add(wxButton(self, wxID_CANCEL, canceltext))
        EVT_BUTTON(self, wxID_CANCEL, self.OnCancel)
        self.mainSzr.Add((0, 5))
        self.mainSzr.Add(okCancelSzr, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT,
                         border=5)

        # Layout Match Setup Dialog
        self.mainSzr.Fit(self)
        self.SetSizer(self.mainSzr)
        self.SetAutoLayout(1)
        self.mainSzr.Layout()
        self.Center()

    def addPlayer(self, player, clientplayer):
        self.playerMap[player] = {"BRANCH":
                                  self.pwTree.AppendItem(self.treeRoot,
                                                         player)}
        if player == clientplayer:
            self.pwTree.SetItemBold(self.playerMap[player]["BRANCH"])

    def removePlayer(self, player):
        self.pwTree.Delete(self.playerMap[player]["BRANCH"])
        self.playerMap.pop(player)
                                  
    def addWrestlerToPlayerTree(self, player, wrestler, team):
        self.playerMap[player][wrestler] = {"BRANCH":
                                            self.pwTree.AppendItem(self.playerMap[player]["BRANCH"],
                                                                  "%s (Team %s)" % (wrestler,
                                                                  team + 1))}
        self.pwTree.Expand(self.playerMap[player]["BRANCH"])
        
    def removeWrestlerFromPlayerTree(self, player, wrestler):
        self.pwTree.Delete(self.playerMap[player][wrestler]["BRANCH"])
        self.playerMap[player].pop(wrestler)

    def setPlayerReady(self, player):
        self.pwTree.SetItemTextColour(self.playerMap[player]["BRANCH"], wxRED)
        self.pwTree.SetItemBold(self.playerMap[player]["BRANCH"])
        self.pwTree.SetItemText(self.playerMap[player]["BRANCH"],
                                "%s (Ready)" % player)
        
    def OnOk(self, evt):
        self.setupObj.validateTeams(self._validationDone)

    def OnCancel(self, evt):         
        self.EndModal(wxCANCEL)
        if self.disconnect:
            self.state = DISCONNECT
                    
    def _validationDone(self, ok2go):
        if ok2go:
            self.EndModal(wxID_OK)
            self.state = READY_TO_START_MATCH
        else:
            dlg = wxMessageDialog(self, "Teams are uneven. Re-select teams.",
                                  "Uneven Teams", style=wxOK)
            if dlg.ShowModal() == wxID_OK: dlg.Destroy()
            

    def _setTeamParam(self, teams, data): self.msParamDict["TEAMS"] = teams
    def _setCPUsParam(self, cpus): self.msParamDict["CPUS"] = cpus
    def _setTimeLimitParam(self, timelimit):
        self.msParamDict["TIMELIMIT"] = timelimit
        
    def _setDqParam(self, dq): self.msParamDict["DQ"] = dq
    def _setDramaParam(self, drama):
        self.msParamDict["DRAMATIC_PAUSE"] = drama
        self.msParamDict["STARTUP_CB"](self.msParamDict)
    
    
    def getTeams(self, getTeamsCB): self.controlGUI.getTeams(getTeamsCB)
    def getCPUs(self, getCPUsCB): self.controlGUI.getCPUs(getCPUsCB)
    def getMatchType(self, getMatchTypeCB):
        self.controlGUI.getMatchType(getMatchTypeCB)
        
    def getTimeLimit(self, getTimeLimitCB):
        self.controlGUI.getTimeLimit(getTimeLimitCB)
        
    def getDQ(self, getDqCB): self.controlGUI.getDQ(getDqCB)
    
    def getDrama(self, getDramaCB):
        self.controlGUI.getDrama(getDramaCB)
        
    def getMatchObject(self, getMatchObjCB):
        self.setupObj.getMatchObject(getMatchObjCB)
        
    def getSetupValues(self, cb=None):
        return self.setupObj.getCurrentSetupValues(cb)

    def getMatchStartupParams(self, startupCB, setupUI):
        self.msParamDict["STARTUP_CB"] = startupCB
        self.msParamDict["SETUP_UI"] = setupUI
        self.getTeams(self._setTeamParam)
        self.getCPUs(self._setCPUsParam)
        self.getTimeLimit(self._setTimeLimitParam)
        self.getDQ(self._setDqParam)
        self.getDramaticPause(self._setDramaParam)