E:/project/Anoria2/bigworld/anoria/res/scripts/client/AnGUI/__init__.py

Go to the documentation of this file.

''' 
    Anoria (c) Gsk 2010
'''

import BigWorld
import GUI
from Helpers import PyGUI
from Keys import *


import Cursor
from Helpers.PyGUI.ToolTip import ToolTipManager

import FX

# anything that BigWorld GUI needs to be able to create due to a script tag 
# needs to be imported here
from Base import Base
from LabeledTextField import LabeledTextField
from TextField import TextField
from TextField2 import TextField2
from StatsWindow import StatsWindow
from ChatConsole import ChatConsole
from Button import Button
from ProficienciesWindow import ProficienciesWindow
from AvatarHud import AvatarHud
from Listener import Listener
from TargetHud import TargetHud

class GuiEvent():
    def __init__(self, triggerName, triggerAction='ACTIVATE'):
        self.name=triggerName
        self.action=triggerAction
    
    

class AnGUI(Listener):
    __instance = None
    
    
    def __init__(self):
        if AnGUI.__instance: return     # singleton
        Listener.__init__(self, self.__class__)
        AnGUI.__instance=self;
        self.name = "AnGUI"
        self.listeners = {}

        self.root = None
        self.console = None
        self.hotkeybarGui = None
        self.hotkeys = {}
    
    def setupGUI(self):
        print "AnGUI.setupGUI() executing"
        self.root = GUI.Simple("")
        GUI.addRoot(self.root)
        
        # need to instantiate this one (even though we dont use it) because some code in PyGUI relies on it
        # and I have been to lazy to remove it so far
        self.tooltip_manager = ToolTipManager(self.root, -1)    

        # the overhead hud for our targets
        self.targetHud = TargetHud()

        # chat console
        self.console = GUI.load("gui/chat_window.gui")
        self.console.script.active(True)    # active() adds this component directly to GUI.root !
        
        # a hotkeybar
        self.hotkeybarGui = GUI.load("gui/hotkeybar.gui")
        self.hotkeybarGui.script.active=True
        self.root.addChild(self.hotkeybarGui, "hotkeybarGui")
        
        # hotkeybar buttons: this is not the final solution, need to implement a fully featured system
        # with drag&droppable buttons at some point
        self.buttonBar_1 = GUI.load("gui/hotkeybutton.gui")
        self.buttonBar_1.script.name="AutoAttackToggle"
        self.hotkeybarGui.addChild(self.buttonBar_1, "buttonBar_1")
        self.buttonBar_1.script.setFx("onMouseEnter", FX.fxNop())   # override default Button FX
        self.buttonBar_1.script.setFx("onMouseLeave", FX.fxNop())
        
        self.buttonBar_2 = GUI.load("gui/hotkeybutton.gui")
        self.buttonBar_2.script.name="ProficienciesWindowToggle"
        self.buttonBar_2.position.x = self.buttonBar_2.position.x + 64 
        self.buttonBar_2.textureName = "gui/maps/icons/rz_WK_Student.dds" 
        self.hotkeybarGui.addChild(self.buttonBar_2, "buttonBar_2")
        self.buttonBar_2.script.setFx("onMouseEnter", FX.fxNop())   # override default Button FX
        self.buttonBar_2.script.setFx("onMouseLeave", FX.fxNop())
        
        # the proficiencies window
        self.proficienciesWindow = ProficienciesWindow()
        self.root.addChild(self.proficienciesWindow.Gui, "proficienciesGui")
        self.proficienciesWindow.setVisible(False)
        self.addListener(self, GuiEvent('ProficienciesWindowToggle'))

        # the avatar hud
        self.avatarHud = AvatarHud()
        self.root.addChild(self.avatarHud.Gui, "AvatarHud")

    def addHotkey(self, key, name):
        self.hotkeys[key] = name
        
    # -------------------------------------------------------------------------
    # EVENT HANLDING  
    # -------------------------------------------------------------------------
    
    # We handle some gui events ourselves 
    def handleGuiEvent(self, guiEvent):
        eventName = guiEvent.name
        eventAction = guiEvent.action
        # print "AnGUI.handleGuiEvent(): event.name=%s event.action=%s" % (eventName, eventAction)
        if eventName == "ProficienciesWindowToggle":
            self.proficienciesWindow.toggleActive()

    # handle key events from BigWorld 
    # these are actually passed in here from the personality script
    def handleKeyEvent(self, down, key, mods ):
        # scroll player chat console if we can
        chatConsole = self.console
        if chatConsole and chatConsole.script.isActive:
            if down and key == KEY_PGUP:
                chatConsole.script.scrollUp()
                return True
            elif down and key == KEY_PGDN:
                chatConsole.script.scrollDown()
                return True
            elif down and (key == KEY_RETURN and mods == 0):
                # check if the in game menu is active
                if not chatConsole.script.editing:
                    chatConsole.script.edit(1)     # if already editing then
                    return True                       #  it'll catch return above
            elif down and (key == KEY_SLASH and mods == 0):
                # check if the in game menu is active
                if not chatConsole.script.editing:
                    chatConsole.script.edit(1)  # if already editing then it'll catch return above
                    return True
            elif down and (key == KEY_ESCAPE and mods == 0) and chatConsole.script.component.visible:
                chatConsole.script.hideNow()
                return True

        # ALT-P: Python Console
        if down and key == KEY_P and mods == MODIFIER_ALT:
            BigWorld.setWatcher("Debug/activeConsole", "Python")
            return True

        # hotkeys 
        if self.hotkeys.has_key(key):
            # self.hotkeys stores event names in a directory keyed by key_code
            if down:
                self.dispatchGuiEvent(GuiEvent(self.hotkeys[key], 'ACTIVATE'))
            else:
                self.dispatchGuiEvent(GuiEvent(self.hotkeys[key], 'RELEASE'))
            
            return True
        
        # pass through to the other GUI elements we still use
        # print "Calling PyGUI.handleKeyEvent()"
        handled = PyGUI.handleKeyEvent( down, key, mods )
        # print "Calling SYSGUI.handleKeyEvent()"
        # this will also pass through event into AnGUI
        handled =  GUI.handleKeyEvent(down, key, mods)

        return handled
    

    # anyone can register themselves here for notification (via callback) passing in
    # a triggers ( a tuple ["TriggerName", "TriggerAction"] ) they are interested in
    # the caller needs to implement a function handleGuiEvent(self, event)
    def addListener(self, listener, guiEvent):
        # directory entries here tuples: (listener, guiEvent)
        # print "AnGUI.addListener() id=%s eventName=%s" % (listener.id, guiEvent.name)
        key = guiEvent.name
        try:
            list = self.listeners[key]
        except:
            list = []
            self.listeners[key] = list
            
        list.append([listener, guiEvent])

    def cancelListener(self, listener):
        ''' cancelListener() removes all event listen entries for a given object from the AnGUI listners directory
            @param: listener is the object to remove '''
            
        for list in self.listeners.values():
            delEntries = []
            for entry in list:
                if entry[0] == listener:
                    delEntries.append(list.index(entry))
                    
            for index in delEntries:
                # print "DELETING LISTENER"
                del list[index]
                
    # called by our own components like HotButtons etc
    def dispatchGuiEvent(self, guiEvent):
        print "AnGUI.dispatchGuiEvent(): event.name=%s event.action=%s" % (guiEvent.name, guiEvent.action)
        key = guiEvent.name
        try:
            list = self.listeners[key]
        except:
            return  # no listeners registered
        
        for entry in list:
            listenerEvent = entry[1]
            if listenerEvent.action == 'ANY' or listenerEvent.action == guiEvent.action:    
                listener = entry[0]
                # print "calling", listener
                listener.handleGuiEvent(guiEvent)  # ok, pass it over ...
            else:
                pass
                print "guiEvent.match() no match"


service = AnGUI()