vanilla-wow-addons – Rev 1
?pathlinks?
-- Old mappings now deprecated. Left here to support addons already using them,
-- but these will be removed in the future, so update to the new format.
MYBINDINGS_CATEGORY_BARS = "bars"
MYBINDINGS_CATEGORY_CHAT = "chat"
MYBINDINGS_CATEGORY_CLASS = "class"
MYBINDINGS_CATEGORY_COMBAT = "combat"
MYBINDINGS_CATEGORY_COMPILATIONS = "compilations"
MYBINDINGS_CATEGORY_INTERFACE = "interface"
MYBINDINGS_CATEGORY_INVENTORY = "inventory"
MYBINDINGS_CATEGORY_MAP = "map"
MYBINDINGS_CATEGORY_OTHERS = "others"
MYBINDINGS_CATEGORY_PROFESSIONS = "professions"
MYBINDINGS_CATEGORY_QUESTS = "quests"
MYBINDINGS_CATEGORY_RAID = "raid"
-- Key binding to open up the myBindings window.
BINDING_HEADER_MYBINDINGS = MYBINDINGS_NAME
BINDING_CATEGORY_MYBINDINGS = "interface"
BINDING_NAME_MYBINDINGS_OPEN = MYBINDINGS_KEYBIND_OPEN
--[[--------------------------------------------------------------------------
Class Definition
-----------------------------------------------------------------------------]]
myBindings = AceAddonClass:new({
name = MYBINDINGS_NAME,
description = MYBINDINGS_DESCRIPTION,
category = BINDING_CATEGORY_MYBINDINGS,
optionsFrame = "myBindingsOptionsFrame",
version = "1.3",
releaseDate = "10-11-2005",
author = "Turan",
email = "turan@wowace.com",
website = "http://www.wowace.com",
aceCompatible = "100",
db = AceDbClass:new("myBindingsDB"),
cmd = AceChatCmdClass:new(MYBINDINGS_COMMANDS, MYBINDINGS_CMD_OPTIONS),
maxMenuLines = 18,
maxMenuLineHeight = 22,
maxBindingLines = 17,
maxBindingLineHeight = 25,
categoriesSort = {
MYBINDINGS_CATEGORY_GAME,
ACE_CATEGORY_BARS,
ACE_CATEGORY_CHAT,
ACE_CATEGORY_CLASS,
ACE_CATEGORY_COMBAT,
ACE_CATEGORY_COMPILATIONS,
ACE_CATEGORY_INTERFACE,
ACE_CATEGORY_INVENTORY,
ACE_CATEGORY_MAP,
ACE_CATEGORY_OTHERS,
ACE_CATEGORY_PROFESSIONS,
ACE_CATEGORY_QUESTS,
ACE_CATEGORY_RAID
},
gameBindings = {},
currentMenuSelection = nil,
confirmKeyBind = nil
})
myBindings:RegisterForLoad()
function myBindings:Initialize()
if( myBindings_LoadCategories ) then myBindings_LoadCategories() end
self.Msg = function(...) self.cmd:result(format(unpack(arg))) end
self.Error = function(...) self.cmd:result(ACEG_LABEL_ERROR, " ", format(unpack(arg))) end
self.savedKeyBindingFrame = KeyBindingFrame
self.frame = myBindingsOptionsFrame
self.currentProfile = self.profilePath[2]
end
-- Data Management
function myBindings:GetBind(val)
if( not val ) then
return self.db:get(self.profilePath, "bindings")
else
return self.db:get({self.profilePath, "bindings"}, val)
end
end
function myBindings:SetBind(var, val)
self.db:set({self.profilePath, "bindings"}, var, val)
end
function myBindings:ClearBinds()
self.db:set(self.profilePath, "bindings")
end
function myBindings:GetCat(var)
return self.db:get({"categories"}, var)
end
function myBindings:SetCat(var, val)
self.db:set({"categories"}, var, val)
end
--
function myBindings:Enable()
-- Override the existing key bindings dialog so that myBindingsOptionsFrame will
-- get called just like any other UIPanel frame.
KeyBindingFrame = myBindingsOptionsFrame
GameMenuButtonKeybindings:Hide()
myBindingsGameMenuButton:Show()
self:RegisterEvent("ACE_PROFILE_LOADED")
self:SetGameBindings()
self:ParseBindings()
self:LoadBindings(GetCurrentBindingSet())
self:UpdateLoadedLabel()
UIPanelWindows[self.optionsFrame] = {area = "center", pushable = 0}
self.frame.selected = nil
end
function myBindings:Disable()
KeyBindingFrame = self.savedKeyBindingFrame
GameMenuButtonKeybindings:Show()
myBindingsGameMenuButton:Hide()
end
function myBindings:ACE_PROFILE_LOADED()
if( self.profilePath[2] == self.currentProfile ) then return end
self.currentProfile = self.profilePath[2]
self:LoadBindings(GetCurrentBindingSet())
self:UpdateLoadedLabel()
end
--[[--------------------------------------------------------------------------
Initialize Bindings List
-----------------------------------------------------------------------------]]
function myBindings:SetGameBindings()
-- This is just a reference list to check later which bindings are part of the
-- standard game controls.
self.gameBindings[BINDING_HEADER_ACTIONBAR] = 1
self.gameBindings[BINDING_HEADER_CAMERA] = 1
self.gameBindings[BINDING_HEADER_CHAT] = 1
self.gameBindings[BINDING_HEADER_INTERFACE] = 1
self.gameBindings[BINDING_HEADER_MISC] = 1
self.gameBindings[BINDING_HEADER_MOVEMENT] = 1
self.gameBindings[BINDING_HEADER_TARGETING] = 1
self.gameBindings[BINDING_HEADER_MULTIACTIONBAR] = 1
self.gameBindings[BINDING_HEADER_BLANK] = 1
self.gameBindings[BINDING_HEADER_BLANK2] = 1
self.gameBindings[BINDING_HEADER_BLANK3] = 1
end
function myBindings:ParseBindings()
local categories = {}
local commandName, binding1, binding2, header, addOnCat
self.menuHeaders = {}
self.bindingIndexes = {}
self.expandedCategories = {}
for index = 1, GetNumBindings(), 1 do
commandName, binding1, binding2 = GetBinding(index)
if( strsub(commandName, 1, 6) == "HEADER" ) then
header = getglobal("BINDING_"..commandName)
if( (header or "") == "" ) then header = strsub(commandName, 8) end
self.bindingIndexes[header] = {}
-- Add to appropriate category
if( self.gameBindings[header] ) then
if( not categories[MYBINDINGS_CATEGORY_GAME] ) then
categories[MYBINDINGS_CATEGORY_GAME] = {}
end
table.insert(categories[MYBINDINGS_CATEGORY_GAME], header)
else
addOnCat = getglobal(
"ACE_CATEGORY_"..
strupper(
self:GetCat(strsub(commandName, 8)) or
getglobal("BINDING_CATEGORY_"..strsub(commandName, 8)) or
"others"
)
) or ACE_CATEGORY_OTHERS
if( not categories[addOnCat] ) then categories[addOnCat] = {} end
table.insert(categories[addOnCat], header)
end
elseif( header ) then
-- Need to save the index so it can be used later to reference this command
-- in the API's bindings list.
table.insert(self.bindingIndexes[header], index)
end
end
-- Now place all the sorted categories and headers into one list for easy
-- display later on.
for index, category in self.categoriesSort do
if( categories[category] ) then
table.sort(categories[category])
table.insert(self.menuHeaders, {text=category, isCategory=TRUE})
for i, header in categories[category] do
table.insert(self.menuHeaders, {text=header, category=category})
end
end
end
end
--[[--------------------------------------------------------------------------
Dialog Handling Methods
-----------------------------------------------------------------------------]]
function myBindings:HeadingsUpdate()
local numHeaders = table.getn(self.menuHeaders)
local offset = FauxScrollFrame_GetOffset(myBindingsOptionsHeadingsScrollFrame)
local hdrinx = 0
local visible = 0
local line = 0
local header, menuItem, button
-- In case we were waiting for a key bind confirmation, cancel it.
self:CancelKeyBind()
-- Browse the lines
while ( line < self.maxMenuLines ) do
if( ((offset + line) <= numHeaders) and (hdrinx < numHeaders) ) then
hdrinx = hdrinx + 1
header = self.menuHeaders[hdrinx]
if( header.isCategory ) then
visible = visible + 1
if( visible > offset ) then
line = line + 1
getglobal("myBindingsOptionsBindCategory"..line.."NormalText"):SetText(header.text)
-- getglobal("myBindingsOptionsBindCategory"..line.."HighlightText"):SetText(header.text)
getglobal("myBindingsOptionsBindCategory"..line):Show()
getglobal("myBindingsOptionsBindHeader"..line):Hide()
end
elseif( self.expandedCategories[header.category] ) then
visible = visible + 1
if( visible > offset ) then
line = line + 1
menuItem = getglobal("myBindingsOptionsBindHeader"..line)
button = getglobal("myBindingsOptionsBindHeader"..line.."Button")
getglobal("myBindingsOptionsBindHeader"..line.."ButtonNormalText"):SetText(header.text)
-- getglobal("myBindingsOptionsBindHeader"..line.."ButtonHighlightText"):SetText(header.text)
getglobal("myBindingsOptionsBindCategory"..line):Hide()
menuItem:Show()
if( self.currentMenuSelection == header.text ) then
myBindingsOptionsFrameBindingsTitle:SetText(header.text)
menuItem:SetBackdropBorderColor(.9, .9, 0)
menuItem:SetBackdropColor(1.0, 1.0, 0.5)
button:LockHighlight()
else
menuItem:SetBackdropBorderColor(0.4, 0.4, 0.4)
menuItem:SetBackdropColor(0.15, 0.15, 0.15)
button:UnlockHighlight()
end
self.frame.highlightID = self.frame:GetParent():GetID()
end
end
else
line = line + 1
getglobal("myBindingsOptionsBindCategory"..line):Hide()
getglobal("myBindingsOptionsBindHeader"..line):Hide()
end
end
FauxScrollFrame_Update(myBindingsOptionsHeadingsScrollFrame,
self:GetMenuNumVisible(),
self.maxMenuLines,
self.maxMenuLineHeight
)
end
function myBindings:ExpandCollapseHeadings(val)
for index, header in self.menuHeaders do
if( header.isCategory ) then
self.expandedCategories[header.text] = val
end
end
end
function myBindings:GetMenuNumVisible()
local numVisible = 0
for index = 1, table.getn(self.menuHeaders), 1 do
if( self.menuHeaders[index].isCategory ) then
numVisible = numVisible + 1
elseif( self.expandedCategories[self.menuHeaders[index].category] ) then
numVisible = numVisible + 1
end
end
return numVisible
end
function myBindings:CategoryOnClick(text)
self.expandedCategories[text] = (not self.expandedCategories[text])
self:HeadingsUpdate()
end
function myBindings:HeaderOnClick()
self.currentMenuSelection = this:GetText()
self:HeadingsUpdate()
self:BindingsUpdate()
end
--[[--------------------------------------------------------------------------
Bindings ScrollFrame Methods
-----------------------------------------------------------------------------]]
-- Copied from Blizzard's UI as a temporary fix for game patch 1800. Since the
-- default key binding frame is no longer loaded at start, this function is
-- not available if the default key bind frame is never opened, which it probably
-- never is if someone is using myBindings. 10/11/2005
function KeyBindingFrame_GetLocalizedName(name, prefix)
if ( not name ) then
return "";
end
local tempName = name;
local i = strfind(name, "-");
local dashIndex = nil;
while ( i ) do
if ( not dashIndex ) then
dashIndex = i;
else
dashIndex = dashIndex + i;
end
tempName = strsub(tempName, i + 1);
i = strfind(tempName, "-");
end
local modKeys = '';
if ( not dashIndex ) then
dashIndex = 0;
else
modKeys = strsub(name, 1, dashIndex);
if ( GetLocale() == "deDE") then
modKeys = gsub(modKeys, "CTRL", "STRG");
end
end
local variablePrefix = prefix;
if ( not variablePrefix ) then
variablePrefix = "";
end
local localizedName = nil;
if ( IsMacClient() ) then
-- see if there is a mac specific name for the key
localizedName = getglobal(variablePrefix..tempName.."_MAC");
end
if ( not localizedName ) then
localizedName = getglobal(variablePrefix..tempName);
end
if ( not localizedName ) then
localizedName = tempName;
end
return modKeys..localizedName;
end
function myBindings:BindingsUpdate()
local header = self.currentMenuSelection
local indexes = self.bindingIndexes[header]
local scrollOffset = FauxScrollFrame_GetOffset(myBindingsOptionsBindingsScrollFrame)
local bindLine, commandName, numCommands, keyOffset
local keyBindingButton1, keyBindingButton1NormalTexture, keyBindingButton1PushedTexture,
keyBindingButton2, keyBindingButton2NormalTexture, keyBindingButton2PushedTexture,
keyBindingDescription
-- In case we were waiting for a key bind confirmation, cancel it.
if( not myBindingsOptionsBindingsScrollFrame.buttonPressed ) then
self:CancelKeyBind()
end
if( indexes ) then
numCommands = table.getn(indexes)
else
numCommands = 0
end
-- Browse the lines
for line = 1, self.maxBindingLines, 1 do
keyOffset = scrollOffset + line
keyBindingButton1 = getglobal("myBindingsOptionsBindingLine"..line.."Key1Button")
keyBindingButton2 = getglobal("myBindingsOptionsBindingLine"..line.."Key2Button")
if( keyOffset <= numCommands ) then
bindLine = getglobal("myBindingsOptionsBindingLine"..line)
commandName, binding1, binding2 = GetBinding(self.bindingIndexes[header][keyOffset])
keyBindingButton1NormalTexture = getglobal("myBindingsOptionsBindingLine"..line.."Key1ButtonNormalTexture")
keyBindingButton1PushedTexture = getglobal("myBindingsOptionsBindingLine"..line.."Key1ButtonPushedTexture")
keyBindingButton2NormalTexture = getglobal("myBindingsOptionsBindingLine"..line.."Key2ButtonNormalTexture")
keyBindingButton2PushedTexture = getglobal("myBindingsOptionsBindingLine"..line.."Key2ButtonPushedTexture")
keyBindingLabel = getglobal("myBindingsOptionsBindingLine"..line.."Label")
keyBindingLabel:SetText(KeyBindingFrame_GetLocalizedName(commandName, "BINDING_NAME_"))
if( binding1 ) then
keyBindingButton1:SetText(
KeyBindingFrame_GetLocalizedName(binding1, "KEY_")
)
keyBindingButton1:SetAlpha(1)
else
keyBindingButton1:SetText(NORMAL_FONT_COLOR_CODE..NOT_BOUND..FONT_COLOR_CODE_CLOSE)
keyBindingButton1:SetAlpha(0.8)
end
if( binding2 ) then
keyBindingButton2:SetText(
KeyBindingFrame_GetLocalizedName(binding2, "KEY_")
)
keyBindingButton2:SetAlpha(1)
else
keyBindingButton2:SetText(NORMAL_FONT_COLOR_CODE..NOT_BOUND..FONT_COLOR_CODE_CLOSE)
keyBindingButton2:SetAlpha(0.8)
end
if( myBindingsOptionsBindingsScrollFrame.selected == commandName ) then
if( myBindingsOptionsBindingsScrollFrame.keyID == 1 ) then
keyBindingButton1:LockHighlight()
keyBindingButton2:UnlockHighlight()
else
keyBindingButton2:LockHighlight()
keyBindingButton1:UnlockHighlight()
end
else
keyBindingButton1:UnlockHighlight()
keyBindingButton2:UnlockHighlight()
end
keyBindingButton1.commandName = commandName
keyBindingButton2.commandName = commandName
bindLine:Show()
else
keyBindingButton1.commandName = nil
keyBindingButton2.commandName = nil
getglobal("myBindingsOptionsBindingLine"..line):Hide()
end
end
FauxScrollFrame_Update(myBindingsOptionsBindingsScrollFrame,
numCommands,
self.maxBindingLines,
self.maxBindingLineHeight
)
end
function myBindings:DeselectButton()
myBindingsOptionsFrameOutputText:SetText("")
myBindingsOptionsBindingsScrollFrame.selected = nil
myBindingsOptionsBindingsScrollFrame.buttonPressed = nil
myBindingsOptionsBindingsScrollFrame.keyID = nil
self:BindingsUpdate()
end
function myBindings:BindingOnClick(button)
if( myBindingsOptionsBindingsScrollFrame.buttonPressed == this ) then
-- Code to be able to deselect or select another key to bind
if( button == "LeftButton" or button == "RightButton" ) then
-- Deselect button if it was the pressed previously pressed
self:DeselectButton()
else
self:OnKeyDown(button)
end
else
myBindingsOptionsFrameUnbindButton:Enable()
myBindingsOptionsBindingsScrollFrame.selected = this.commandName
myBindingsOptionsBindingsScrollFrame.buttonPressed = this
myBindingsOptionsBindingsScrollFrame.keyID = this:GetID()
myBindingsOptionsFrameOutputText:SetText(
format(BIND_KEY_TO_COMMAND,
KeyBindingFrame_GetLocalizedName(this.commandName, "BINDING_NAME_")
)
)
self:BindingsUpdate()
end
end
function myBindings:OnKeyDown(button)
if( arg1 == "PRINTSCREEN" ) then
Screenshot()
return
end
-- Convert the mouse button names
if( button == "LeftButton" ) then
button = "BUTTON1"
elseif( button == "RightButton" ) then
button = "BUTTON2"
elseif( button == "MiddleButton" ) then
button = "BUTTON3"
elseif( button == "Button4" ) then
button = "BUTTON4"
elseif( button == "Button5" ) then
button = "BUTTON5"
end
if( myBindingsOptionsBindingsScrollFrame.selected ) then
local keyPressed = arg1
if( button ) then
if( button == "BUTTON1" or button == "BUTTON2" ) then
return
end
keyPressed = button
else
keyPressed = arg1
end
if( keyPressed == "UNKNOWN" ) then
return
end
if( keyPressed == "SHIFT" or keyPressed == "CTRL" or keyPressed == "ALT") then
return
end
if( IsShiftKeyDown() ) then
keyPressed = "SHIFT-"..keyPressed
end
if( IsControlKeyDown() ) then
keyPressed = "CTRL-"..keyPressed
end
if( IsAltKeyDown() ) then
keyPressed = "ALT-"..keyPressed
end
local oldAction = GetBindingAction(keyPressed)
if( (oldAction ~= "") and (oldAction ~= myBindingsOptionsBindingsScrollFrame.selected) ) then
local key1, key2 = GetBindingKey(oldAction)
if( (not key1 or key1 == keyPressed) and ((not key2) or (key2 == keyPressed)) ) then
--Error message
myBindingsOptionsFrameOutputText:SetText(
format(MYBINDINGS_BOUND_ERROR,
keyPressed,
KeyBindingFrame_GetLocalizedName(oldAction, "BINDING_NAME_")
)
)
self.confirmKeyBind = TRUE
end
end
if( self.confirmKeyBind ) then
myBindingsOptionsFrameConfirmBindButton:Show()
myBindingsOptionsFrameConfirmBindButton.keyPressed = keyPressed
myBindingsOptionsFrameCancelBindButton:Show()
else
self:BindKey(keyPressed)
end
else
if( arg1 == "ESCAPE" ) then
LoadBindings(GetCurrentBindingSet())
myBindingsOptionsFrameOutputText:SetText("")
myBindingsOptionsBindingsScrollFrame.selected = nil
HideUIPanel(this)
end
end
end
function myBindings:BindKey(keyPressed)
local key1, key2 = GetBindingKey(myBindingsOptionsBindingsScrollFrame.selected)
if( key1 ) then SetBinding(key1); end
if( key2 ) then SetBinding(key2); end
if( myBindingsOptionsBindingsScrollFrame.keyID == 1 ) then
self:SetBinding(keyPressed, myBindingsOptionsBindingsScrollFrame.selected, key1)
if( key2 ) then
SetBinding(key2, myBindingsOptionsBindingsScrollFrame.selected)
end
else
if( key1 ) then
self:SetBinding(key1, myBindingsOptionsBindingsScrollFrame.selected)
end
self:SetBinding(keyPressed, myBindingsOptionsBindingsScrollFrame.selected, key2)
end
myBindingsOptionsBindingsScrollFrame.selected = nil
myBindingsOptionsBindingsScrollFrame.buttonPressed = nil
self:BindingsUpdate()
myBindingsOptionsFrameOutputText:SetText(KEY_BOUND)
end
function myBindings:SetBinding(key, selectedBinding, oldKey)
if( SetBinding(key, selectedBinding) ) then
return
else
if( oldKey ) then
SetBinding(oldKey, selectedBinding)
end
--Error message
myBindingsOptionsFrameOutputText:SetText(
"Can't bind mousewheel to actions with up and down states"
)
end
end
function myBindings:ConfirmKeyBind()
self:BindKey(this.keyPressed)
end
function myBindings:CancelKeyBind()
self.confirmKeyBind = FALSE
-- Button highlighting stuff
myBindingsOptionsBindingsScrollFrame.selected = nil
if( myBindingsOptionsBindingsScrollFrame.buttonPressed ) then
myBindingsOptionsBindingsScrollFrame.buttonPressed:UnlockHighlight()
myBindingsOptionsBindingsScrollFrame.buttonPressed = nil
end
myBindingsOptionsFrameConfirmBindButton:Hide()
myBindingsOptionsFrameConfirmBindButton.keyPressed = nil
myBindingsOptionsFrameCancelBindButton:Hide()
myBindingsOptionsFrameUnbindButton:Disable()
myBindingsOptionsFrameOutputText:SetText("")
end
function myBindings:UnbindKey()
if( not myBindingsOptionsBindingsScrollFrame.selected ) then return end
local key1, key2 = GetBindingKey(myBindingsOptionsBindingsScrollFrame.selected)
if( myBindingsOptionsBindingsScrollFrame.keyID == 1 ) then
if( key1 ) then SetBinding(key1) end
if( key2 ) then
SetBinding(key2, myBindingsOptionsBindingsScrollFrame.selected)
end
elseif( key2 ) then SetBinding(key2)
end
self:CancelKeyBind()
self:BindingsUpdate()
end
--[[--------------------------------------------------------------------------
Binding Methods
-----------------------------------------------------------------------------]]
function myBindings:LoadGameDefaultBindings()
LoadBindings(DEFAULT_BINDINGS)
self:BindingsUpdate()
end
function myBindings:LoadBindings()
-- If there's no binding set in the current profile, don't do anything or this
-- will wipe out all settings, leaving mouse-control of the game only.
if( not self:GetBind() ) then return end
local commandName, binding1, binding2, command
for index = 1, GetNumBindings(), 1 do
commandName, binding1, binding2 = GetBinding(index)
-- I don't know why, but if the bindings aren't first erased, then attempting
-- to overwrite the values from the stored values will wipe out all the second
-- key bindings. They need clearing anyway in case the stored binding set
-- doesn't have values, meaning these bindings should be empty.
if( binding1 ) then SetBinding(binding1) end
if( binding2 ) then SetBinding(binding2) end
command = self:GetBind(commandName)
if( command ) then
if( command.bind1 ) then SetBinding(command.bind1, commandName, binding1) end
if( command.bind2 ) then SetBinding(command.bind2, commandName, binding2) end
end
end
SaveBindings(GetCurrentBindingSet())
self:BindingsUpdate()
end
function myBindings:SaveBindings()
-- Save the bindings in the system first.
SaveBindings(GetCurrentBindingSet())
local commandName, binding1, binding2
-- Empty the stored bindings first.
self:ClearBinds()
for index = 1, GetNumBindings(), 1 do
commandName, binding1, binding2 = GetBinding(index)
local key1, key2 = GetBindingKey(commandName)
-- Don't save empty bindings
if( binding1 or binding2 ) then
self:SetBind(commandName, {bind1 = binding1, bind2 = binding2})
end
end
self:CloseInterface()
end
--[[--------------------------------------------------------------------------
Display Methods
-----------------------------------------------------------------------------]]
function myBindings:UpdateLoadedLabel()
myBindingsOptionsFrameBindingsLoadedLabel:SetText(
format(MYBINDINGS_LABEL_BINDINGS_LOADED, self.profilePath[2])
)
end
function myBindings:OpenInterface()
if( self.disabled ) then return; end
if( not self.frame:IsVisible() ) then
ShowUIPanel(self.frame)
self.dontOpenGameMenu = TRUE
self:HeadingsUpdate()
self:BindingsUpdate()
end
end
function myBindings:CloseInterface()
myBindingsOptionsBindingsScrollFrame.selected = nil
HideUIPanel(self.frame)
end
function myBindings:OnShow()
self:HeadingsUpdate()
self:BindingsUpdate()
end
function myBindings:OnHide()
self:CancelKeyBind()
-- Check if it's currently showing an options frame or the myAddOns options frame.
if( (not MYADDONS_ACTIVE_OPTIONSFRAME) and
(not self.dontOpenGameMenu) and
( (not myAddOnsFrame) or (not myAddOnsFrame:IsVisible())) ) then
ShowUIPanel(GameMenuFrame)
-- Check if the options frame was opened by myAddOns
elseif( MYADDONS_ACTIVE_OPTIONSFRAME == this ) then
ShowUIPanel(myAddOnsFrame)
end
self.dontOpenGameMenu = FALSE
end
--[[--------------------------------------------------------------------------
Chat Handlers
-----------------------------------------------------------------------------]]
function myBindings:SetCategory(opt)
local header, cat = unpack(ace.ParseWords(opt))
if( (not header) or (not cat) ) then
self.Error(MYBINDINGS_TEXT_INVALID_ENTRY)
return
elseif( not getglobal("ACE_CATEGORY_"..strupper(cat)) ) then
self.Error(MYBINDINGS_TEXT_CAT_INVALID, cat)
return
end
local try, valid = getglobal("BINDING_HEADER_"..header)
if( try ) then
valid = header
else
try = getglobal("BINDING_HEADER_"..strlower(header))
if( try ) then
valid = strlower(header)
else
try = getglobal("BINDING_HEADER_"..strupper(header))
if( try ) then
valid = strupper(header)
else
self.Error(MYBINDINGS_TEXT_HDR_INVALID, header)
return
end
end
end
self:SetCat(valid, cat)
self:ParseBindings()
self.Msg(MYBINDINGS_TEXT_CAT_SET, valid, getglobal("ACE_CATEGORY_"..strupper(cat)))
end
function myBindings:SetBindOpt(opt)
local oldaction = nil
local key, action = unpack(ace.ParseWords(opt))
key = string.upper(key)
-- Attempt to clear the binding. If this is an invalid key, it'll fail.
oldaction = GetBindingAction( key )
if not SetBinding(key, nil) then
if not SetBinding(key, oldaction) then
self.cmd:msg( "Error - " .. key .. " is not a valid key!" )
end
elseif action then
if SetBinding(key, action) then
self.cmd:msg( "Key " .. key .. " successfully bound to action " .. action .. ".")
else
self.cmd:msg( "Action " .. action .. " is not valid!" )
SetBinding(key, oldaction)
end
else
self.cmd:msg( "Key " .. key .. " cleared." )
end
end