local HealBot_Options_ComboButtons_Button=1;
local HealBot_Options_ResetSkins=false;
local HealBot_Options_Opened=false;
local HealBot_Options_SoftReset_flag=false;
local HealBot_buffbarcolr = {};
local HealBot_buffbarcolg = {};
local HealBot_buffbarcolb = {};
local HealBot_Skins = {};
local HealBot_DebuffWatchTarget={}
local HealBot_DebuffPriority="none"
local HealBot_BuffWatchTarget={}
local BuffTextClass=nil
local strtrim=strtrim
local strsub=strsub
local tonumber=tonumber
local floor=floor
local HealBot_Action_SetAllAttribs_flag=false
local class=nil
local mins,secs=0,0
local DoInitTab1=true
local DoInitTab2=true
local DoInitTab3=true
local DoInitTab4=true
local DoInitTab5=true
local DoInitTab6=true
local DoInitTab7=true
local DoInitTab8=true
local bar=nil
local sName=nil
local sRank=nil
local dName=nil
local id=nil
local sID=nil
local val=nil
local text=nil
local unique=nil
local x,k,j=nil,nil,nil
local textures=nil
local texturesIndex={}
local fonts=nil
local fontsIndex={}
local sounds=nil
local soundsIndex={}
local updatingMedia=false
local LSM = LibStub("LibSharedMedia-3.0")
local uGUID=nil
local BuffWatchName=nil
local ClickedBuffGroupDD=nil
local tGUID=nil
local tName=nil
local HealBot_Debuff_Spells = {
  ["PALA"] = {
    HEALBOT_PURIFY,
    HEALBOT_CLEANSE,
    HEALBOT_BLESSING_OF_FREEDOM,
                      },
  ["DRUI"] = {
    HEALBOT_CURE_POISON,
    HEALBOT_REMOVE_CURSE,
    HEALBOT_ABOLISH_POISON,
                    },
  ["PRIE"] = {
    HEALBOT_CURE_DISEASE,
    HEALBOT_DISPEL_MAGIC,
    HEALBOT_ABOLISH_DISEASE,
                     },
  ["SHAM"] = {
    HEALBOT_CURE_TOXINS,
    HEALBOT_CLEANSE_SPIRIT,
                       },
  ["HUNT"] = {},
  ["MAGE"] = {HEALBOT_REMOVE_CURSE,},
  ["ROGU"] = {},
  ["WARL"] = {},
  ["WARR"] = {},
  ["DEAT"] = {},
}

local HealBot_Racial_Debuff_Spells = {
  ["Hum"] = {},
  ["Dwa"] = {HEALBOT_STONEFORM,},
  ["Nig"] = {},
  ["Gno"] = {},
  ["Dra"] = {},
  ["Orc"] = {},
  ["Sco"] = {}, -- Undead
  ["Tau"] = {},
  ["Tro"] = {}, 
  ["Blo"] = {},
}

local HealBot_Debuff_Types = {
  [HEALBOT_PURIFY] = {HEALBOT_DISEASE_en, HEALBOT_POISON_en},
  [HEALBOT_CLEANSE] = {HEALBOT_DISEASE_en, HEALBOT_POISON_en, HEALBOT_MAGIC_en},
  [HEALBOT_CURE_POISON] = {HEALBOT_POISON_en},
  [HEALBOT_REMOVE_CURSE] = {HEALBOT_CURSE_en},
  [HEALBOT_ABOLISH_POISON] = {HEALBOT_POISON_en},
  [HEALBOT_CURE_DISEASE] = {HEALBOT_DISEASE_en},
  [HEALBOT_ABOLISH_DISEASE] = {HEALBOT_DISEASE_en},
  [HEALBOT_DISPEL_MAGIC] = {HEALBOT_MAGIC_en},
  [HEALBOT_REMOVE_LESSER_CURSE] = {HEALBOT_CURSE_en},
  [HEALBOT_PURIFICATION_POTION] = {HEALBOT_CURSE_en, HEALBOT_DISEASE_en, HEALBOT_POISON_en},
  [HEALBOT_ANTI_VENOM] = {HEALBOT_POISON_en},
  [HEALBOT_POWERFUL_ANTI_VENOM] = {HEALBOT_POISON_en},
  [HEALBOT_ELIXIR_OF_POISON_RES] = {HEALBOT_POISON_en},
  [HEALBOT_BLESSING_OF_FREEDOM] = {HEALBOT_MAGIC_en},
  [HEALBOT_STONEFORM] = {HEALBOT_DISEASE_en, HEALBOT_POISON_en},
  [HEALBOT_CLEANSE_SPIRIT] = {HEALBOT_DISEASE_en, HEALBOT_POISON_en, HEALBOT_CURSE_en},
  [HEALBOT_CURE_TOXINS] = {HEALBOT_DISEASE_en, HEALBOT_POISON_en},
}

local CPUProfiler=0
StaticPopupDialogs["HEALBOT_OPTIONS_RELOADUI"] = {
    text = HEALBOT_OPTIONS_RELOADUIMSG,
    button1 = HEALBOT_WORDS_YES,
    button2 = HEALBOT_WORDS_NO,
    OnAccept = function()
        ReloadUI();
    end,
    timeout = 0,
    whileDead = 1,
    hideOnEscape = 1
};

function HealBot_Options_retDebuffWatchTarget(debuffType, hbGUID)
    if HealBot_DebuffSpell[debuffType] and HealBot_Config.HealBot_BuffWatchGUID[HealBot_DebuffSpell[debuffType]] then
        return HealBot_DebuffWatchTarget[debuffType], HealBot_Config.HealBot_BuffWatchGUID[HealBot_DebuffSpell[debuffType]][hbGUID]
    else
        return HealBot_DebuffWatchTarget[debuffType], nil
    end
end

function HealBot_Options_retBuffWatchTarget(buffName, hbGUID)
    if HealBot_Config.HealBot_BuffWatchGUID[buffName] then
        return HealBot_BuffWatchTarget[buffName], HealBot_Config.HealBot_BuffWatchGUID[buffName][hbGUID]
    else
        return HealBot_BuffWatchTarget[buffName], nil
    end
end

function HealBot_Options_retDebuffPriority()
    return HealBot_DebuffPriority
end

function HealBot_Options_Pct_OnLoad(self,vText)
    self.text = vText;
    getglobal(self:GetName().."Text"):SetText(vText);
    getglobal(self:GetName().."Low"):SetText("0%");
    getglobal(self:GetName().."High"):SetText("100%");
    self:SetMinMaxValues(0.00,1.00);
    self:SetValueStep(0.01);
end

function HealBot_Options_Pct_OnLoad_MinMax(self,vText,Min,Max)
    self.text = vText;

    i=(Min*100).."%";
    j=(Max*100).."%";

    getglobal(self:GetName().."Text"):SetText(vText);
    getglobal(self:GetName().."Low"):SetText(i);
    getglobal(self:GetName().."High"):SetText(j);
    self:SetMinMaxValues(Min,Max);
    self:SetValueStep(0.01);
end

function HealBot_Options_val_OnLoad(self,vText,Min,Max)
    self.text = vText;

    getglobal(self:GetName().."Text"):SetText(vText);
    getglobal(self:GetName().."Low"):SetText(Min);
    getglobal(self:GetName().."High"):SetText(Max);
    self:SetMinMaxValues(Min,Max);
    self:SetValueStep(1);
end

function HealBot_Options_valNoCols_OnLoad(self,Min,Max)
    getglobal(self:GetName().."Text"):SetText(HealBot_Options_SetNoColsText);
    getglobal(self:GetName().."Low"):SetText(Min);
    getglobal(self:GetName().."High"):SetText(Max);
    self:SetMinMaxValues(Min,Max);
    self:SetValueStep(1);
end

function HealBot_Options_val2_OnLoad(self,vText,Min,Max,Step)
    self.text = vText;

    getglobal(self:GetName().."Text"):SetText(vText);
    getglobal(self:GetName().."Low"):SetText(Min/10);
    getglobal(self:GetName().."High"):SetText(Max/10);
    self:SetMinMaxValues(Min,Max);
    self:SetValueStep(Step);
end

function HealBot_Options_valtime_OnLoad(self,vText,Min,Max,Step,secsOnly)
    self.text = vText;

    getglobal(self:GetName().."Text"):SetText(vText);
    if secsOnly then
        getglobal(self:GetName().."Low"):SetText(Min);
        getglobal(self:GetName().."High"):SetText(Max);
    else
        getglobal(self:GetName().."Low"):SetText(Min/60);
        getglobal(self:GetName().."High"):SetText(Max/60);
    end
    self:SetMinMaxValues(Min,Max);
    self:SetValueStep(Step);
end

function HealBot_Options_SetText(self,vText)
    getglobal(self:GetName().."Text"):SetText(vText);
end

function HealBot_Options_NotifyHealMsg_OnTextChanged(self)
    HealBot_Config.NotifyHealMsg = self:GetText()
end

function HealBot_Options_NotifyOtherMsg_OnTextChanged(self)
    HealBot_Config.NotifyOtherMsg = self:GetText()
end

function HealBot_Options_SetNoColsText()
    if Healbot_Config_Skins.ShowHeader[Healbot_Config_Skins.Current_Skin]==1 then
        return HEALBOT_OPTIONS_SKINNUMHCOLS;
    else
        return HEALBOT_OPTIONS_SKINNUMCOLS;
    end
end

local pct=nil
function HealBot_Options_Pct_OnValueChanged(self)
    pct = floor(self:GetValue()*100+0.5);
    getglobal(self:GetName().."Text"):SetText(self.text .. " (" .. pct .. "%)");
    return self:GetValue();
end


function HealBot_Options_NewSkin_OnTextChanged(self)
    text= self:GetText()
    if strlen(text)>0 then
        HealBot_Options_NewSkinb:Enable();
    else
        HealBot_Options_NewSkinb:Disable();
    end
end

local NewSkinTxt=nil
function HealBot_Options_NewSkinb_OnClick(self)
    NewSkinTxt=HealBot_Options_NewSkin:GetText()
    Healbot_Config_Skins.numcols[NewSkinTxt] = Healbot_Config_Skins.numcols[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btexture[NewSkinTxt] = Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.bcspace[NewSkinTxt] = Healbot_Config_Skins.bcspace[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.brspace[NewSkinTxt] = Healbot_Config_Skins.brspace[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.bwidth[NewSkinTxt] = Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.bheight[NewSkinTxt] = Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextenabledcolr[NewSkinTxt] = Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextenabledcolg[NewSkinTxt] = Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextenabledcolb[NewSkinTxt] = Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextenabledcola[NewSkinTxt] = Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextdisbledcolr[NewSkinTxt] = Healbot_Config_Skins.btextdisbledcolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextdisbledcolg[NewSkinTxt] = Healbot_Config_Skins.btextdisbledcolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextdisbledcolb[NewSkinTxt] = Healbot_Config_Skins.btextdisbledcolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextdisbledcola[NewSkinTxt] = Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextcursecolr[NewSkinTxt] = Healbot_Config_Skins.btextcursecolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextcursecolg[NewSkinTxt] = Healbot_Config_Skins.btextcursecolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextcursecolb[NewSkinTxt] = Healbot_Config_Skins.btextcursecolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextcursecola[NewSkinTxt] = Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.backcola[NewSkinTxt] = Healbot_Config_Skins.backcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.Barcola[NewSkinTxt] = Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.BarcolaInHeal[NewSkinTxt] = Healbot_Config_Skins.BarcolaInHeal[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.backcolr[NewSkinTxt] = Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.backcolg[NewSkinTxt] = Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.backcolb[NewSkinTxt] = Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.borcolr[NewSkinTxt] = Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.borcolg[NewSkinTxt] = Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.borcolb[NewSkinTxt] = Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.borcola[NewSkinTxt] = Healbot_Config_Skins.borcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextheight[NewSkinTxt] = Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.bardisa[NewSkinTxt] = Healbot_Config_Skins.bardisa[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.bareora[NewSkinTxt] = Healbot_Config_Skins.bareora[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.bar2size[NewSkinTxt] = Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowHeader[NewSkinTxt] = Healbot_Config_Skins.ShowHeader[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headbarcolr[NewSkinTxt] = Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headbarcolg[NewSkinTxt] = Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headbarcolb[NewSkinTxt] = Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headbarcola[NewSkinTxt] = Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtxtcolr[NewSkinTxt] = Healbot_Config_Skins.headtxtcolr[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtxtcolg[NewSkinTxt] = Healbot_Config_Skins.headtxtcolg[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtxtcolb[NewSkinTxt] = Healbot_Config_Skins.headtxtcolb[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtxtcola[NewSkinTxt] = Healbot_Config_Skins.headtxtcola[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtexture[NewSkinTxt] = Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headwidth[NewSkinTxt] = Healbot_Config_Skins.headwidth[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowAggro[NewSkinTxt] = Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowAggroBars[NewSkinTxt] = Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowAggroText[NewSkinTxt] = Healbot_Config_Skins.ShowAggroText[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.UseFluidBars[NewSkinTxt] = Healbot_Config_Skins.UseFluidBars[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.BarFreq[NewSkinTxt] = Healbot_Config_Skins.BarFreq[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowHoTicons[NewSkinTxt] = Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowRaidIcon[NewSkinTxt] = Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.HoTonBar[NewSkinTxt] = Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.HoTposBar[NewSkinTxt] = Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowClassOnBar[NewSkinTxt] = Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowClassType[NewSkinTxt] = Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowNameOnBar[NewSkinTxt] = Healbot_Config_Skins.ShowNameOnBar[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowHealthOnBar[NewSkinTxt] = Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.BarHealthIncHeals[NewSkinTxt] = Healbot_Config_Skins.BarHealthIncHeals[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.BarHealthSepHeals[NewSkinTxt] = Healbot_Config_Skins.BarHealthSepHeals[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.BarHealthType[NewSkinTxt] = Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.SetClassColourText[NewSkinTxt] = Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.SetBarClassColour[NewSkinTxt] = Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.SetBarCustomColour[NewSkinTxt] = Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowDebuffIcon[NewSkinTxt] = Healbot_Config_Skins.ShowDebuffIcon[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowIconTextCount[NewSkinTxt] = Healbot_Config_Skins.ShowIconTextCount[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.ShowIconTextDuration[NewSkinTxt] = Healbot_Config_Skins.ShowIconTextDuration[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.IconScale[NewSkinTxt] = Healbot_Config_Skins.IconScale[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.IconTextScale[NewSkinTxt] = Healbot_Config_Skins.IconTextScale[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.btextfont[NewSkinTxt] = Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtextfont[NewSkinTxt] = Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.headtextheight[NewSkinTxt] = Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.AggroBarSize[NewSkinTxt] = Healbot_Config_Skins.AggroBarSize[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.TextAlignment[NewSkinTxt] = Healbot_Config_Skins.TextAlignment[Healbot_Config_Skins.Current_Skin]
    Healbot_Config_Skins.DoubleText[NewSkinTxt] = Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Current_Skin]
    unique=true;
    table.foreach(HealBot_Skins, function (index,skin)
        if skin==HealBot_Options_NewSkin:GetText() then unique=false; end
    end)
    if unique then
        table.insert(HealBot_Skins,2,NewSkinTxt)
        Healbot_Config_Skins.Skin_ID = 2;
        Healbot_Config_Skins.Skins = HealBot_Skins
        Healbot_Config_Skins.Current_Skin = NewSkinTxt
    end
    HealBot_Options_SetSkins();
    HealBot_Options_NewSkin:SetText("")
end

function HealBot_Options_DeleteSkin_OnClick(self)
    if Healbot_Config_Skins.Current_Skin~=HEALBOT_SKINS_STD then
        Healbot_Config_Skins.numcols[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btexture[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.bcspace[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.brspace[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.bwidth[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.bheight[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextenabledcolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextenabledcolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextenabledcolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextenabledcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextdisbledcolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextdisbledcolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextdisbledcolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextdisbledcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextcursecolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextcursecolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextcursecolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextcursecola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.backcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.Barcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.BarcolaInHeal[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.backcolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.backcolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.backcolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.borcolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.borcolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.borcolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.borcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextheight[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.bardisa[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.bareora[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.bar2size[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowHeader[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headbarcolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headbarcolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headbarcolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headbarcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtxtcolr[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtxtcolg[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtxtcolb[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtxtcola[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtexture[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headwidth[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowAggro[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowAggroBars[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowAggroText[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.UseFluidBars[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.BarFreq[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowHoTicons[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowRaidIcon[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.HoTonBar[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.HoTposBar[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowClassOnBar[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowClassType[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowNameOnBar[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowHealthOnBar[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.BarHealthIncHeals[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.BarHealthSepHeals[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.BarHealthType[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.SetClassColourText[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.SetBarClassColour[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.SetBarCustomColour[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowDebuffIcon[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowIconTextCount[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.ShowIconTextDuration[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.IconScale[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.IconTextScale[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.btextfont[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtextfont[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.headtextheight[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.AggroBarSize[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.TextAlignment[HealBot_Options_SkinsText:GetText()] = nil
        Healbot_Config_Skins.DoubleText[HealBot_Options_SkinsText:GetText()] = nil
        table.remove(HealBot_Skins,Healbot_Config_Skins.Skin_ID)
        Healbot_Config_Skins.Skin_ID = 1;
        Healbot_Config_Skins.Skins = HealBot_Skins;  
        Healbot_Config_Skins.Current_Skin = HEALBOT_SKINS_STD;
        HealBot_Options_SetSkins();
    end
end

function HealBot_Options_ShowHeaders_OnClick(self)
    Healbot_Config_Skins.ShowHeader[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_Options_BarNumColsSText:SetText(HealBot_Options_SetNoColsText() .. ": " .. Healbot_Config_Skins.numcols[Healbot_Config_Skins.Current_Skin]);
    HealBot_setOptions_Timer(150)
end
 
function HealBot_Options_PlaySound_OnClick(self)
    PlaySoundFile(LSM:Fetch('sound',sounds[HealBot_Options_WarningSound:GetValue()]));    
end
    
function HealBot_Options_WarningSound_OnValueChanged(self)
    if self:GetValue() > 0 and sounds then
        HealBot_Config.SoundDebuffPlay = sounds[self:GetValue()];
        getglobal(self:GetName().."Text"):SetText(self.text .. " ".. self:GetValue()..": " ..sounds[self:GetValue()]);
    else
        getglobal(self:GetName().."Text"):SetText(self.text);
    end
    if not DoInitTab4 and not updatingMedia then
        PlaySoundFile(LSM:Fetch('sound',HealBot_Config.SoundDebuffPlay));
    end
    updatingMedia=false;
end

function HealBot_Options_BarTextureS_OnValueChanged(self)
    if self:GetValue() > 0 and textures then
        Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin] = textures[self:GetValue()];
        getglobal(self:GetName().."Text"):SetText(self.text .. " "..self:GetValue()..": " .. textures[self:GetValue()]);
    else
        getglobal(self:GetName().."Text"):SetText(self.text);
    end    
    if not updatingMedia and self:GetValue() > 0 then
        HealBot_setOptions_Timer(150)
    end
    updatingMedia=false;
end

function HealBot_BarButtonIconScale_OnValueChanged(self)
    val=self:GetValue();
    val=val/10;
    Healbot_Config_Skins.IconScale[Healbot_Config_Skins.Current_Skin] = val;
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. val);
    HealBot_setOptions_Timer(150)
end

function HealBot_BarButtonIconTextScale_OnValueChanged(self)
    val=self:GetValue();
    val=val/10;
    Healbot_Config_Skins.IconTextScale[Healbot_Config_Skins.Current_Skin] = val;
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. val);
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_HeadTextureS_OnValueChanged(self)
    if self:GetValue() > 0 and textures then
        Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Current_Skin] = textures[self:GetValue()];
        getglobal(self:GetName().."Text"):SetText(self.text .. " " .. self:GetValue()..": " .. textures[self:GetValue()]);
    else
        getglobal(self:GetName().."Text"):SetText(self.text);
    end  
    if not updatingMedia and  self:GetValue() > 0 then
        HealBot_setOptions_Timer(150)
    end
    updatingMedia=false;
end

function HealBot_Options_HeadFontNameS_OnValueChanged(self)
    if self:GetValue() > 0 and fonts then
        Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin] = fonts[self:GetValue()];
        getglobal(self:GetName().."Text"):SetText(self.text .. " ".. self:GetValue()..": " ..fonts[self:GetValue()]);
    else
        getglobal(self:GetName().."Text"):SetText(self.text);
    end   
    if not updatingMedia and  self:GetValue() > 0 then
        HealBot_setOptions_Timer(150)
    end
    updatingMedia=false;
end

function HealBot_Options_HeadFontHeightS_OnValueChanged(self)
    Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarHeightS_OnValueChanged(self)
    Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarWidthS_OnValueChanged(self)
    Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarNumColsS_OnValueChanged(self)
    Healbot_Config_Skins.numcols[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(HealBot_Options_SetNoColsText() .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarBRSpaceS_OnValueChanged(self)
    Healbot_Config_Skins.brspace[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarBCSpaceS_OnValueChanged(self)
    Healbot_Config_Skins.bcspace[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_incHealsDur_OnValueChanged(self, healType)
    HealBot_Config.incHealDur[healType] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
end

function HealBot_Options_FontName_OnValueChanged(self)
    if self:GetValue() > 0 and fonts then
        Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin] = fonts[self:GetValue()];
        getglobal(self:GetName().."Text"):SetText(self.text .. " ".. self:GetValue()..": " ..fonts[self:GetValue()]);
    else
        getglobal(self:GetName().."Text"):SetText(self.text);
    end       
    if not updatingMedia and  self:GetValue() > 0 then
        HealBot_setOptions_Timer(150)
    end
    updatingMedia=false;
end

function HealBot_Options_FontHeight_OnValueChanged(self)
    Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_AggroBarSize_OnValueChanged(self)
    Healbot_Config_Skins.AggroBarSize[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_Bar2Size_OnValueChanged(self)
    Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin] = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
    HealBot_setOptions_Timer(150)
    if Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_UnRegister_Mana()
    else
        HealBot_Register_Mana()
    end
end

local HealBot_Alignment = { [1]=HEALBOT_OPTIONS_BUTTONLEFT, [2]=HEALBOT_OPTIONS_BUTTONMIDDLE, [3]=HEALBOT_OPTIONS_BUTTONRIGHT }
function HealBot_Options_TextAlign_OnValueChanged(self)
    getglobal(self:GetName().."Text"):SetText(self.text .. " ".. self:GetValue()..": " ..HealBot_Alignment[self:GetValue()]);
    if Healbot_Config_Skins.TextAlignment[Healbot_Config_Skins.Current_Skin] ~= self:GetValue() then
        Healbot_Config_Skins.TextAlignment[Healbot_Config_Skins.Current_Skin] = self:GetValue();
        StaticPopup_Show ("HEALBOT_OPTIONS_RELOADUI");
    end
end

function HealBot_Options_ActionAlpha_OnValueChanged(self)
    Healbot_Config_Skins.backcola[Healbot_Config_Skins.Current_Skin] = HealBot_Options_Pct_OnValueChanged(self);
end

function HealBot_Options_BarAlpha_OnValueChanged(self)
    Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin] = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_HeadWidthS_OnValueChanged(self)
    Healbot_Config_Skins.headwidth[Healbot_Config_Skins.Current_Skin] = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_setOptions_Timer(150)
end


function HealBot_Options_BarAlphaInHeal_OnValueChanged(self)
    Healbot_Config_Skins.BarcolaInHeal[Healbot_Config_Skins.Current_Skin] = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarAlphaDis_OnValueChanged(self)
    Healbot_Config_Skins.bardisa[Healbot_Config_Skins.Current_Skin] = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarAlphaEor_OnValueChanged(self)
    Healbot_Config_Skins.bareora[Healbot_Config_Skins.Current_Skin] = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_TTAlpha_OnValueChanged(self)
    HealBot_Config.ttalpha = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_Tooltip:SetBackdropColor(0,0,0,HealBot_Config.ttalpha)
end

local HealBot_ColourObjWaiting=nil
function HealBot_SkinColorpick_OnClick(SkinType)
    HealBot_ColourObjWaiting=SkinType;

    if SkinType=="En" then
        HealBot_UseColourPick(Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Current_Skin]);
    elseif SkinType=="Dis" then
        HealBot_UseColourPick(Healbot_Config_Skins.btextdisbledcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextdisbledcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextdisbledcolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Current_Skin])
    elseif SkinType=="Debuff" then
        HealBot_UseColourPick(Healbot_Config_Skins.btextcursecolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextcursecolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextcursecolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Current_Skin])
    elseif SkinType=="Back" then
        HealBot_UseColourPick(Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.backcola[Healbot_Config_Skins.Current_Skin])
    elseif SkinType=="Bor" then
        HealBot_UseColourPick(Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.borcola[Healbot_Config_Skins.Current_Skin])
    elseif SkinType=="HeadB" then
        HealBot_UseColourPick(Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Current_Skin])
    elseif SkinType=="HeadT" then
        HealBot_UseColourPick(Healbot_Config_Skins.headtxtcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.headtxtcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.headtxtcolb[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.headtxtcola[Healbot_Config_Skins.Current_Skin])
    elseif SkinType=="CustomBar" then
        HealBot_UseColourPick(Healbot_Config_Skins.barcolr[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.barcolg[Healbot_Config_Skins.Current_Skin],
                              Healbot_Config_Skins.barcolb[Healbot_Config_Skins.Current_Skin])
    end
end

local buffbarcolrClass=nil
local buffbarcolgClass=nil
local buffbarcolbClass=nil
function HealBot_BuffColorpick_OnClick(BuffID,id)
    HealBot_ColourObjWaiting=BuffID;
    buffbarcolrClass = HealBot_Config.HealBotBuffColR
    buffbarcolgClass = HealBot_Config.HealBotBuffColG
    buffbarcolbClass = HealBot_Config.HealBotBuffColB
    HealBot_UseColourPick(buffbarcolrClass[id],
                          buffbarcolgClass[id],
                          buffbarcolbClass[id]);
end

local btextheight=nil
local barScale=nil
function HealBot_SetSkinColours()
    btextheight=Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Current_Skin] or 10;
  
    HealBot_EnTextColorpick:SetStatusBarColor(0,1,0,Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_EnTextColorpickin:SetStatusBarColor(0,1,0,Healbot_Config_Skins.BarcolaInHeal[Healbot_Config_Skins.Current_Skin]);
    HealBot_DisTextColorpick:SetStatusBarColor(0,1,0,Healbot_Config_Skins.bardisa[Healbot_Config_Skins.Current_Skin]); 
    HealBot_Options_SetBarsTextColour()
    HealBot_HeadTextColorpickt:SetTextColor(
        Healbot_Config_Skins.headtxtcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headtxtcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headtxtcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headtxtcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_BackgroundColorpick:SetStatusBarColor(
        Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_BorderColorpick:SetStatusBarColor(
        Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_HeadBarColorpick:SetStatusBarColor(
        Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Current_Skin])
    HealBot_HeadTextColorpick:SetStatusBarColor(
        Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Current_Skin])
    HealBot_BarCustomColour:SetStatusBarColor(
        Healbot_Config_Skins.barcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.barcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.barcolb[Healbot_Config_Skins.Current_Skin]);
    HealBot_Action:SetBackdropColor(
        Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Current_Skin], 
        Healbot_Config_Skins.backcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_Action:SetBackdropBorderColor(
        Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcola[Healbot_Config_Skins.Current_Skin]);
    
    HealBot_HeadBarColorpickt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]),Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin],"");
    HealBot_HeadTextColorpickt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]),Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin],"");
    HealBot_EnTextColorpickt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]),btextheight,"");
    HealBot_DisTextColorpickt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]),btextheight,"");
    HealBot_DebTextColorpickt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]),btextheight,"");

    HealBot_EnTextColorpickt:SetText(HEALBOT_SKIN_ENTEXT);
    HealBot_DisTextColorpickt:SetText(HEALBOT_SKIN_DISTEXT);
    HealBot_DebTextColorpickt:SetText(HEALBOT_SKIN_DEBTEXT);
    barScale = HealBot_EnTextColorpick:GetScale();
    HealBot_EnTextColorpick:SetScale(barScale + 0.01);
    HealBot_EnTextColorpick:SetScale(barScale);
    HealBot_DisTextColorpick:SetScale(barScale + 0.01);
    HealBot_DisTextColorpick:SetScale(barScale);
    HealBot_DebTextColorpick:SetScale(barScale + 0.01);
    HealBot_DebTextColorpick:SetScale(barScale);
   
end

local sbR, sbG, sbB = nil, nil, nil
function HealBot_Options_SetBarsTextColour()
    if Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_EnTextColorpickt:SetTextColor(
            Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Current_Skin]);
        HealBot_DisTextColorpickt:SetTextColor(
            Healbot_Config_Skins.btextdisbledcolr[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextdisbledcolg[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextdisbledcolb[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Current_Skin]);
        HealBot_DebTextColorpickt:SetTextColor(
            Healbot_Config_Skins.btextcursecolr[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextcursecolg[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextcursecolb[Healbot_Config_Skins.Current_Skin],
            Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Current_Skin]);
    else
        sbR, sbG, sbB = HealBot_Action_ClassColour(HealBot_PlayerGUID)
        HealBot_EnTextColorpickt:SetTextColor(
            sbR,
            sbG,
            sbB,
            Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Current_Skin]);
        HealBot_DisTextColorpickt:SetTextColor(
            sbR,
            sbG,
            sbB,
            Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Current_Skin]);
        HealBot_DebTextColorpickt:SetTextColor(
            sbR,
            sbG,
            sbB,
            Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Current_Skin]);
    end
end

function HealBot_Options_AlertLevel_OnValueChanged(self)
    HealBot_Config.AlertLevel = HealBot_Options_Pct_OnValueChanged(self);
    HealBot_setOptions_Timer(80)
end

function HealBot_Options_RangeCheckFreq_OnValueChanged(self)
    val=self:GetValue();
    val=val/10;
    HealBot_Config.RangeCheckFreq = val;
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. val .." sec");
end

function HealBot_Options_BuffTimer_OnValueChanged(self,bufftype)
    val=self:GetValue();
    if bufftype=="SHORT" then
        HealBot_Config.ShortBuffTimer = val;
    else
        HealBot_Config.LongBuffTimer = val;
    end
    mins,secs=HealBot_Tooltip_ReturnMinsSecs(val)
    if mins==0 then
        getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. secs .." secs");
    else
        val=val/60;
        getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. mins ..":".. secs .." mins");
    end
    HealBot_setOptions_Timer(10)
end

function HealBot_Options_BarFreq_OnValueChanged(self)
    val=self:GetValue();
    val=val/10;
    Healbot_Config_Skins.BarFreq[Healbot_Config_Skins.Current_Skin] = val;
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. val);
end

function HealBot_Options_RangeCheckUnits_OnValueChanged(self)
    HealBot_Config.RangeCheckUnits = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
end

function HealBot_Options_AutoShow_OnClick(self)
    HealBot_Config.AutoClose = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
    if HealBot_Config.AutoClose==0 and HealBot_Config.DisableHealBot==0 then
        ShowUIPanel(HealBot_Action)
    end
end

function HealBot_Options_IgnoreDebuffsClass_OnClick(self)
    HealBot_Config.IgnoreClassDebuffs = self:GetChecked() or 0;
end

function HealBot_Options_IgnoreDebuffsNoHarm_OnClick(self)
    HealBot_Config.IgnoreNonHarmfulDebuffs = self:GetChecked() or 0;
end

function HealBot_Options_IgnoreDebuffsDuration_OnClick(self)
    HealBot_Config.IgnoreFastDurDebuffs = self:GetChecked() or 0;
end

function HealBot_Options_IgnoreDebuffsDurationSecs_OnValueChanged(self)
    HealBot_Config.IgnoreFastDurDebuffsSecs = self:GetValue();
    getglobal(self:GetName().."Text"):SetText(self.text .. ": " .. self:GetValue());
end

function HealBot_Options_IgnoreDebuffsMovement_OnClick(self)
    HealBot_Config.IgnoreMovementDebuffs = self:GetChecked() or 0;
end

function HealBot_Options_CastNotifyResOnly_OnClick(self)
    HealBot_Config.CastNotifyResOnly = self:GetChecked() or 0;
end

function HealBot_Options_ShowTooltipMyBuffs_OnClick(self)
    HealBot_Config.Tooltip_ShowMyBuffs = self:GetChecked() or 0;
end

function HealBot_Options_ShowClassOnBar_OnClick(self)
    if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then HealBot_RaidTargetToggle(nil) end
    Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(150)
    if Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_Options_ShowClassOnBarType1:Disable();
        HealBot_Options_ShowClassOnBarType2:Disable();
    else
        HealBot_Options_ShowClassOnBarType1:Enable();
        HealBot_Options_ShowClassOnBarType2:Enable();
    end
end

function HealBot_Options_ShowNameOnBar_OnClick(self)
    Healbot_Config_Skins.ShowNameOnBar[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
end

function HealBot_BarHealthIncHeal_OnClick(self)
    Healbot_Config_Skins.BarHealthIncHeals[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
end

function HealBot_BarHealthSepHeal_OnClick(self)
    Healbot_Config_Skins.BarHealthSepHeals[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
end

function HealBot_Options_PartyFrames_OnClick(self)
    HealBot_Config.HidePartyFrames = self:GetChecked() or 0;
    if HealBot_Config.HidePartyFrames==0 then
        if HealBot_Config.HidePlayerTarget==1 then
            HealBot_Options_EnablePlayerFrame();
            HealBot_Options_EnablePetFrame()
            HealBot_Options_EnableTargetFrame()
            HealBot_Config.HidePlayerTarget=0;
            HealBot_Options_PlayerTargetFrames:SetChecked(HealBot_Config.HidePlayerTarget);
        end
        HealBot_Options_PlayerTargetFrames:Disable();
        HealBot_Options_EnablePartyFrame()
    else
        HealBot_Options_PlayerTargetFrames:Enable();
        HealBot_Options_DisablePartyFrame()
    end
end

function HealBot_Options_AggroTrack_OnClick(self)
    Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    if Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_UnRegister_Aggro()
        HealBot_ClearAggro()
    else
        HealBot_Register_Aggro()
    end
    HealBot_setOptions_Timer(80)
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_UseFluidBars_OnClick(self)
    Healbot_Config_Skins.UseFluidBars[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
    HealBot_Action_Set_Timers()
end

function HealBot_Options_AggroBar_OnClick(self)
    Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_AggroTxt_OnClick(self)
    Healbot_Config_Skins.ShowAggroText[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(80)
end

function HealBot_Options_EnableLibQuickHealth_OnClick(self)
    HealBot_Config.EnLibQuickHealth = self:GetChecked() or 0;
    StaticPopup_Show ("HEALBOT_OPTIONS_RELOADUI");
end

function HealBot_Options_CPUProfiler_OnClick(self)
    CPUProfiler = self:GetChecked() or 0;
    SetCVar("scriptProfile", CPUProfiler)
    StaticPopup_Show ("HEALBOT_OPTIONS_RELOADUI");
end

function HealBot_Options_PlayerTargetFrames_OnClick(self)
    HealBot_Config.HidePlayerTarget = self:GetChecked() or 0;
    if HealBot_Config.HidePlayerTarget==0 then
        HealBot_Options_EnablePlayerFrame()
        HealBot_Options_EnablePetFrame()
        HealBot_Options_EnableTargetFrame()
    else
        HealBot_Options_DisablePlayerFrame()
        HealBot_Options_DisablePetFrame()
        HealBot_Options_DisableTargetFrame()
    end
end

function HealBot_Options_MonitorBuffs_OnClick(self)
    HealBot_Config.BuffWatch = self:GetChecked() or 0;
    if HealBot_Config.BuffWatch==0 then
        HealBot_Options_MonitorBuffsInCombat:Disable();
        HealBot_ClearAllBuffs()
        for x,_ in pairs(HealBot_UnitBuff) do
            HealBot_UnitBuff[x]=nil;
        end
    else
        HealBot_Options_MonitorBuffsInCombat:Enable();
        HealBot_setOptions_Timer(40)
    end
end

function HealBot_Options_MonitorDebuffs_OnClick(self)
    HealBot_Config.DebuffWatch = self:GetChecked() or 0;
    if HealBot_Config.DebuffWatch==0 then
        HealBot_Options_MonitorDebuffsInCombat:Disable();
        HealBot_ClearAllDebuffs()
        for x,_ in pairs(HealBot_UnitDebuff) do
            HealBot_UnitDebuff[x]=nil;
        end
    else
        HealBot_Options_MonitorDebuffsInCombat:Enable();
        HealBot_setOptions_Timer(50)
    end
end

function HealBot_Options_MonitorBuffsInCombat_OnClick(self)
    HealBot_Config.BuffWatchInCombat = self:GetChecked() or 0;
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_MonitorDebuffsInCombat_OnClick(self)
    HealBot_Config.DebuffWatchInCombat = self:GetChecked() or 0;
    HealBot_setOptions_Timer(50)
end

function HealBot_Options_CDCCol_ShowOnHealthBar_OnClick(self)
    HealBot_Config.CDCshownHB = self:GetChecked() or 0;
end

function HealBot_Options_CDCCol_ShowOnAggroBar_OnClick(self)
    HealBot_Config.CDCshownAB = self:GetChecked() or 0;
    if HealBot_Config.CDCshownAB==0 then
        HealBot_Action_ClearUnitDebuffStatus()
    end
end

function HealBot_Options_PanelSounds_OnClick(self)
    HealBot_Config.PanelSounds = self:GetChecked() or 0;
end

function HealBot_Options_ActionLocked_OnClick(self)
    HealBot_Config.ActionLocked = self:GetChecked() or 0;
end

function HealBot_Options_VisibleRange_OnClick(self)
    HealBot_Config.NotVisibleDisable = self:GetChecked() or 0;
    HealBot_Action_ResetUnitStatus()
end

local curval = 0
function HealBot_Options_DisableHealBot_OnClick(self)
    curval = self:GetChecked() or 0;
    HealBot_Options_ToggleHealBot(curval)
end

function HealBot_Options_ToggleHealBot(checkval)
    HealBot_Config.DisableHealBot=checkval
    HealBot_Options_Timer1 = 0.1
    HealBot_setOptions_Timer(500+checkval)
end

function HealBot_Options_GroupHeals_OnClick(self)
    HealBot_Config.GroupHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_TankHeals_OnClick(self)
    HealBot_Config.TankHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_SelfPet_OnClick(self)
    HealBot_Config.SelfPet = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_EmergencyHeals_OnClick(self)
    HealBot_Config.EmergencyHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_SelfHeals_OnClick(self)
    HealBot_Config.SelfHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_PetHeals_OnClick(self)
    HealBot_Config.PetHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_FocusBar_OnClick(self)
    HealBot_Config.SetFocusBar = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_MyTargetsList_OnClick(self)
    HealBot_Config.ShowMyTargetsList = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_VehicleHeals_OnClick(self)
    HealBot_Config.VehicleHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_TargetBar_OnClick(self)
    HealBot_Config.TargetHeals = self:GetChecked() or 0;
    if Delay_RecalcParty<2 then 
        Delay_RecalcParty=2; 
    end
end

function HealBot_Options_TargetIncSelf_OnClick(self)
    HealBot_Config.TargetIncSelf = self:GetChecked() or 0;
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_TargetIncGroup_OnClick(self)
    HealBot_Config.TargetIncGroup = self:GetChecked() or 0;
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_TargetIncRaid_OnClick(self)
    HealBot_Config.TargetIncRaid = self:GetChecked() or 0;
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_TargetIncPet_OnClick(self)
    HealBot_Config.TargetIncPet = self:GetChecked() or 0;
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_TargetMode_OnClick(self)
    HealBot_Config.TargetBarNormalMode = self:GetChecked() or 0;
    HealBot_SetResetFlag("SOFT")
end

function HealBot_Options_EFGroup_OnClick(self,id)
    if self:GetChecked() then
        HealBot_Config.ExtraIncGroup[id] = true;
    else
        HealBot_Config.ExtraIncGroup[id] = false;
    end
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_EFClass_OnClick(self)
    if HealBot_Config.EmergencyFClass==1 then
        HealBot_Config.EmergIncMelee[HEALBOT_DRUID] = HealBot_Options_EFClassDruid:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_HUNTER] = HealBot_Options_EFClassHunter:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_MAGE] = HealBot_Options_EFClassMage:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_PALADIN] = HealBot_Options_EFClassPaladin:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_PRIEST] = HealBot_Options_EFClassPriest:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_ROGUE] = HealBot_Options_EFClassRogue:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_SHAMAN] = HealBot_Options_EFClassShaman:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_WARLOCK] = HealBot_Options_EFClassWarlock:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_WARRIOR] = HealBot_Options_EFClassWarrior:GetChecked() or 0;
        HealBot_Config.EmergIncMelee[HEALBOT_DEATHKNIGHT] = HealBot_Options_EFClassDeathKnight:GetChecked() or 0;
    elseif HealBot_Config.EmergencyFClass==2 then
        HealBot_Config.EmergIncRange[HEALBOT_DRUID] = HealBot_Options_EFClassDruid:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_HUNTER] = HealBot_Options_EFClassHunter:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_MAGE] = HealBot_Options_EFClassMage:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_PALADIN] = HealBot_Options_EFClassPaladin:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_PRIEST] = HealBot_Options_EFClassPriest:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_ROGUE] = HealBot_Options_EFClassRogue:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_SHAMAN] = HealBot_Options_EFClassShaman:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_WARLOCK] = HealBot_Options_EFClassWarlock:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_WARRIOR] = HealBot_Options_EFClassWarrior:GetChecked() or 0;
        HealBot_Config.EmergIncRange[HEALBOT_DEATHKNIGHT] = HealBot_Options_EFClassDeathKnight:GetChecked() or 0;
    elseif HealBot_Config.EmergencyFClass==3 then
        HealBot_Config.EmergIncHealers[HEALBOT_DRUID] = HealBot_Options_EFClassDruid:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_HUNTER] = HealBot_Options_EFClassHunter:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_MAGE] = HealBot_Options_EFClassMage:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_PALADIN] = HealBot_Options_EFClassPaladin:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_PRIEST] = HealBot_Options_EFClassPriest:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_ROGUE] = HealBot_Options_EFClassRogue:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_SHAMAN] = HealBot_Options_EFClassShaman:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_WARLOCK] = HealBot_Options_EFClassWarlock:GetChecked() or 0;
        HealBot_Config.EmergIncHealers[HEALBOT_WARRIOR] = HealBot_Options_EFClassWarrior:GetChecked() or 0
        HealBot_Config.EmergIncHealers[HEALBOT_DEATHKNIGHT] = HealBot_Options_EFClassDeathKnight:GetChecked() or 0;
    elseif HealBot_Config.EmergencyFClass==4 then
        HealBot_Config.EmergIncCustom[HEALBOT_DRUID] = HealBot_Options_EFClassDruid:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_HUNTER] = HealBot_Options_EFClassHunter:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_MAGE] = HealBot_Options_EFClassMage:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_PALADIN] = HealBot_Options_EFClassPaladin:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_PRIEST] = HealBot_Options_EFClassPriest:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_ROGUE] = HealBot_Options_EFClassRogue:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_SHAMAN] = HealBot_Options_EFClassShaman:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_WARLOCK] = HealBot_Options_EFClassWarlock:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_WARRIOR] = HealBot_Options_EFClassWarrior:GetChecked() or 0;
        HealBot_Config.EmergIncCustom[HEALBOT_DEATHKNIGHT] = HealBot_Options_EFClassDeathKnight:GetChecked() or 0;
    end
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_CastNotify_OnClick(self,id)
    if HealBot_Config.CastNotify>0 then
        getglobal("HealBot_Options_CastNotify"..HealBot_Config.CastNotify):SetChecked(nil);
    end
    HealBot_Config.CastNotify = id;
    if HealBot_Config.CastNotify>0 then
        getglobal("HealBot_Options_CastNotify"..HealBot_Config.CastNotify):SetChecked(1);
    end
end

function HealBot_ComboButtons_Button_OnClick(self,id)
    if HealBot_Options_ComboButtons_Button>0 then
        getglobal("HealBot_ComboButtons_Button"..HealBot_Options_ComboButtons_Button):SetChecked(nil);
    end
    HealBot_Options_ComboButtons_Button = id;
    if HealBot_Options_ComboButtons_Button>0 then
        getglobal("HealBot_ComboButtons_Button"..HealBot_Options_ComboButtons_Button):SetChecked(1);
    end
    HealBot_Options_ComboClass_Text()
end

function HealBot_Options_HideOptions_OnClick(self)
    HealBot_Config.HideOptions = self:GetChecked() or 0;
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

function HealBot_Options_RightButtonOptions_OnClick(self)
    HealBot_Config.RightButtonOptions = self:GetChecked() or 0;
end

function HealBot_Options_ShowMinimapButton_OnClick(self)
    HealBot_Config.ButtonShown = self:GetChecked() or 0;
    HealBot_MMButton_Init();   
end

function HealBot_Options_ShowTooltip_OnClick(self)
    HealBot_Config.ShowTooltip = self:GetChecked() or 0;
end

function HealBot_Options_ShowTooltipUpdate_OnClick(self)
    HealBot_Config.TooltipUpdate = self:GetChecked() or 0;
end

function HealBot_Options_HideTooltipInCombat_OnClick(self)
    HealBot_Config.DisableToolTipInCombat = self:GetChecked() or 0;
end

function HealBot_Options_ShowTooltipTarget_OnClick(self)
    HealBot_Config.Tooltip_ShowTarget = self:GetChecked() or 0;
end

function HealBot_Options_ShowTooltipSpellDetail_OnClick(self)
    HealBot_Config.Tooltip_ShowSpellDetail = self:GetChecked() or 0;
end

function HealBot_Options_ShowTooltipInstant_OnClick(self)
    HealBot_Config.Tooltip_Recommend = self:GetChecked() or 0;
end

function HealBot_Options_ShowTooltipPreDefined_OnClick(self)
    HealBot_Config.Tooltip_PreDefined = self:GetChecked() or 0;
end

function HealBot_Options_ShowIncomingHeals_OnClick(self)
    HealBot_Config.ShowIncHeals = self:GetChecked() or 0;
    StaticPopup_Show ("HEALBOT_OPTIONS_RELOADUI");
end

function HealBot_Options_ShowDebuffWarning_OnClick(self)
    HealBot_Config.ShowDebuffWarning = self:GetChecked() or 0;
end

function HealBot_Options_ShowDebuffIcon_OnClick(self)
    Healbot_Config_Skins.ShowDebuffIcon[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
end

function HealBot_Options_SoundDebuffWarning_OnClick(self)
    HealBot_Config.SoundDebuffWarning = self:GetChecked() or 0;
    if HealBot_Config.SoundDebuffWarning==0 then
        HealBot_Options_WarningSound:Disable();
        HealBot_Options_PlaySound:Disable();
    else
        HealBot_Options_WarningSound:Enable();
        HealBot_Options_PlaySound:Enable();
      end
end

function HealBot_Options_BarInClassColour_OnClick(self)
    Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    if Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_Options_BarClassCustomColour1:Disable();
        HealBot_Options_BarClassCustomColour2:Disable();
    else
        HealBot_Options_BarClassCustomColour1:Enable();
        HealBot_Options_BarClassCustomColour2:Enable();
    end
    HealBot_Action_ResetUnitStatus()
end

local ClassCustomPrev=-1
function HealBot_Options_BarClassCustom_OnClick(self,id)
    if ClassCustomPrev==-1 then
        if Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin]==1 then
            ClassCustomPrev=1
        else
            ClassCustomPrev=2
        end
    end
    getglobal("HealBot_Options_BarClassCustomColour"..ClassCustomPrev):SetChecked(nil);
    Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin] = id;
    if Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin]>0 then
        getglobal("HealBot_Options_BarClassCustomColour"..Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin]):SetChecked(1);
        ClassCustomPrev=id
    end
    HealBot_Action_ResetUnitStatus()
end

function HealBot_Options_NumberTextLines_OnClick(self)
    Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(150)
end

function HealBot_Options_BarTextInClassColour_OnClick(self)
    Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_Action_ResetUnitStatus()
    HealBot_Options_SetBarsTextColour()
end

function HealBot_Options_BarButtonShowHoT_OnClick(self)
    Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
end

function HealBot_Options_BarButtonShowRaidIcon_OnClick(self)
    Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    HealBot_setOptions_Timer(200)
end

function HealBot_BarButtonShowHoTTextCount_OnClick(self)
    Healbot_Config_Skins.ShowIconTextCount[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
end

function HealBot_BarButtonShowHoTTextDuration_OnClick(self)
    Healbot_Config_Skins.ShowIconTextDuration[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
end

function HealBot_Options_ShowHealthOnBar_OnClick(self)
    Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Current_Skin] = self:GetChecked() or 0;
    if Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Current_Skin]==0 then
        HealBot_BarHealthType1:Disable();
        HealBot_BarHealthType2:Disable();
        HealBot_BarHealthIncHeal:Disable();
        HealBot_BarHealthSepHeal:Disable();
    else
        HealBot_BarHealthType1:Enable();
        HealBot_BarHealthType2:Enable();
        HealBot_BarHealthIncHeal:Enable();
        HealBot_BarHealthSepHeal:Enable();
    end
end

local BarHealthTypePrev=-1
function HealBot_BarHealthType_OnClick(self,id)
    if BarHealthTypePrev==-1 then
        if Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin]==1 then
            BarHealthTypePrev=1
        else
            BarHealthTypePrev=2
        end
    end
    getglobal("HealBot_BarHealthType"..BarHealthTypePrev):SetChecked(nil);
    Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin] = id;
    if Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin]>0 then
        getglobal("HealBot_BarHealthType"..Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin]):SetChecked(1);
        BarHealthTypePrev=id
    end
end

local HoTonBarPrev=-1
function HealBot_HoTonBar_OnClick(self,id)
    if HoTonBarPrev==-1 then
        if Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Current_Skin]==1 then
            HoTonBarPrev=1
        else
            HoTonBarPrev=2
        end
    end
    getglobal("HealBot_BarButtonShowHoTonBar"..HoTonBarPrev):SetChecked(nil);
    Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Current_Skin] = id;
    if Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Current_Skin]>0 then
        getglobal("HealBot_BarButtonShowHoTonBar"..Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Current_Skin]):SetChecked(1);
        HoTonBarPrev=id
        HealBot_setOptions_Timer(150)
    end
end

local HoTposBarPrev=-1
function HealBot_HoTposBar_OnClick(self,id)
    if HoTposBarPrev==-1 then
        if Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]==1 then
            HoTposBarPrev=1
        else
            HoTposBarPrev=2
        end
    end
    getglobal("HealBot_BarButtonShowHoTposBar"..HoTposBarPrev):SetChecked(nil);
    Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin] = id;
    if Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]>0 then
        getglobal("HealBot_BarButtonShowHoTposBar"..Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin]):SetChecked(1);
        HoTposBarPrev=id
        HealBot_setOptions_Timer(150)
    end
end


local ShowClassOnBarTypePrev=-1
function HealBot_Options_ShowClassOnBarType_OnClick(self,id)
    if Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin]==1 then HealBot_RaidTargetToggle(nil) end
    if ShowClassOnBarTypePrev==-1 then
        if Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin]==1 then
            ShowClassOnBarTypePrev=1
        else
            ShowClassOnBarTypePrev=2
        end
    end
    getglobal("HealBot_Options_ShowClassOnBarType"..ShowClassOnBarTypePrev):SetChecked(nil);
    Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin] = id;
    if Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin]>0 then
        getglobal("HealBot_Options_ShowClassOnBarType"..Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin]):SetChecked(1);
        ShowClassOnBarTypePrev=id
        HealBot_setOptions_Timer(150)
    end
end

function HealBot_Options_ProtectPvP_OnClick(self)
    HealBot_Config.ProtectPvP = self:GetChecked() or 0;
end

--------------------------------------------------------------------------------


--------------------------------------------------------------------------------

local HealBot_Options_EmergencyFClass_List = {
    HEALBOT_CLASSES_MELEE,
    HEALBOT_CLASSES_RANGES,
    HEALBOT_CLASSES_HEALERS,
    HEALBOT_CLASSES_CUSTOM,
}

local info={}
function HealBot_Options_EmergencyFClass_DropDown()
    for j=1, getn(HealBot_Options_EmergencyFClass_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_EmergencyFClass_List[j];
        info.func = HealBot_Options_EmergencyFClass_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_EmergencyFClass_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_EmergencyFClass,HealBot_Options_EmergencyFClass_DropDown)
end

function HealBot_Options_EmergencyFClass_Refresh(onselect)
    if not HealBot_Config.EmergencyFClass then return end
    if not onselect then HealBot_Options_EmergencyFClass_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_EmergencyFClass,HealBot_Config.EmergencyFClass)
end

function HealBot_Options_EmergencyFClass_OnLoad(self)
    HealBot_Options_EmergencyFClass_Initialize()
    UIDropDownMenu_SetWidth(self,145)
end

function HealBot_Options_EmergencyFClass_OnSelect()
    HealBot_Config.EmergencyFClass = this:GetID()
    HealBot_Options_EmergencyFClass_Refresh(true)
    HealBot_Options_EFClass_Reset()
end

function HealBot_Options_EFClass_Reset()
    if HealBot_Config.EmergencyFClass==1 then
        HealBot_Options_EFClassDruid:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_DRUID]);
        HealBot_Options_EFClassHunter:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_HUNTER]);
        HealBot_Options_EFClassMage:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_MAGE]);
        HealBot_Options_EFClassPaladin:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_PALADIN]);
        HealBot_Options_EFClassPriest:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_PRIEST]);
        HealBot_Options_EFClassRogue:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_ROGUE]);
        HealBot_Options_EFClassShaman:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_SHAMAN]);
        HealBot_Options_EFClassWarlock:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_WARLOCK]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_WARRIOR]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncMelee[HEALBOT_DEATHKNIGHT]);
    elseif HealBot_Config.EmergencyFClass==2 then
        HealBot_Options_EFClassDruid:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_DRUID]);
        HealBot_Options_EFClassHunter:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_HUNTER]);
        HealBot_Options_EFClassMage:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_MAGE]);
        HealBot_Options_EFClassPaladin:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_PALADIN]);
        HealBot_Options_EFClassPriest:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_PRIEST]);
        HealBot_Options_EFClassRogue:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_ROGUE]);
        HealBot_Options_EFClassShaman:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_SHAMAN]);
        HealBot_Options_EFClassWarlock:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_WARLOCK]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_WARRIOR]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncRange[HEALBOT_DEATHKNIGHT]);
    elseif HealBot_Config.EmergencyFClass==3 then
        HealBot_Options_EFClassDruid:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_DRUID]);
        HealBot_Options_EFClassHunter:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_HUNTER]);
        HealBot_Options_EFClassMage:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_MAGE]);
        HealBot_Options_EFClassPaladin:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_PALADIN]);
        HealBot_Options_EFClassPriest:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_PRIEST]);
        HealBot_Options_EFClassRogue:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_ROGUE]);
        HealBot_Options_EFClassShaman:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_SHAMAN]);
        HealBot_Options_EFClassWarlock:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_WARLOCK]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_WARRIOR]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncHealers[HEALBOT_DEATHKNIGHT]);
    elseif HealBot_Config.EmergencyFClass==4 then
        HealBot_Options_EFClassDruid:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_DRUID]);
        HealBot_Options_EFClassHunter:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_HUNTER]);
        HealBot_Options_EFClassMage:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_MAGE]);
        HealBot_Options_EFClassPaladin:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_PALADIN]);
        HealBot_Options_EFClassPriest:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_PRIEST]);
        HealBot_Options_EFClassRogue:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_ROGUE]);
        HealBot_Options_EFClassShaman:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_SHAMAN]);
        HealBot_Options_EFClassWarlock:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_WARLOCK]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_WARRIOR]);
        HealBot_Options_EFClassWarrior:SetChecked(HealBot_Config.EmergIncCustom[HEALBOT_DEATHKNIGHT]);
    end
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

--------------------------------------------------------------------------------

local HealBot_Options_ExtraSort_List = {
    HEALBOT_SORTBY_NAME,
    HEALBOT_SORTBY_CLASS,
    HEALBOT_SORTBY_GROUP,
    HEALBOT_SORTBY_MAXHEALTH,
}

function HealBot_Options_ExtraSort_DropDown()
    for j=1, getn(HealBot_Options_ExtraSort_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_ExtraSort_List[j];
        info.func = HealBot_Options_ExtraSort_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_ExtraSort_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_ExtraSort,HealBot_Options_ExtraSort_DropDown)
end

function HealBot_Options_ExtraSort_Refresh(onselect)
    if not HealBot_Config.ExtraOrder then return end
    if not onselect then HealBot_Options_ExtraSort_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_ExtraSort,HealBot_Config.ExtraOrder)
end

function HealBot_Options_ExtraSort_OnLoad(self)
    HealBot_Options_ExtraSort_Initialize()
    UIDropDownMenu_SetWidth(self,145)
end

function HealBot_Options_ExtraSort_OnSelect()
    HealBot_Config.ExtraOrder = this:GetID();
    HealBot_Options_ExtraSort_Refresh(true)
    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

--------------------------------------------------------------------------------
local HealBot_ActionBarsCombo=1;

local HealBot_Options_ActionBarsCombo_List = {
    HEALBOT_OPTIONS_ENABLEDBARS,
    HEALBOT_OPTIONS_DISABLEDBARS,
}

function HealBot_Options_ActionBarsCombo_DropDown()
    for j=1, getn(HealBot_Options_ActionBarsCombo_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_ActionBarsCombo_List[j];
        info.func = HealBot_Options_ActionBarsCombo_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_ActionBarsCombo_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_ActionBarsCombo,HealBot_Options_ActionBarsCombo_DropDown)
end

function HealBot_Options_ActionBarsCombo_Refresh(onselect)
    if not onselect then HealBot_Options_ActionBarsCombo_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_ActionBarsCombo,HealBot_ActionBarsCombo)
end

function HealBot_Options_ActionBarsCombo_OnLoad(self)
    HealBot_Options_ActionBarsCombo_Initialize()
    UIDropDownMenu_SetWidth(self,240)
end

function HealBot_Options_ActionBarsCombo_OnSelect()
    HealBot_ActionBarsCombo = this:GetID()
    HealBot_Options_ActionBarsCombo_Refresh(true)
    HealBot_Options_ComboClass_Text();
end

--------------------------------------------------------------------------------

local HealBot_Options_ActionAnchor_List = {
    HEALBOT_OPTIONS_TOPLEFT,
    HEALBOT_OPTIONS_BOTTOMLEFT,
    HEALBOT_OPTIONS_TOPRIGHT,
    HEALBOT_OPTIONS_BOTTOMRIGHT,
}

function HealBot_Options_ActionAnchor_DropDown()
    for j=1, getn(HealBot_Options_ActionAnchor_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_ActionAnchor_List[j];
        info.func = HealBot_Options_ActionAnchor_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_ActionAnchor_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_ActionAnchor,HealBot_Options_ActionAnchor_DropDown)
end

function HealBot_Options_ActionAnchor_Refresh(onselect)
    if not onselect then HealBot_Options_ActionAnchor_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_ActionAnchor,HealBot_Config.Panel_Anchor)
end

function HealBot_Options_ActionAnchor_OnLoad(self)
    HealBot_Options_ActionAnchor_Initialize()
    UIDropDownMenu_SetWidth(self,120)
end

function HealBot_Options_ActionAnchor_OnSelect()
    HealBot_Config.Panel_Anchor = this:GetID()
    if HealBot_Config.Panel_Anchor==1 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetTop();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetLeft()
    elseif HealBot_Config.Panel_Anchor==2 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetBottom();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetLeft()
    elseif HealBot_Config.Panel_Anchor==3 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetTop();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetRight()
    elseif HealBot_Config.Panel_Anchor==4 then
        HealBot_Config.PanelAnchorY = HealBot_Action:GetBottom();
        HealBot_Config.PanelAnchorX = HealBot_Action:GetRight()
    end
    HealBot_Options_ActionAnchor_Refresh(true)
    HealBot_SetResetFlag("SOFT")
end

--------------------------------------------------------------------------------


local HealBot_Options_UseHBinHeals_List = {
    HEALBOT_WORD_ALWAYS,
    HEALBOT_WORD_SOLO,
    HEALBOT_WORD_NEVER,
}

function HealBot_Options_UseHBinHeals_DropDown()
    for j=1, getn(HealBot_Options_UseHBinHeals_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_UseHBinHeals_List[j];
        info.func = HealBot_Options_UseHBinHeals_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_UseHBinHeals_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_UseHBinHeals,HealBot_Options_UseHBinHeals_DropDown)
end

function HealBot_Options_UseHBinHeals_Refresh(onselect)
    if not onselect then HealBot_Options_UseHBinHeals_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_UseHBinHeals,HealBot_Config.UseHbHeals)
end

function HealBot_Options_UseHBinHeals_OnLoad(self)
    HealBot_Options_UseHBinHeals_Initialize()
    UIDropDownMenu_SetWidth(self,120)
end

function HealBot_Options_UseHBinHeals_OnSelect()
    HealBot_Config.UseHbHeals = this:GetID()
    HealBot_Options_UseHBinHeals_Refresh(true)
end

--------------------------------------------------------------------------------

local HealBot_Options_EmergencyFilter_List = {
    HEALBOT_CLASSES_ALL,
    HEALBOT_DRUID,
    HEALBOT_HUNTER,
    HEALBOT_MAGE,
    HEALBOT_PALADIN,
    HEALBOT_PRIEST,
    HEALBOT_ROGUE,
    HEALBOT_SHAMAN,
    HEALBOT_WARLOCK,
    HEALBOT_WARRIOR,
    HEALBOT_DEATHKNIGHT,
    HEALBOT_CLASSES_MELEE,
    HEALBOT_CLASSES_RANGES,
    HEALBOT_CLASSES_HEALERS,
    HEALBOT_CLASSES_CUSTOM,
}

function HealBot_Options_EmergencyFilter_DropDown()
    for j=1, getn(HealBot_Options_EmergencyFilter_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_EmergencyFilter_List[j];
        info.func = HealBot_Options_EmergencyFilter_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_EmergencyFilter_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_EmergencyFilter,HealBot_Options_EmergencyFilter_DropDown)
end

function HealBot_Options_EmergencyFilter_Refresh(onselect)
    if not HealBot_Config.EmergIncMonitor then return end
    if not onselect then HealBot_Options_EmergencyFilter_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_EmergencyFilter,HealBot_Config.EmergIncMonitor)
end

function HealBot_Options_EmergencyFilter_OnLoad(self)
    HealBot_Options_EmergencyFilter_Initialize()
    UIDropDownMenu_SetWidth(self,145)
end

function HealBot_Options_EmergencyFilter_OnSelect()
    HealBot_Config.EmergIncMonitor = this:GetID()
    HealBot_Options_EmergencyFilter_Refresh(true)
    HealBot_setOptions_Timer(60)
end

function HealBot_Options_EmergencyFilter_Reset()
  
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = 0;
    HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = 0;
    if HealBot_Config.EmergIncMonitor==1 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = 1;
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = 1;
    elseif HealBot_Config.EmergIncMonitor==2 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = 1;
    elseif HealBot_Config.EmergIncMonitor==3 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = 1;
    elseif HealBot_Config.EmergIncMonitor==4 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = 1;
    elseif HealBot_Config.EmergIncMonitor==5 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = 1;
    elseif HealBot_Config.EmergIncMonitor==6 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = 1;
    elseif HealBot_Config.EmergIncMonitor==7 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = 1;
    elseif HealBot_Config.EmergIncMonitor==8 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = 1;
    elseif HealBot_Config.EmergIncMonitor==9 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = 1;
    elseif HealBot_Config.EmergIncMonitor==10 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = 1;
    elseif HealBot_Config.EmergIncMonitor==11 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = 1;
    elseif HealBot_Config.EmergIncMonitor==12 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = HealBot_Config.EmergIncMelee[HEALBOT_DRUID];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = HealBot_Config.EmergIncMelee[HEALBOT_HUNTER];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = HealBot_Config.EmergIncMelee[HEALBOT_MAGE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = HealBot_Config.EmergIncMelee[HEALBOT_PALADIN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = HealBot_Config.EmergIncMelee[HEALBOT_PRIEST];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = HealBot_Config.EmergIncMelee[HEALBOT_ROGUE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = HealBot_Config.EmergIncMelee[HEALBOT_SHAMAN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = HealBot_Config.EmergIncMelee[HEALBOT_WARLOCK];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = HealBot_Config.EmergIncMelee[HEALBOT_WARRIOR];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = HealBot_Config.EmergIncMelee[HEALBOT_DEATHKNIGHT];
    elseif HealBot_Config.EmergIncMonitor==13 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = HealBot_Config.EmergIncRange[HEALBOT_DRUID];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = HealBot_Config.EmergIncRange[HEALBOT_HUNTER];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = HealBot_Config.EmergIncRange[HEALBOT_MAGE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = HealBot_Config.EmergIncRange[HEALBOT_PALADIN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = HealBot_Config.EmergIncRange[HEALBOT_PRIEST];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = HealBot_Config.EmergIncRange[HEALBOT_ROGUE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = HealBot_Config.EmergIncRange[HEALBOT_SHAMAN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = HealBot_Config.EmergIncRange[HEALBOT_WARLOCK];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = HealBot_Config.EmergIncRange[HEALBOT_WARRIOR];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = HealBot_Config.EmergIncRange[HEALBOT_DEATHKNIGHT];
    elseif HealBot_Config.EmergIncMonitor==14 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = HealBot_Config.EmergIncHealers[HEALBOT_DRUID];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = HealBot_Config.EmergIncHealers[HEALBOT_HUNTER];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = HealBot_Config.EmergIncHealers[HEALBOT_MAGE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = HealBot_Config.EmergIncHealers[HEALBOT_PALADIN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = HealBot_Config.EmergIncHealers[HEALBOT_PRIEST];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = HealBot_Config.EmergIncHealers[HEALBOT_ROGUE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = HealBot_Config.EmergIncHealers[HEALBOT_SHAMAN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = HealBot_Config.EmergIncHealers[HEALBOT_WARLOCK];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = HealBot_Config.EmergIncHealers[HEALBOT_WARRIOR];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = HealBot_Config.EmergIncHealers[HEALBOT_DEATHKNIGHT];
    elseif HealBot_Config.EmergIncMonitor==15 then
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DRUID]] = HealBot_Config.EmergIncCustom[HEALBOT_DRUID];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_HUNTER]] = HealBot_Config.EmergIncCustom[HEALBOT_HUNTER];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_MAGE]] = HealBot_Config.EmergIncCustom[HEALBOT_MAGE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PALADIN]] = HealBot_Config.EmergIncCustom[HEALBOT_PALADIN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_PRIEST]] = HealBot_Config.EmergIncCustom[HEALBOT_PRIEST];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_ROGUE]] = HealBot_Config.EmergIncCustom[HEALBOT_ROGUE];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_SHAMAN]] = HealBot_Config.EmergIncCustom[HEALBOT_SHAMAN];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARLOCK]] = HealBot_Config.EmergIncCustom[HEALBOT_WARLOCK];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_WARRIOR]] = HealBot_Config.EmergIncCustom[HEALBOT_WARRIOR];
        HealBot_EmergInc[HealBot_Class_En[HEALBOT_DEATHKNIGHT]] = HealBot_Config.EmergIncCustom[HEALBOT_DEATHKNIGHT];
    end

    if Delay_RecalcParty==0 then 
        Delay_RecalcParty=1; 
    end
end

--------------------------------------------------------------------------------

function HealBot_Options_Skins_DropDown()
    for j=1, getn(HealBot_Skins), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Skins[j];
        info.func = HealBot_Options_Skins_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_Skins_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_Skins,HealBot_Options_Skins_DropDown)
end

function HealBot_Options_Skins_Refresh(onselect)
    if not Healbot_Config_Skins.Skin_ID then return end
    if not onselect then HealBot_Options_Skins_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_Skins,Healbot_Config_Skins.Skin_ID)
end

function HealBot_Options_Skins_OnLoad(self)
    HealBot_setOptions_Timer(9000)
    UIDropDownMenu_SetWidth(self,170)
end

function HealBot_Options_Skins_OnSelect()
    Healbot_Config_Skins.Skin_ID = this:GetID()
    HealBot_Options_Skins_Refresh(true)
    HealBot_Options_Skins2_Refresh(true)
    if this:GetID()>=1 then
        Healbot_Config_Skins.Current_Skin = this:GetText()
        HealBot_Options_SetSkins();
    end
end


function HealBot_Options_Skins2_DropDown()
    for j=1, getn(HealBot_Skins), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Skins[j];
        info.func = HealBot_Options_Skins2_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_Skins2_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_Skins2,HealBot_Options_Skins2_DropDown)
end

function HealBot_Options_Skins2_Refresh(onselect)
    if not Healbot_Config_Skins.Skin_ID then return end
    if not onselect then HealBot_Options_Skins2_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_Skins2,Healbot_Config_Skins.Skin_ID)
end

function HealBot_Options_Skins2_OnLoad(self)
    HealBot_setOptions_Timer(9000)
    UIDropDownMenu_SetWidth(self,170)
end

function HealBot_Options_Skins2_OnSelect()
    Healbot_Config_Skins.Skin_ID = this:GetID()
    HealBot_Options_Skins_Refresh(true)
    HealBot_Options_Skins2_Refresh(true)
    if this:GetID()>=1 then
        Healbot_Config_Skins.Current_Skin = this:GetText()
        HealBot_Options_SetSkins();
    end
end

local HealBot_Options_notSet_Current_Skin = true
function HealBot_Options_Set_Current_Skin(newSkin)
    if HealBot_Options_notSet_Current_Skin or newSkin then
        if HealBot_Options_notSet_Current_Skin then 
            HealBot_Skins = Healbot_Config_Skins.Skins
            HealBot_Options_notSet_Current_Skin=nil
        end
        if newSkin then
            local hbFoundSkin=nil
            local hbValidSkins=nil
            for j=1, getn(HealBot_Skins), 1 do
                if newSkin==HealBot_Skins[j] then
                    hbFoundSkin=true
                    Healbot_Config_Skins.Skin_ID = j
                    Healbot_Config_Skins.Current_Skin = HealBot_Skins[j]
                    HealBot_Options_SetSkins();
                    HealBot_SetSkinColours();
                    HealBot_SetResetFlag("SOFT")
                end
                if hbValidSkins then
                    hbValidSkins=hbValidSkins.."  +  "..HealBot_Skins[j]
                else
                    hbValidSkins=HealBot_Skins[j]
                end
            end
            if not hbFoundSkin then
                HealBot_AddChat("[HealBot] Unknown skin: /hb skin "..newSkin)
                HealBot_AddChat("[HealBot]  Valid skins:  "..hbValidSkins)
            end
        elseif HealBot_Config.Skin_ID>0 and HealBot_Config.Current_Skin and Healbot_Config_Skins.bheight[HealBot_Config.Current_Skin] then 
            Healbot_Config_Skins.Current_Skin = HealBot_Config.Current_Skin
            Healbot_Config_Skins.Skin_ID = HealBot_Config.Skin_ID
        else
            HealBot_Config.Current_Skin = Healbot_Config_Skins.Current_Skin
            HealBot_Config.Skin_ID = Healbot_Config_Skins.Skin_ID
        end
        HealBot_Options_Skins_Refresh()
        HealBot_Options_Skins2_Refresh()
    end
end

--------------------------------------------------------------------------------

local HealBot_Options_TooltipPos_List = {
    HEALBOT_TOOLTIP_POSDEFAULT,
    HEALBOT_TOOLTIP_POSLEFT,
    HEALBOT_TOOLTIP_POSRIGHT,
    HEALBOT_TOOLTIP_POSABOVE,
    HEALBOT_TOOLTIP_POSBELOW,
    HEALBOT_TOOLTIP_POSCURSOR,
}

function HealBot_Options_TooltipPos_DropDown()
    for j=1, getn(HealBot_Options_TooltipPos_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_TooltipPos_List[j];
        info.func = HealBot_Options_TooltipPos_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_TooltipPos_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_TooltipPos,HealBot_Options_TooltipPos_DropDown)
end

function HealBot_Options_TooltipPos_Refresh(onselect)
    if not HealBot_Config.TooltipPos then return end
    if not onselect then HealBot_Options_TooltipPos_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_TooltipPos,HealBot_Config.TooltipPos)
end

function HealBot_Options_TooltipPos_OnLoad(self)
    HealBot_Options_TooltipPos_Initialize()
    UIDropDownMenu_SetWidth(self,128)
end

function HealBot_Options_TooltipPos_OnSelect()
    HealBot_Config.TooltipPos = this:GetID()
    HealBot_Options_TooltipPos_Refresh(true)
end

--------------------------------------------------------------------------------

local HealBot_Options_BuffTxt_List = {
    HEALBOT_WORDS_NONE,
    HEALBOT_OPTIONS_BUFFSELF,
    HEALBOT_OPTIONS_BUFFPARTY,
    HEALBOT_OPTIONS_BUFFRAID,
    HEALBOT_DRUID,
    HEALBOT_HUNTER,
    HEALBOT_MAGE,
    HEALBOT_PALADIN,
    HEALBOT_PRIEST,
    HEALBOT_ROGUE,
    HEALBOT_SHAMAN,
    HEALBOT_WARLOCK,
    HEALBOT_WARRIOR,
    HEALBOT_DEATHKNIGHT,
    HEALBOT_CLASSES_MELEE,
    HEALBOT_CLASSES_RANGES,
    HEALBOT_CLASSES_HEALERS,
    HEALBOT_CLASSES_CUSTOM,
    HEALBOT_SELF_PVP,
    HEALBOT_OPTIONS_TANKHEALS,
    HEALBOT_OPTIONS_MYTARGET,
    HEALBOT_FOCUS,
	HEALBOT_SORTBY_NAME,
}

local HealBot_Buff_Spells_Total_List = {
    HEALBOT_POWER_WORD_FORTITUDE,
    HEALBOT_PRAYER_OF_FORTITUDE,
    HEALBOT_ANCESTRAL_FORTITUDE,
    HEALBOT_INNER_FIRE,
    HEALBOT_TOUCH_OF_WEAKNESS,
    HEALBOT_FEAR_WARD,
    HEALBOT_PAIN_SUPPRESSION,
    HEALBOT_POWER_INFUSION,
    HEALBOT_DIVINE_SPIRIT,
    HEALBOT_LEVITATE,
    HEALBOT_PRAYER_OF_SPIRIT,
    HEALBOT_SHADOW_PROTECTION,
    HEALBOT_PRAYER_OF_SHADOW_PROTECTION,
    HEALBOT_SHADOWFORM,
    HEALBOT_MARK_OF_THE_WILD,
    HEALBOT_GIFT_OF_THE_WILD,
    HEALBOT_THORNS,
    HEALBOT_OMEN_OF_CLARITY,
    HEALBOT_BLESSING_OF_MIGHT,
    HEALBOT_BLESSING_OF_WISDOM,
    HEALBOT_BLESSING_OF_SALVATION,
    HEALBOT_HAND_OF_SALVATION,
    HEALBOT_BLESSING_OF_SANCTUARY,
    HEALBOT_BLESSING_OF_LIGHT,
    HEALBOT_BLESSING_OF_PROTECTION,
    HEALBOT_BLESSING_OF_FREEDOM,
    HEALBOT_BLESSING_OF_SACRIFICE,
    HEALBOT_BLESSING_OF_KINGS,
    HEALBOT_GREATER_BLESSING_OF_MIGHT,
    HEALBOT_GREATER_BLESSING_OF_WISDOM,
    HEALBOT_GREATER_BLESSING_OF_KINGS,
    HEALBOT_GREATER_BLESSING_OF_LIGHT,
    HEALBOT_GREATER_BLESSING_OF_SALVATION,
    HEALBOT_GREATER_BLESSING_OF_SANCTUARY,
    HEALBOT_HAND_OF_FREEDOM,
    HEALBOT_HAND_OF_PROTECTION,
    HEALBOT_HAND_OF_SACRIFICE,
    HEALBOT_HAND_OF_SALVATION,
    HEALBOT_ARCANE_INTELLECT,
    HEALBOT_ARCANE_BRILLIANCE,
    HEALBOT_DALARAN_INTELLECT,
    HEALBOT_DALARAN_BRILLIANCE,
    HEALBOT_FROST_ARMOR,
    HEALBOT_ICE_ARMOR,
    HEALBOT_MAGE_ARMOR,
    HEALBOT_DEMON_ARMOR,
    HEALBOT_DEMON_SKIN,
    HEALBOT_LIGHTNING_SHIELD,
    HEALBOT_ROCKBITER_WEAPON,
    HEALBOT_FLAMETONGUE_WEAPON,
    HEALBOT_EARTHLIVING_WEAPON,
    HEALBOT_WINDFURY_WEAPON,
    HEALBOT_FROSTBRAND_WEAPON,
    HEALBOT_EARTH_SHIELD,
    HEALBOT_WATER_SHIELD,
    HEALBOT_MOLTEN_ARMOR,
    HEALBOT_DAMPEN_MAGIC,
    HEALBOT_AMPLIFY_MAGIC,
    HEALBOT_FEL_ARMOR,
    HEALBOT_SOUL_LINK,
    HEALBOT_WIND_FURY,
    HEALBOT_SHADOW_GUARD,
    HEALBOT_DETECT_INV,
    HEALBOT_RIGHTEOUS_FURY,
    HEALBOT_DEVOTION_AURA,
    HEALBOT_RETRIBUTION_AURA,
    HEALBOT_CONCENTRATION_AURA,
    HEALBOT_SHR_AURA,
    HEALBOT_FRR_AURA,
    HEALBOT_FIR_AURA,
    HEALBOT_CRUSADER_AURA,
    HEALBOT_SANCTITY_AURA,
    HEALBOT_A_MONKEY,
    HEALBOT_A_HAWK,
    HEALBOT_A_CHEETAH,
    HEALBOT_A_BEAST,
    HEALBOT_A_PACK,
    HEALBOT_A_WILD,
    HEALBOT_A_VIPER,
    HEALBOT_A_DRAGONHAWK,
    HEALBOT_UNENDING_BREATH,
    HEALBOT_BEACON_OF_LIGHT,
    HEALBOT_SACRED_SHIELD,
    HEALBOT_SHEATH_OF_LIGHT,
    HEALBOT_SEAL_OF_RIGHTEOUSNESS,
    HEALBOT_SEAL_OF_BLOOD,
    HEALBOT_SEAL_OF_CORRUPTION,
    HEALBOT_SEAL_OF_JUSTICE,
    HEALBOT_SEAL_OF_LIGHT,
    HEALBOT_SEAL_OF_VENGEANCE,
    HEALBOT_SEAL_OF_WISDOM,
    HEALBOT_SEAL_OF_COMMAND,
    HEALBOT_SEAL_OF_THE_MARTYR,
    HEALBOT_BONE_SHIELD,
    HEALBOT_HORN_OF_WINTER,
    HEALBOT_FOCUS_MAGIC,
    HEALBOT_BATTLE_SHOUT,
    HEALBOT_COMMANDING_SHOUT,
    HEALBOT_VIGILANCE,
    HEALBOT_WATER_BREATHING,
    HEALBOT_WATER_WALKING, 
}

local HealBot_Buff_Spells_List ={}

function HealBot_Options_InitBuffList()
    HealBot_Buff_Spells_List ={}
  --if not HealBot_Buff_Spells_List[1] then
    for j=1, getn(HealBot_Buff_Spells_Total_List), 1 do
        sID=HealBot_GetSpellId(HealBot_Buff_Spells_Total_List[j]);
        if sID then
            table.insert(HealBot_Buff_Spells_List,HealBot_Buff_Spells_Total_List[j])
        end
    end
    return HealBot_Buff_Spells_List
 -- end
end

local specDdId = nil
function HealBot_Options_BuffTxt1_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt1_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt1_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt2_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt2_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt2_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt3_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt3_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt3_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt4_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt4_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt4_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt5_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt5_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt5_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt6_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt6_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt6_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt7_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt7_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt7_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt8_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt8_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt8_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt9_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt9_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt9_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt10_DropDown()
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_BuffTxt10_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(HealBot_Buff_Spells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Buff_Spells_List[j];
        info.func = HealBot_Options_BuffTxt10_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups1_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups1_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups2_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups2_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups3_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups3_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups4_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups4_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups5_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups5_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups6_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups6_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups7_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups7_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups8_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups8_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups9_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups9_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffGroups10_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_BuffGroups10_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_BuffTxt1_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt1,HealBot_Options_BuffTxt1_DropDown)
end

function HealBot_Options_BuffTxt2_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt2,HealBot_Options_BuffTxt2_DropDown)
end

function HealBot_Options_BuffTxt3_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt3,HealBot_Options_BuffTxt3_DropDown)
end

function HealBot_Options_BuffTxt4_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt4,HealBot_Options_BuffTxt4_DropDown)
end

function HealBot_Options_BuffTxt5_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt5,HealBot_Options_BuffTxt5_DropDown)
end

function HealBot_Options_BuffTxt6_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt6,HealBot_Options_BuffTxt6_DropDown)
end

function HealBot_Options_BuffTxt7_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt7,HealBot_Options_BuffTxt7_DropDown)
end

function HealBot_Options_BuffTxt8_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt8,HealBot_Options_BuffTxt8_DropDown)
end

function HealBot_Options_BuffTxt9_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt9,HealBot_Options_BuffTxt9_DropDown)
end

function HealBot_Options_BuffTxt10_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffTxt10,HealBot_Options_BuffTxt10_DropDown)
end

function HealBot_Options_BuffGroups1_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups1,HealBot_Options_BuffGroups1_DropDown)
end

function HealBot_Options_BuffGroups2_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups2,HealBot_Options_BuffGroups2_DropDown)
end

function HealBot_Options_BuffGroups3_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups3,HealBot_Options_BuffGroups3_DropDown)
end

function HealBot_Options_BuffGroups4_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups4,HealBot_Options_BuffGroups4_DropDown)
end

function HealBot_Options_BuffGroups5_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups5,HealBot_Options_BuffGroups5_DropDown)
end

function HealBot_Options_BuffGroups6_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups6,HealBot_Options_BuffGroups6_DropDown)
end

function HealBot_Options_BuffGroups7_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups7,HealBot_Options_BuffGroups7_DropDown)
end

function HealBot_Options_BuffGroups8_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups8,HealBot_Options_BuffGroups8_DropDown)
end

function HealBot_Options_BuffGroups9_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups9,HealBot_Options_BuffGroups9_DropDown)
end

function HealBot_Options_BuffGroups10_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_BuffGroups10,HealBot_Options_BuffGroups10_DropDown)
end

local BuffSpellDropDownClass=nil
function HealBot_Options_BuffTxt1_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(1)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(1)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt1_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt1,BuffTextClass[HealBot_Options_getDropDownId_bySpec(1)])
end

function HealBot_Options_BuffTxt2_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(2)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(2)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt2_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt2,BuffTextClass[HealBot_Options_getDropDownId_bySpec(2)])
end

function HealBot_Options_BuffTxt3_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(3)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(3)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt3_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt3,BuffTextClass[HealBot_Options_getDropDownId_bySpec(3)])
end

function HealBot_Options_BuffTxt4_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(4)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(4)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt4_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt4,BuffTextClass[HealBot_Options_getDropDownId_bySpec(4)])
end

function HealBot_Options_BuffTxt5_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(5)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(5)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt5_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt5,BuffTextClass[HealBot_Options_getDropDownId_bySpec(5)])
end

function HealBot_Options_BuffTxt6_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(6)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(6)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt6_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt6,BuffTextClass[HealBot_Options_getDropDownId_bySpec(6)])
end

function HealBot_Options_BuffTxt7_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(7)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(7)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt7_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt7,BuffTextClass[HealBot_Options_getDropDownId_bySpec(7)])
end

function HealBot_Options_BuffTxt8_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(8)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(8)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt8_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt8,BuffTextClass[HealBot_Options_getDropDownId_bySpec(8)])
end

function HealBot_Options_BuffTxt9_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(9)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(9)]=HEALBOT_WORDS_NONE end;
    if not onselect then HealBot_Options_BuffTxt9_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt9,BuffTextClass[HealBot_Options_getDropDownId_bySpec(9)])
end

function HealBot_Options_BuffTxt10_Refresh(onselect)
    BuffTextClass = HealBot_Config.HealBotBuffText
    if not BuffTextClass[HealBot_Options_getDropDownId_bySpec(10)] then BuffTextClass[HealBot_Options_getDropDownId_bySpec(10)]=HEALBOT_WORDS_NONE  end;
    if not onselect then HealBot_Options_BuffTxt10_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedValue(HealBot_Options_BuffTxt10,BuffTextClass[HealBot_Options_getDropDownId_bySpec(10)])
end

local BuffDropDownClass=nil
function HealBot_Options_BuffGroups1_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)]=4 end;
    if not onselect then HealBot_Options_BuffGroups1_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups1,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)])
end

function HealBot_Options_BuffGroups2_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)]=4 end;
    if not onselect then HealBot_Options_BuffGroups2_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups2,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)])
end

function HealBot_Options_BuffGroups3_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)]=4 end;
    if not onselect then HealBot_Options_BuffGroups3_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups3,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)])
end

function HealBot_Options_BuffGroups4_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(4)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(4)]=4 end;
    if not onselect then HealBot_Options_BuffGroups4_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups4,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(4)])
end

function HealBot_Options_BuffGroups5_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(5)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(5)]=4 end;
    if not onselect then HealBot_Options_BuffGroups5_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups5,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(5)])
end

function HealBot_Options_BuffGroups6_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(6)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(6)]=4 end;
    if not onselect then HealBot_Options_BuffGroups6_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups6,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(6)])
end

function HealBot_Options_BuffGroups7_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(7)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(7)]=4 end;
    if not onselect then HealBot_Options_BuffGroups7_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups7,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(7)])
end

function HealBot_Options_BuffGroups8_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(8)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(8)]=4 end;
    if not onselect then HealBot_Options_BuffGroups8_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups8,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(8)])
end

function HealBot_Options_BuffGroups9_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(9)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(9)]=4 end;
    if not onselect then HealBot_Options_BuffGroups9_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups9,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(9)])
end

function HealBot_Options_BuffGroups10_Refresh(onselect)
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    if not BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(10)] then BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(10)]=4 end;
    if not onselect then HealBot_Options_BuffGroups10_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_BuffGroups10,BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(10)])
end

function HealBot_Options_BuffTxt1_OnLoad(self)
    HealBot_Options_BuffTxt1_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt2_OnLoad(self)
    HealBot_Options_BuffTxt2_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt3_OnLoad(self)
    HealBot_Options_BuffTxt3_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt4_OnLoad(self)
    HealBot_Options_BuffTxt4_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt5_OnLoad(self)
    HealBot_Options_BuffTxt5_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt6_OnLoad(self)
    HealBot_Options_BuffTxt6_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt7_OnLoad(self)
    HealBot_Options_BuffTxt7_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt8_OnLoad(self)
    HealBot_Options_BuffTxt8_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt9_OnLoad(self)
    HealBot_Options_BuffTxt9_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffTxt10_OnLoad(self)
    HealBot_Options_BuffTxt10_Initialize()
    UIDropDownMenu_SetWidth(self,175)
end

function HealBot_Options_BuffGroups1_OnLoad(self)
    HealBot_Options_BuffGroups1_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups2_OnLoad(self)
    HealBot_Options_BuffGroups2_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups3_OnLoad(self)
    HealBot_Options_BuffGroups3_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups4_OnLoad(self)
    HealBot_Options_BuffGroups4_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups5_OnLoad(self)
    HealBot_Options_BuffGroups5_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups6_OnLoad(self)
    HealBot_Options_BuffGroups6_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups7_OnLoad(self)
    HealBot_Options_BuffGroups7_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups8_OnLoad(self)
    HealBot_Options_BuffGroups8_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups9_OnLoad(self)
    HealBot_Options_BuffGroups9_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffGroups10_OnLoad(self)
    HealBot_Options_BuffGroups10_Initialize()
    UIDropDownMenu_SetWidth(self,95)
end

function HealBot_Options_BuffTxt1_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(1)] = this:GetText()
    HealBot_Options_BuffTxt1_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt2_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(2)] = this:GetText()
    HealBot_Options_BuffTxt2_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt3_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(3)] = this:GetText()
    HealBot_Options_BuffTxt3_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt4_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(4)] = this:GetText()
    HealBot_Options_BuffTxt4_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt5_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(5)] = this:GetText()
    HealBot_Options_BuffTxt5_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt6_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(6)] = this:GetText()
    HealBot_Options_BuffTxt6_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt7_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(7)] = this:GetText()
    HealBot_Options_BuffTxt7_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt8_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(8)] = this:GetText()
    HealBot_Options_BuffTxt8_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt9_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(9)] = this:GetText()
    HealBot_Options_BuffTxt9_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffTxt10_OnSelect()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffTextClass[HealBot_Options_getDropDownId_bySpec(10)] = this:GetText()
    HealBot_Options_BuffTxt10_Refresh(true)
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups1_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)] = this:GetID()
    HealBot_Options_BuffGroups1_Refresh(true)
    ClickedBuffGroupDD=1
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups2_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)] = this:GetID()
    HealBot_Options_BuffGroups2_Refresh(true)
    ClickedBuffGroupDD=2
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups3_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)] = this:GetID()
    HealBot_Options_BuffGroups3_Refresh(true)
    ClickedBuffGroupDD=3
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups4_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(4)] = this:GetID()
    HealBot_Options_BuffGroups4_Refresh(true)
    ClickedBuffGroupDD=4
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups5_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(5)] = this:GetID()
    HealBot_Options_BuffGroups5_Refresh(true)
    ClickedBuffGroupDD=5
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups6_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(6)] = this:GetID()
    HealBot_Options_BuffGroups6_Refresh(true)
    ClickedBuffGroupDD=6
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups7_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(7)] = this:GetID()
    HealBot_Options_BuffGroups7_Refresh(true)
    ClickedBuffGroupDD=7
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups8_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(8)] = this:GetID()
    HealBot_Options_BuffGroups8_Refresh(true)
    ClickedBuffGroupDD=8
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups9_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(9)] = this:GetID()
    HealBot_Options_BuffGroups9_Refresh(true)
    ClickedBuffGroupDD=9
    HealBot_setOptions_Timer(40)
end

function HealBot_Options_BuffGroups10_OnSelect()
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(10)] = this:GetID()
    HealBot_Options_BuffGroups10_Refresh(true)
    ClickedBuffGroupDD=10
    HealBot_setOptions_Timer(40)
end
--------------------------------------------------------------------------------

local HealBot_Options_ComboClass_List = {
    HEALBOT_DRUID,
    HEALBOT_PALADIN,
    HEALBOT_PRIEST,
    HEALBOT_SHAMAN,
}

local HealBot_Debuff_Item_List = {
    HEALBOT_PURIFICATION_POTION,
    HEALBOT_ELIXIR_OF_POISON_RES,
    HEALBOT_ANTI_VENOM,
    HEALBOT_POWERFUL_ANTI_VENOM,
}

function HealBot_Options_GetDebuffSpells_List(class)
    return HealBot_Debuff_Spells[class]
end

function HealBot_Options_GetRacialDebuffSpells_List(race)
    return HealBot_Racial_Debuff_Spells[race]
end

local DebuffSpells_List=nil
local RacialDebuffSpells_List=nil
function HealBot_Options_CDCTxt1_DropDown()
    DebuffSpells_List = HealBot_Options_GetDebuffSpells_List(strsub(HealBot_PlayerClassEN,1,4))
    RacialDebuffSpells_List = HealBot_Options_GetRacialDebuffSpells_List(strsub(HealBot_PlayerRaceEN,1,3))
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_CDCTxt1_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(DebuffSpells_List), 1 do
        sName, _=HealBot_GetSpellName(HealBot_GetSpellId(DebuffSpells_List[j]));
        if sName then
            for x,_ in pairs(info) do
                info[x]=nil;
            end
            info.text = sName;
            info.func = HealBot_Options_CDCTxt1_OnSelect;
            UIDropDownMenu_AddButton(info);
        end
    end
    for j=1, getn(RacialDebuffSpells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = RacialDebuffSpells_List[j];
        info.func = HealBot_Options_CDCTxt1_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
    for j=1, getn(HealBot_Debuff_Item_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Debuff_Item_List[j];
        info.func = HealBot_Options_CDCTxt1_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_CDCTxt2_DropDown()
    DebuffSpells_List = HealBot_Options_GetDebuffSpells_List(strsub(HealBot_PlayerClassEN,1,4))
    RacialDebuffSpells_List = HealBot_Options_GetRacialDebuffSpells_List(strsub(HealBot_PlayerRaceEN,1,3))
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_CDCTxt2_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(DebuffSpells_List), 1 do
        sName, _=HealBot_GetSpellName(HealBot_GetSpellId(DebuffSpells_List[j]));
        if sName then
            for x,_ in pairs(info) do
                info[x]=nil;
            end
            info.text = sName;
            info.func = HealBot_Options_CDCTxt2_OnSelect;
            UIDropDownMenu_AddButton(info);
        end
    end
    for j=1, getn(RacialDebuffSpells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = RacialDebuffSpells_List[j];
        info.func = HealBot_Options_CDCTxt2_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
    for j=1, getn(HealBot_Debuff_Item_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Debuff_Item_List[j];
        info.func = HealBot_Options_CDCTxt2_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_CDCTxt3_DropDown()
    DebuffSpells_List = HealBot_Options_GetDebuffSpells_List(strsub(HealBot_PlayerClassEN,1,4))
    RacialDebuffSpells_List = HealBot_Options_GetRacialDebuffSpells_List(strsub(HealBot_PlayerRaceEN,1,3))
    for x,_ in pairs(info) do
        info[x]=nil;
    end
    info.text = HEALBOT_WORDS_NONE;
    info.func = HealBot_Options_CDCTxt3_OnSelect;
    UIDropDownMenu_AddButton(info);
    for j=1, getn(DebuffSpells_List), 1 do
        sName, _=HealBot_GetSpellName(HealBot_GetSpellId(DebuffSpells_List[j]));
        if sName then
            for x,_ in pairs(info) do
                info[x]=nil;
            end
            info.text = sName;
            info.func = HealBot_Options_CDCTxt3_OnSelect;
            UIDropDownMenu_AddButton(info);
        end
    end
    for j=1, getn(RacialDebuffSpells_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = RacialDebuffSpells_List[j];
        info.func = HealBot_Options_CDCTxt3_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
    for j=1, getn(HealBot_Debuff_Item_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Debuff_Item_List[j];
        info.func = HealBot_Options_CDCTxt3_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_CDCGroups1_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_CDCGroups1_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_CDCGroups2_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_CDCGroups2_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_CDCGroups3_DropDown()
    for j=1, getn(HealBot_Options_BuffTxt_List), 1 do
        for x,_ in pairs(info) do
            info[x]=nil;
        end   
        info.text = HealBot_Options_BuffTxt_List[j];
        info.func = HealBot_Options_CDCGroups3_OnSelect;
        UIDropDownMenu_AddButton(info);
    end
end

function HealBot_Options_CDCTxt1_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDCTxt1,HealBot_Options_CDCTxt1_DropDown)
end

function HealBot_Options_CDCTxt2_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDCTxt2,HealBot_Options_CDCTxt2_DropDown)
end

function HealBot_Options_CDCTxt3_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDCTxt3,HealBot_Options_CDCTxt3_DropDown)
end

function HealBot_Options_CDCGroups1_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDCGroups1,HealBot_Options_CDCGroups1_DropDown)
end

function HealBot_Options_CDCGroups2_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDCGroups2,HealBot_Options_CDCGroups2_DropDown)
end

function HealBot_Options_CDCGroups3_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDCGroups3,HealBot_Options_CDCGroups3_DropDown)
end

local DebuffSpellDropDownClass=nil
function HealBot_Options_CDCTxt1_Refresh(onselect)
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    if not DebuffTextClass[HealBot_Options_getDropDownId_bySpec(1)] then return; end
    if not onselect then HealBot_Options_CDCTxt1_Initialize() end 
    UIDropDownMenu_SetSelectedValue(HealBot_Options_CDCTxt1,DebuffTextClass[HealBot_Options_getDropDownId_bySpec(1)])
end

function HealBot_Options_CDCTxt2_Refresh(onselect)
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    if not DebuffTextClass[HealBot_Options_getDropDownId_bySpec(2)] then return; end
    if not onselect then HealBot_Options_CDCTxt2_Initialize() end 
    UIDropDownMenu_SetSelectedValue(HealBot_Options_CDCTxt2,DebuffTextClass[HealBot_Options_getDropDownId_bySpec(2)])
end

function HealBot_Options_CDCTxt3_Refresh(onselect)
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    if not DebuffTextClass[HealBot_Options_getDropDownId_bySpec(3)] then return; end
    if not onselect then HealBot_Options_CDCTxt3_Initialize() end 
    UIDropDownMenu_SetSelectedValue(HealBot_Options_CDCTxt3,DebuffTextClass[HealBot_Options_getDropDownId_bySpec(3)])
end

local DebuffDropDownClass=nil
function HealBot_Options_CDCGroups1_Refresh(onselect)
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    if not DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)] then return end;
    if not onselect then HealBot_Options_CDCGroups1_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_CDCGroups1,DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)])
end

function HealBot_Options_CDCGroups2_Refresh(onselect)
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    if not DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)] then return end;
    if not onselect then HealBot_Options_CDCGroups2_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_CDCGroups2,DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)])
end

function HealBot_Options_CDCGroups3_Refresh(onselect)
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    if not DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)] then return end;
    if not onselect then HealBot_Options_CDCGroups3_Initialize() end  -- or wrong menu may be used !
    UIDropDownMenu_SetSelectedID(HealBot_Options_CDCGroups3,DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)])
end

local combo=nil
local button=nil
function HealBot_Options_ComboClass_Text()
    if HealBot_ActionBarsCombo==1 then
        combo = HealBot_Config.EnabledKeyCombo;
    else
        combo = HealBot_Config.DisabledKeyCombo;
    end
    button = HealBot_Options_ComboClass_Button(HealBot_Options_ComboButtons_Button)
    if combo then
        if HealBot_Config.UniqueSpellComboToSpec==1 then
            HealBot_Options_Click:SetText(combo[button..HealBot_Config.CurrentSpec] or "")
            HealBot_Options_Shift:SetText(combo["Shift"..button..HealBot_Config.CurrentSpec] or "")
            HealBot_Options_Ctrl:SetText(combo["Ctrl"..button..HealBot_Config.CurrentSpec] or "")
            HealBot_Options_Alt:SetText(combo["Alt"..button..HealBot_Config.CurrentSpec] or "")
        else
            HealBot_Options_Click:SetText(combo[button] or "")
            HealBot_Options_Shift:SetText(combo["Shift"..button] or "")
            HealBot_Options_Ctrl:SetText(combo["Ctrl"..button] or "")
            HealBot_Options_Alt:SetText(combo["Alt"..button] or "")
        end
    end
end

function HealBot_Options_CDCTxt1_OnLoad(self)
    UIDropDownMenu_SetWidth(self,180)
    HealBot_Options_CDCTxt1_Initialize()
end

function HealBot_Options_CDCTxt2_OnLoad(self)
    UIDropDownMenu_SetWidth(self,180)
    HealBot_Options_CDCTxt2_Initialize()
end

function HealBot_Options_CDCTxt3_OnLoad(self)
    UIDropDownMenu_SetWidth(self,180)
    HealBot_Options_CDCTxt3_Initialize()
end

function HealBot_Options_CDCGroups1_OnLoad(self)
    UIDropDownMenu_SetWidth(self,110)
    HealBot_Options_CDCGroups1_Initialize()
end

function HealBot_Options_CDCGroups2_OnLoad(self)
    UIDropDownMenu_SetWidth(self,110)
    HealBot_Options_CDCGroups2_Initialize()
end

function HealBot_Options_CDCGroups3_OnLoad(self)
    UIDropDownMenu_SetWidth(self,110)
    HealBot_Options_CDCGroups3_Initialize()
end

local DebuffTextClass=nil
function HealBot_Options_CDCTxt1_OnSelect()
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    DebuffTextClass[HealBot_Options_getDropDownId_bySpec(1)] = this:GetText()
    HealBot_Options_CDCTxt1_Refresh(true)
    HealBot_setOptions_Timer(50)
end

function HealBot_Options_CDCTxt2_OnSelect()
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    DebuffTextClass[HealBot_Options_getDropDownId_bySpec(2)] = this:GetText()
    HealBot_Options_CDCTxt2_Refresh(true)
    HealBot_setOptions_Timer(50)
end

function HealBot_Options_CDCTxt3_OnSelect()
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    DebuffTextClass[HealBot_Options_getDropDownId_bySpec(3)] = this:GetText()
    HealBot_Options_CDCTxt3_Refresh(true)
    HealBot_setOptions_Timer(50)
end

function HealBot_Options_CDCGroups1_OnSelect()
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(1)] = this:GetID()
    HealBot_Options_CDCGroups1_Refresh(true)
    ClickedBuffGroupDD=1
    HealBot_setOptions_Timer(50)
end

function HealBot_Options_CDCGroups2_OnSelect()
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(2)] = this:GetID()
    HealBot_Options_CDCGroups2_Refresh(true)
    ClickedBuffGroupDD=2
    HealBot_setOptions_Timer(50)
end

function HealBot_Options_CDCGroups3_OnSelect()
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(3)] = this:GetID()
    HealBot_Options_CDCGroups3_Refresh(true)
    ClickedBuffGroupDD=3
    HealBot_setOptions_Timer(50)
end

local t=nil
local t2={}
function HealBot_Options_CDebuffTxt1_DropDown() -- added by Diacono
    t = HealBot_Config.HealBot_Custom_Debuffs
    if t then
        for x,_ in pairs(t2) do
            t2[x]=nil;
        end
        table.foreach (t, function (k) table.insert (t2, k) end )
        table.sort (t2)
  
        for x,_ in pairs(info) do
            info[x]=nil;
        end

        for j=1, getn(t2), 1 do
            for x,_ in pairs(info) do
                info[x]=nil;
            end
            info.text = t2[j];
            info.func = HealBot_Options_CDebuffTxt1_OnSelect;
            UIDropDownMenu_AddButton(info);
        end
    end
end

function HealBot_Options_CDebuffTxt1_OnSelect()
    UIDropDownMenu_SetSelectedValue(HealBot_Options_CDebuffTxt1, this.value);
    HealBot_Options_DeleteCDebuffBtn:Enable();
end

function HealBot_Options_CDebuffTxt1_Initialize()
    UIDropDownMenu_Initialize(HealBot_Options_CDebuffTxt1,HealBot_Options_CDebuffTxt1_DropDown)
end

function HealBot_Options_CDebuffTxt1_OnLoad(self)
    HealBot_Options_CDebuffTxt1_Initialize()
    UIDropDownMenu_SetWidth(self,140)
end

function HealBot_Options_NewCDebuff_OnTextChanged(self)
    text = strtrim(self:GetText())
    if strlen(text)>0 then
        HealBot_Options_NewCDebuffBtn:Enable();
    else
        HealBot_Options_NewCDebuffBtn:Disable();
    end
end

function HealBot_Options_GetSpellInfo_OnEnterPressed(self)
    text = strtrim(self:GetText())
    if tonumber(text) then
        text = GetSpellInfo(text)
    end
    self:SetText(text or "")
end

StaticPopupDialogs["HEALBOT_OPTIONS_ERROR"] = {
    text = HEALBOT_WORDS_ERROR..": %s",
    button1 = OKAY,
    showAlert = 1,
    timeout = 0,
    whileDead = 1,
    hideOnEscape = 1
};

StaticPopupDialogs["HEALBOT_OPTIONS_NEWCDEBUFF"] = {
    text = HEALBOT_OPTIONS_SAVESKIN..": %s",
    button1 = HEALBOT_WORDS_YES,
    button2 = HEALBOT_WORDS_NO,
    OnAccept = function()
        HealBot_Options_NewCDebuffBtn_OnClick(HealBot_Options_NewCDebuffBtn)
    end,
    timeout = 0,
    whileDead = 1,
    hideOnEscape = 1
};

local NewCDebuffTxt=nil
function HealBot_Options_NewCDebuffBtn_OnClick(self)
    NewCDebuffTxt=HealBot_Options_NewCDebuff:GetText()
    unique=true;
    for k, _ in pairs(HealBot_Config.HealBot_Custom_Debuffs) do
        if k==NewCDebuffTxt then unique=false; end
    end
    if unique then
        HealBot_Config.HealBot_Custom_Debuffs[NewCDebuffTxt]=true;
    end
    HealBot_Options_NewCDebuff:SetText("")
    HealBot_Options_CDebuffTxt1_Initialize()
    UIDropDownMenu_SetSelectedValue(HealBot_Options_CDebuffTxt1, NewCDebuffTxt);
end

function HealBot_Options_ConfirmNewCDebuff()
    NewCDebuffTxt=strtrim(HealBot_Options_NewCDebuff:GetText())
    HealBot_Options_NewCDebuff:SetText(NewCDebuffTxt)
    if tonumber(NewCDebuffTxt) then
        NewCDebuffTxt = GetSpellInfo(NewCDebuffTxt)
        if not NewCDebuffTxt then 
            StaticPopup_Show ("HEALBOT_OPTIONS_ERROR", HEALBOT_SPELL_NOT_FOUND);
        else
            HealBot_Options_NewCDebuff:SetText(NewCDebuffTxt)
        end
    end
    if NewCDebuffTxt and NewCDebuffTxt ~= "" then
        StaticPopup_Show ("HEALBOT_OPTIONS_NEWCDEBUFF", NewCDebuffTxt);
    end
end

function HealBot_Options_DeleteCDebuffBtn_OnClick(self)
    HealBot_Config.HealBot_Custom_Debuffs[HealBot_Options_CDebuffTxt1.selectedValue]=nil;
    UIDropDownMenu_ClearAll(HealBot_Options_CDebuffTxt1);
    HealBot_Options_DeleteCDebuffBtn:Disable();
    HealBot_Options_CDebuffTxt1_Initialize()
end

----------------------------------------------------------------------------------

function HealBot_Options_getDropDownId_bySpec(ddId)
    if HealBot_Config.UniqueSpellComboToSpec==1 and HealBot_Config.CurrentSpec then
        return HealBot_Config.CurrentSpec..ddId
    else
        return ddId
    end
end

function HealBot_Options_ComboClass_Button(bNo)
    if bNo==2 then 
        button = "Middle"
    elseif bNo==3 then 
        button = "Right"
    elseif bNo==4 then 
        button = "Button4"
    elseif bNo==5 then 
        button = "Button5"
    else 
        button = "Left"
    end
    return button;
end

local usable=nil
local HealBot_DebuffWatchTargetSpell=nil
local FirstDebuffLoad=true
function HealBot_Options_Debuff_Reset()
    HealBot_DebuffWatchTarget[HEALBOT_DISEASE_en] = {HEALBOT_DISEASE_en = {}};
    HealBot_DebuffWatchTarget[HEALBOT_POISON_en] = {HEALBOT_POISON_en = {}};
    HealBot_DebuffWatchTarget[HEALBOT_MAGIC_en] = {HEALBOT_MAGIC_en = {}};
    HealBot_DebuffWatchTarget[HEALBOT_CURSE_en] = {HEALBOT_CURSE_en = {}};
    HealBot_DebuffWatchTarget[HEALBOT_CUSTOM_en] = {HEALBOT_CUSTOM_en = {}}; -- added by Diacono
    for x,_ in pairs(HealBot_DebuffSpell) do
        HealBot_DebuffSpell[x]=nil;
    end
    HealBot_DebuffPriority = nil;
    DebuffTextClass = HealBot_Config.HealBotDebuffText
    DebuffDropDownClass = HealBot_Config.HealBotDebuffDropDown
    
    for k=1,3 do
        if DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)] and DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]>1 then
            id=HealBot_GetSpellId(DebuffTextClass[HealBot_Options_getDropDownId_bySpec(k)]);
            sName,spellrank = HealBot_GetSpellName(id);
            if not sName then
                usable, _ = IsUsableItem(DebuffTextClass[HealBot_Options_getDropDownId_bySpec(k)]);
                if usable then
                    sName=DebuffTextClass[HealBot_Options_getDropDownId_bySpec(k)];
                end
            end
            if HealBot_Debuff_Types[sName] then
                table.foreach(HealBot_Debuff_Types[sName], function (i,dName)
                    
                    if not HealBot_DebuffSpell[dName] then
                        HealBot_DebuffSpell[dName]=sName;
                    end
                    HealBot_DebuffWatchTargetSpell=HealBot_DebuffWatchTarget[dName];

                    if not HealBot_DebuffPriority then
                        HealBot_DebuffPriority=dName;
                    end
                    if DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==2 then
                        HealBot_DebuffWatchTargetSpell["Self"]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==3 then
                        HealBot_DebuffWatchTargetSpell["Party"]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==4 then
                        HealBot_DebuffWatchTargetSpell["Raid"]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==5 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==6 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==7 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==8 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==9 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==10 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==11 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==12 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==13 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==14 then
                        HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==15 then
                        if HealBot_Config.EmergIncMelee[HEALBOT_DRUID]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_HUNTER]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_MAGE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_PALADIN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_PRIEST]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_ROGUE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_SHAMAN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_WARLOCK]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_WARRIOR]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                        end
                        if HealBot_Config.EmergIncMelee[HEALBOT_DEATHKNIGHT]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                        end
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==16 then
                        if HealBot_Config.EmergIncRange[HEALBOT_DRUID]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_HUNTER]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_MAGE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_PALADIN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_PRIEST]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_ROGUE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_SHAMAN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_WARLOCK]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_WARRIOR]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                        end
                        if HealBot_Config.EmergIncRange[HEALBOT_DEATHKNIGHT]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                        end
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==17 then
                        if HealBot_Config.EmergIncHealers[HEALBOT_DRUID]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_HUNTER]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_MAGE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_PALADIN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_PRIEST]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_ROGUE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_SHAMAN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_WARLOCK]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_WARRIOR]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                        end
                        if HealBot_Config.EmergIncHealers[HEALBOT_DEATHKNIGHT]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                        end
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==18 then
                        if HealBot_Config.EmergIncCustom[HEALBOT_DRUID]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_HUNTER]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_MAGE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_PALADIN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_PRIEST]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_ROGUE]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_SHAMAN]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_WARLOCK]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_WARRIOR]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                        end
                        if HealBot_Config.EmergIncCustom[HEALBOT_DEATHKNIGHT]==1 then
                            HealBot_DebuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                        end
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==19 then
                        HealBot_DebuffWatchTargetSpell["PvP"]=true
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==20 then
                        HealBot_DebuffWatchTargetSpell["MainTanks"]=true
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==21 then
                        HealBot_DebuffWatchTargetSpell["MyTargets"]=true
                    elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==22 then
                        HealBot_DebuffWatchTargetSpell["Focus"]=true
					elseif DebuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==23 then
						HealBot_DebuffWatchTargetSpell["Name"]=true
                        if not FirstDebuffLoad then HealBot_Options_Get_deBuffWatchGUID(sName, "Debuff", k) end
                    end        
                end)
            end
        end
        HealBot_setOptions_Timer(20)
    end
    FirstDebuffLoad=nil
end


local spells={}
local Monitor_Buffs=nil
local HealBot_BuffWatchTargetSpell=nil
local FirstBuffLoad=true
function HealBot_Options_Buff_Reset()
    BuffTextClass = HealBot_Config.HealBotBuffText
    BuffDropDownClass = HealBot_Config.HealBotBuffDropDown
    buffbarcolrClass = HealBot_Config.HealBotBuffColR
    buffbarcolgClass = HealBot_Config.HealBotBuffColG
    buffbarcolbClass = HealBot_Config.HealBotBuffColB
    Monitor_Buffs=false;
    for x,_ in pairs(spells) do
        spells[x]=nil;
    end
    HealBot_Clear_BuffWatch()
    for x,_ in pairs(HealBot_BuffWatchTarget) do
        HealBot_BuffWatchTarget[x]=nil;
    end
    for x,_ in pairs(HealBot_buffbarcolr) do
        HealBot_buffbarcolr[x]=nil;
    end
    for x,_ in pairs(HealBot_buffbarcolg) do
        HealBot_buffbarcolg[x]=nil;
    end
    for x,_ in pairs(HealBot_buffbarcolb) do
        HealBot_buffbarcolb[x]=nil;
    end
    HealBot_Tooltip_Clear_CheckBuffs()
    
    for k=1,10 do
        if BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)] and BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]>1 then
            id=HealBot_GetSpellId(BuffTextClass[HealBot_Options_getDropDownId_bySpec(k)]);
            sName,_ = HealBot_GetSpellName(id);

            if sName then
                if not spells[sName] then
                    spells[sName]=sName;
                    HealBot_Set_BuffWatch(sName)
                    HealBot_BuffWatchTarget[sName] = {sName = {}};
                    Monitor_Buffs=true;
                end

                HealBot_BuffWatchTargetSpell=HealBot_BuffWatchTarget[sName];
                HealBot_Tooltip_CheckBuffs(sName)
        
                if BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==2 then
                    HealBot_BuffWatchTargetSpell["Self"]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==3 then
                    HealBot_BuffWatchTargetSpell["Party"]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==4 then
                    HealBot_BuffWatchTargetSpell["Raid"]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==5 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==6 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==7 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==8 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==9 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==10 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==11 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==12 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==13 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==14 then
                    HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==15 then
                    if HealBot_Config.EmergIncMelee[HEALBOT_DRUID]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_HUNTER]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_MAGE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_PALADIN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_PRIEST]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_ROGUE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_SHAMAN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_WARLOCK]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_WARRIOR]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                    end
                    if HealBot_Config.EmergIncMelee[HEALBOT_DEATHKNIGHT]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                    end
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==16 then
                    if HealBot_Config.EmergIncRange[HEALBOT_DRUID]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_HUNTER]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_MAGE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_PALADIN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_PRIEST]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_ROGUE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_SHAMAN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_WARLOCK]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_WARRIOR]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                    end
                    if HealBot_Config.EmergIncRange[HEALBOT_DEATHKNIGHT]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                    end
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==17 then
                    if HealBot_Config.EmergIncHealers[HEALBOT_DRUID]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_HUNTER]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_MAGE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_PALADIN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_PRIEST]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_ROGUE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_SHAMAN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_WARLOCK]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_WARRIOR]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                    end
                    if HealBot_Config.EmergIncHealers[HEALBOT_DEATHKNIGHT]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                    end
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==18 then
                    if HealBot_Config.EmergIncCustom[HEALBOT_DRUID]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DRUID]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_HUNTER]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_HUNTER]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_MAGE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_MAGE]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_PALADIN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PALADIN]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_PRIEST]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_PRIEST]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_ROGUE]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_ROGUE]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_SHAMAN]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_SHAMAN]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_WARLOCK]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARLOCK]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_WARRIOR]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_WARRIOR]]=true;
                    end
                    if HealBot_Config.EmergIncCustom[HEALBOT_DEATHKNIGHT]==1 then
                        HealBot_BuffWatchTargetSpell[HealBot_Class_En[HEALBOT_DEATHKNIGHT]]=true;
                    end
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==19 then
                    HealBot_BuffWatchTargetSpell["PvP"]=true
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==20 then
                    HealBot_BuffWatchTargetSpell["MainTanks"]=true
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==21 then
                    HealBot_BuffWatchTargetSpell["MyTargets"]=true
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==22 then
                    HealBot_BuffWatchTargetSpell["MyTargets"]=true
                elseif BuffDropDownClass[HealBot_Options_getDropDownId_bySpec(k)]==23 then
                    HealBot_BuffWatchTargetSpell["Name"]=true
                    if not FirstBuffLoad then HealBot_Options_Get_BuffWatchGUID(sName, "Buff", k) end
                end
                HealBot_buffbarcolr[sName]=buffbarcolrClass[k];
                HealBot_buffbarcolg[sName]=buffbarcolgClass[k];
                HealBot_buffbarcolb[sName]=buffbarcolbClass[k];
            end
            HealBot_setOptions_Timer(30)
        end
    end
    FirstBuffLoad=nil
end

local BuffWatchSpell=" "
StaticPopupDialogs["HEALBOT_OPTIONS_BUFFNAMEDTITLE"] = {
    text = HEALBOT_OPTIONS_BUFFNAMED.."%s",
    button1 = ACCEPT,
    button2 = CANCEL,
    OnShow = function()
        getglobal(this:GetName().."WideEditBox"):SetText(HealBot_GuessName())
    end,
    OnAccept = function()
        HealBot_Options_Set_BuffWatchGUID(getglobal(this:GetParent():GetName().."WideEditBox"):GetText())
    end,
    OnCancel = function()
        -- do nothing
    end,
    timeout = 0,
    whileDead = 1,
    hideOnEscape = 1,
    hasEditBox = 1,
    hasWideEditBox = 1,
};

local gName=nil
local gGUID=nil
local myTargets={}
function HealBot_GuessName()
    gName=nil
    gGUID=nil

    if HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell] and (type(HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell]) == "table") then
        tGUID=HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell]
        for uGUID,_ in pairs(tGUID) do
            if HealBot_UnitName[uGUID] then
                if gName then
                    gName=gName..","..HealBot_UnitName[uGUID]
                else
                    gName=HealBot_UnitName[uGUID]
                end
            end
        end
    end
    
    if not gName then
        if UnitName("Target") and HealBot_UnitName[HealBot_UnitGUID("Target")] then
            gName=UnitName("Target")
        end
        for j=1,10 do
            gGUID=HealBot_retHealBot_MainTanks(j)
            if HealBot_UnitName[gGUID] then
                if gName then 
                    gName=gName..","..HealBot_UnitName[gGUID]
                else
                    gName=HealBot_UnitName[gGUID]
                end
                do break end
            end
            if not gGUID then
                do break end
            end
        end
        myTargets=HealBot_GetMyHealTargets()
        x=true
        table.foreach(myTargets, function (i,myGUID)
            if HealBot_UnitName[myGUID] then
                if gName and x then 
                    gName=gName..","..HealBot_UnitName[gGUID]
                    x=nil
                elseif x then
                    gName=HealBot_UnitName[gGUID]
                end
            end  
        end)
        if not gName then
            if UnitName("Party1") and HealBot_UnitName[UnitGUID("Party1")] then
                gName=UnitName("Party1")
            elseif UnitName("Party2") and HealBot_UnitName[UnitGUID("Party2")] then
                gName=UnitName("Party2")
            elseif UnitName("Party3") and HealBot_UnitName[UnitGUID("Party3")] then
                gName=UnitName("Party3")
            elseif UnitName("Party4") and HealBot_UnitName[UnitGUID("Party4")] then
                gName=UnitName("Party4")
            end
        end
        if gName then 
            gName=gName..","..UnitName("Player")
        else
            gName=UnitName("Player")..","..HEALBOT_SORTBY_NAME
        end
    end
       
    if not gName then gName=HEALBOT_SORTBY_NAME..","..HEALBOT_SORTBY_NAME end
    return gName
end

local BuffWatchType=nil
local BuffWatchID=nil
local Uname=nil
function HealBot_Options_Set_BuffWatchGUID(unitName)
    
    if BuffWatchType=="Buff" and HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell] then
        tGUID=HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell]
        if tGUID and type(tGUID)=="table" then
            for uGUID,_ in pairs(tGUID) do
                if HealBot_UnitBuff[uGUID] and HealBot_UnitBuff[uGUID]==BuffWatchSpell then
                    HealBot_UnitBuff[uGUID]=nil
                end
            end
        elseif tGUID then
            if HealBot_UnitBuff[tGUID] and HealBot_UnitBuff[tGUID]==BuffWatchSpell then
                HealBot_UnitBuff[tGUID]=nil
            end
        end
    end

    if strfind(unitName,",") then tName = HealBot_Split(unitName, ","); end
    tGUID={}

    if tName and type(tName)=="table" then
        for _,uName in pairs(tName) do
            if not HealBot_Derive_GUID_fuName(uName) then
                uName=HealBot_Options_CleanName(uName)
            else
                tinsert(tGUID, HealBot_Derive_GUID_fuName(uName));
            end
        end
    elseif tName then
        if not HealBot_Derive_GUID_fuName(tName) then
            tName=HealBot_Options_CleanName(tName)
        else
            tinsert(tGUID, HealBot_Derive_GUID_fuName(tName));
        end
    end
    
    HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell]={}
    
    for _,uGUID in pairs(tGUID) do
        HealBot_Config.HealBot_BuffWatchGUID[BuffWatchSpell][uGUID]=uGUID 
    end
end

function HealBot_Options_CleanName(unitName)
    Uname=strtrim(unitName)
    Uname=strupper(strsub(Uname, 1, 1))..strlower(strsub(Uname, 2))
    return Uname
end

function HealBot_Options_Get_BuffWatchGUID(spellName, BuffType, ddID)
    if not ClickedBuffGroupDD or ClickedBuffGroupDD~=ddID then return end
    BuffWatchSpell=spellName
    BuffWatchType=BuffType
    BuffWatchID=ddID
    StaticPopup_Show ("HEALBOT_OPTIONS_BUFFNAMEDTITLE", BuffWatchSpell);
    ClickedBuffGroupDD=nil
end

function HealBot_Options_Get_deBuffWatchGUID(spellName, BuffType, ddID)
    if not ClickedBuffGroupDD or ClickedBuffGroupDD~=ddID then return end
    BuffWatchSpell=spellName
    BuffWatchType=BuffType
    BuffWatchID=ddID
    StaticPopup_Show ("HEALBOT_OPTIONS_BUFFNAMEDTITLE", BuffWatchSpell);
    ClickedBuffGroupDD=nil
end

function HealBot_Options_RetBuffRGB(spellName)
    return HealBot_buffbarcolr[spellName],HealBot_buffbarcolg[spellName],HealBot_buffbarcolb[spellName];
end

function HealBot_Colorpick_OnClick(CDCType)
    HealBot_ColourObjWaiting=CDCType;
    HealBot_UseColourPick(HealBot_Config.CDCBarColour[CDCType].R,HealBot_Config.CDCBarColour[CDCType].G,HealBot_Config.CDCBarColour[CDCType].B, nil)
end

local R=nil
local G=nil
local B=nil
local A=nil
local setskincols=true
function HealBot_Returned_Colours(R, G, B, A)
  --R, G, B = ColorPickerFrame:GetColorRGB(); -- added by Diacono
  --A = OpacitySliderFrame:GetValue();
    if A then
        A = ((0-A)+1);
    end
    setskincols=true;
    if HealBot_ColourObjWaiting=="En" then
        Healbot_Config_Skins.btextenabledcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextenabledcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextenabledcolb[Healbot_Config_Skins.Current_Skin], 
        Healbot_Config_Skins.btextenabledcola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="Dis" then
        Healbot_Config_Skins.btextdisbledcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextdisbledcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextdisbledcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextdisbledcola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="Debuff" then
        Healbot_Config_Skins.btextcursecolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextcursecolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextcursecolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.btextcursecola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="Back" then
        Healbot_Config_Skins.backcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.backcola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="Bor" then
        Healbot_Config_Skins.borcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.borcola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="HeadB" then
        Healbot_Config_Skins.headbarcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headbarcola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="HeadT" then
        Healbot_Config_Skins.headtxtcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headtxtcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headtxtcolb[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.headtxtcola[Healbot_Config_Skins.Current_Skin] = R, G, B, A;
    elseif HealBot_ColourObjWaiting=="CustomBar" then
        Healbot_Config_Skins.barcolr[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.barcolg[Healbot_Config_Skins.Current_Skin],
        Healbot_Config_Skins.barcolb[Healbot_Config_Skins.Current_Skin] = R, G, B;
        HealBot_Action_ResetUnitStatus()
    elseif strsub(HealBot_ColourObjWaiting ,1,4)=="Buff" then
        id=tonumber(strsub(HealBot_ColourObjWaiting ,5));
        buffbarcolrClass = HealBot_Config.HealBotBuffColR
        buffbarcolgClass = HealBot_Config.HealBotBuffColG
        buffbarcolbClass = HealBot_Config.HealBotBuffColB
        buffbarcolrClass[id],
        buffbarcolgClass[id],
        buffbarcolbClass[id] = R, G, B;
        HealBot_setOptions_Timer(100)
        setskincols=false;
    else
        HealBot_Config.CDCBarColour[HealBot_ColourObjWaiting].R,
        HealBot_Config.CDCBarColour[HealBot_ColourObjWaiting].G,
        HealBot_Config.CDCBarColour[HealBot_ColourObjWaiting].B = R, G, B;
        HealBot_SetCDCBarColours();
        setskincols=false;
    end
    if setskincols then
        HealBot_setOptions_Timer(90)
    end
end

local prevR, prevG, prevB, prevA=nil,nil,nil,nil
function HealBot_UseColourPick(R, G, B, A)
    if not R then R=1 end
    if not G then G=1 end
    if not B then B=1 end
    prevR, prevG, prevB, prevA = R, G, B, A;
    if ColorPickerFrame:IsVisible() then 
        ColorPickerFrame:Hide();
    elseif A then
        ColorPickerFrame.hasOpacity = true;
        ColorPickerFrame.opacity = 1-A;
        ColorPickerFrame.func = function() local r,g,b=ColorPickerFrame:GetColorRGB(); local a=OpacitySliderFrame:GetValue() HealBot_Returned_Colours(r,g,b,a); end;
        ColorPickerFrame.cancelFunc = function() HealBot_Returned_Colours(prevR, prevG, prevB, 1-prevA); end; --added by Diacono
        ColorPickerFrame:ClearAllPoints();
        ColorPickerFrame:SetPoint("TOPLEFT","HealBot_Options","TOPRIGHT",0,-152);
        OpacitySliderFrame:SetValue(1-A);
        ColorPickerFrame:SetColorRGB(R, G, B);
        ColorPickerFrame:Show();
    else
        ColorPickerFrame.hasOpacity = false;
        ColorPickerFrame.func = function() HealBot_Returned_Colours(ColorPickerFrame:GetColorRGB()); end;
        ColorPickerFrame.cancelFunc = function() HealBot_Returned_Colours(prevR, prevG, prevB); end; --added by Diacono
        ColorPickerFrame:ClearAllPoints();
        ColorPickerFrame:SetPoint("TOPLEFT","HealBot_Options","TOPRIGHT",0,-152);
        ColorPickerFrame:SetColorRGB(R, G, B);
        ColorPickerFrame:Show();
    end
    return ColorPickerFrame:GetColorRGB();
end

function HealBot_SetCDCBarColours()
    HealBot_DiseaseColorpick:SetStatusBarColor(HealBot_Config.CDCBarColour[HEALBOT_DISEASE_en].R or 0.55,
                                               HealBot_Config.CDCBarColour[HEALBOT_DISEASE_en].G or 0.19,
                                               HealBot_Config.CDCBarColour[HEALBOT_DISEASE_en].B or 0.7,
                                               Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_MagicColorpick:SetStatusBarColor(HealBot_Config.CDCBarColour[HEALBOT_MAGIC_en].R or 0.26,
                                             HealBot_Config.CDCBarColour[HEALBOT_MAGIC_en].G or 0.33,
                                             HealBot_Config.CDCBarColour[HEALBOT_MAGIC_en].B or 0.83,
                                             Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_PoisonColorpick:SetStatusBarColor(HealBot_Config.CDCBarColour[HEALBOT_POISON_en].R or 0.12,
                                              HealBot_Config.CDCBarColour[HEALBOT_POISON_en].G or 0.46,
                                              HealBot_Config.CDCBarColour[HEALBOT_POISON_en].B or 0.24,
                                              Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_CurseColorpick:SetStatusBarColor(HealBot_Config.CDCBarColour[HEALBOT_CURSE_en].R or 0.83,
                                             HealBot_Config.CDCBarColour[HEALBOT_CURSE_en].G or 0.43,
                                             HealBot_Config.CDCBarColour[HEALBOT_CURSE_en].B or 0.09,
                                             Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_CustomColorpick:SetStatusBarColor(HealBot_Config.CDCBarColour[HEALBOT_CUSTOM_en].R or 0.45,
                                             HealBot_Config.CDCBarColour[HEALBOT_CUSTOM_en].G or 0,
                                             HealBot_Config.CDCBarColour[HEALBOT_CUSTOM_en].B or 0.26,
                                             Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
    HealBot_DebTextColorpick:SetStatusBarColor(HealBot_Config.CDCBarColour[HEALBOT_DISEASE_en].R or 0.1,
                                               HealBot_Config.CDCBarColour[HEALBOT_DISEASE_en].G or 0.05,
                                               HealBot_Config.CDCBarColour[HEALBOT_DISEASE_en].B or 0.2,
                                               Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin])
    HealBot_Action_SetDebuffAggroCols()
end

function HealBot_SetBuffBarColours()
    buffbarcolrClass = HealBot_Config.HealBotBuffColR
    buffbarcolgClass = HealBot_Config.HealBotBuffColG
    buffbarcolbClass = HealBot_Config.HealBotBuffColB

    for k=1,10 do
        bar=getglobal("HealBot_Buff"..k.."Colour")
        if bar then
            bar:SetStatusBarColor(buffbarcolrClass[k],
                                  buffbarcolgClass[k],
                                  buffbarcolbClass[k],
                                  Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin]);
        end
    end
    HealBot_setOptions_Timer(40)
end
--------------------------------------------------------------------------------

function HealBot_Options_NotifyChan_OnTextChanged(self)
    HealBot_Config.NotifyChan = self:GetText()
end

local spellText=nil
function HealBot_Options_Click_OnTextChanged(self)
    if HealBot_ActionBarsCombo==1 then
        combo = HealBot_Config.EnabledKeyCombo;
    else
        combo = HealBot_Config.DisabledKeyCombo;
    end
    button = HealBot_Options_ComboClass_Button(HealBot_Options_ComboButtons_Button)
    spellText = strtrim(self:GetText())
    if HealBot_Config.UniqueSpellComboToSpec==1 then
        combo[button..HealBot_Config.CurrentSpec] = spellText
    else
        combo[button] = spellText
    end
    HealBot_setOptions_Timer(70)
    HealBot_Options_SoftReset_flag=true
end

function HealBot_Options_Shift_OnTextChanged(self)
    if HealBot_ActionBarsCombo==1 then
        combo = HealBot_Config.EnabledKeyCombo;
    else
        combo = HealBot_Config.DisabledKeyCombo;
    end
    button = HealBot_Options_ComboClass_Button(HealBot_Options_ComboButtons_Button)
    spellText = strtrim(self:GetText())
    if HealBot_Config.UniqueSpellComboToSpec==1 then
        combo["Shift"..button..HealBot_Config.CurrentSpec] = spellText
    else
        combo["Shift"..button] = spellText
    end
    HealBot_setOptions_Timer(70)
    HealBot_Options_SoftReset_flag=true
end

function HealBot_Options_Ctrl_OnTextChanged(self)
    if HealBot_ActionBarsCombo==1 then
        combo = HealBot_Config.EnabledKeyCombo;
    else
        combo = HealBot_Config.DisabledKeyCombo;
    end
    button = HealBot_Options_ComboClass_Button(HealBot_Options_ComboButtons_Button)
    spellText = strtrim(self:GetText())
    if HealBot_Config.UniqueSpellComboToSpec==1 then
        combo["Ctrl"..button..HealBot_Config.CurrentSpec] = spellText
    else
        combo["Ctrl"..button] = spellText
    end
    HealBot_setOptions_Timer(70)
    HealBot_Options_SoftReset_flag=true
end

function HealBot_Options_Alt_OnTextChanged(self)
    if HealBot_ActionBarsCombo==1 then
        combo = HealBot_Config.EnabledKeyCombo;
    else
        combo = HealBot_Config.DisabledKeyCombo;
    end
    button = HealBot_Options_ComboClass_Button(HealBot_Options_ComboButtons_Button)
    spellText = strtrim(self:GetText())
    if HealBot_Config.UniqueSpellComboToSpec==1 then
        combo["Alt"..button..HealBot_Config.CurrentSpec] = spellText
    else
        combo["Alt"..button] = spellText
    end
    HealBot_setOptions_Timer(70)
    HealBot_Options_SoftReset_flag=true
end

function HealBot_Options_EnableTargetStatus_OnClick(self)
    HealBot_Config.UseTargetCombatStatus = self:GetChecked() or 0;
end

function HealBot_Options_UseUniqueSpec_OnClick(self)
    HealBot_Config.UniqueSpellComboToSpec = self:GetChecked() or 0;
    HealBot_Options_ComboClass_Text();
end

function HealBot_Options_EnableHealthy_OnClick(self)
    HealBot_Config.EnableHealthy = self:GetChecked() or 0;
    HealBot_Action_ResetUnitStatus();
end

function HealBot_Options_EnableSmartCast_OnClick(self)
    HealBot_Config.SmartCast = self:GetChecked() or 0;
end

function HealBot_Options_SmartCastDisspell_OnClick(self)
    HealBot_Config.SmartCastDebuff = self:GetChecked() or 0;
end

function HealBot_Options_SmartCastBuff_OnClick(self)
    HealBot_Config.SmartCastBuff = self:GetChecked() or 0;
end

function HealBot_Options_SmartCastHeal_OnClick(self)
    HealBot_Config.SmartCastHeal = self:GetChecked() or 0;
end

function HealBot_Options_SmartCastRes_OnClick(self)
    HealBot_Config.SmartCastRes = self:GetChecked() or 0;
end

local HealBot_CombosKeys_List = {"","Shift","Ctrl","Alt"}
local HB_combo_prefix=nil
local SpellTxtE=nil
local SpellTxtD=nil
local SpellTxtB=nil
local HB_button=nil
function HealBot_Options_CheckCombos()  

    id=0;
  
    for j=1,5 do
        if j==1 then 
            HB_button="Left";
        elseif j==2 then 
            HB_button="Right";
        elseif j==3 then 
            HB_button="Middle";
        elseif j==4 then 
            HB_button="Button4";
        elseif j==5 then 
            HB_button="Button5";
        end
    
        for x=1, getn(HealBot_CombosKeys_List), 1 do
            if HealBot_Config.UniqueSpellComboToSpec==1 then
                HB_combo_prefix = HealBot_CombosKeys_List[x]..HB_button..HealBot_Config.CurrentSpec
            else
                HB_combo_prefix = HealBot_CombosKeys_List[x]..HB_button
            end
            SpellTxtE = HealBot_Action_AttribSpellPattern(HB_combo_prefix)
            SpellTxtD = HealBot_Action_AttribDisSpellPattern(HB_combo_prefix)
      
            if SpellTxtE then
                if not HealBot_Spells[SpellTxtE] then
                    if not HealBot_OtherSpells[SpellTxtE] then
                        id = HealBot_GetSpellId(SpellTxtE);
                        if id then
                            HealBot_FindSpellRangeCast(id);
                        end
                    end
                end
            end
            if SpellTxtD then
                if not HealBot_Spells[SpellTxtD] then
                    if not HealBot_OtherSpells[SpellTxtD] then
                        id = HealBot_GetSpellId(SpellTxtD);
                        if id then
                            HealBot_FindSpellRangeCast(id);
                        end
                    end
                end
            end
        end
    end

    BuffTextClass = HealBot_Config.HealBotBuffText
    for k=1,10 do
        if BuffTextClass[HealBot_Options_getDropDownId_bySpec(k)] then
            SpellTxtB = BuffTextClass[HealBot_Options_getDropDownId_bySpec(k)]
            if not HealBot_Spells[SpellTxtB] then
                if not HealBot_OtherSpells[SpellTxtB] then
                    id = HealBot_GetSpellId(SpellTxtB);
                    if id then
                        HealBot_FindSpellRangeCast(id);
                    end
                end
            end
        end
    end    
  
end

--------------------------------------------------------------------------------

StaticPopupDialogs["HEALBOT_OPTIONS_SETDEFAULTS"] = {
    text = HEALBOT_OPTIONS_SETDEFAULTSMSG,
    button1 = HEALBOT_WORDS_YES,
    button2 = HEALBOT_WORDS_NO,
    OnAccept = function()
        HealBot_Options_SetDefaults();
    end,
    timeout = 0,
    whileDead = 1,
    hideOnEscape = 1
};

function HealBot_Options_Defaults_OnClick(self)
    StaticPopup_Show ("HEALBOT_OPTIONS_SETDEFAULTS");
end

function HealBot_Options_Reset_OnClick(self,mode)
    HealBot_SetResetFlag(mode)
end

function HealBot_Options_Info_OnClick(self)
    HealBot_Comms_Info()
end

function HealBot_Options_SetDefaults()
--  HealBot_Config = HealBot_ConfigDefaults;
    if HealBot_Config.CastNotify then HealBot_Options_CastNotify_OnClick(nil,0); end
    table.foreach(HealBot_ConfigDefaults, function (x,val)
        HealBot_Config[x] = val;
    end);
    table.foreach(HealBot_Config_SkinsDefaults, function (key,val)
        if not Healbot_Config_Skins[key] then
            Healbot_Config_Skins[key] = val;
        end
    end);
    HealBot_InitNewChar(HealBot_PlayerClassEN)
    HealBot_Config.CurrentSpec=1
    HealBot_Update_SpellCombos()
    HealBot_Update_BuffsForSpec()
    for x,_ in pairs(HealBot_UnitDebuff) do
        HealBot_UnitDebuff[x]=nil;
    end
    for x,_ in pairs(HealBot_UnitBuff) do
        HealBot_UnitBuff[x]=nil;
    end
    HealBot_Options_Opened=false;
    HealBot_RecalcSpells();
    HealBot_Action_Reset();
    HealBot_ClearAllBuffs()
    HealBot_ClearAllDebuffs()
    ShowUIPanel(HealBot_Action)
    HealBot_Action_SetAllAttribs()
    HideUIPanel(HealBot_Options)
    HealBot_Config.ActionVisible = HealBot_Action:IsVisible();
    DoInitTab1=true
    DoInitTab2=true
    DoInitTab3=true
    DoInitTab4=true
    DoInitTab5=true
    DoInitTab6=true
    DoInitTab7=true
    DoInitTab8=true
    DoInitTab9=true
end

function HealBot_Options_OnLoad(self)

    table.insert(UISpecialFrames,self:GetName());

  -- Tabs
    PanelTemplates_SetNumTabs(self,8);
    self.selectedTab = 1; 
    PanelTemplates_UpdateTabs(self);
    DoInitTab1=true
    DoInitTab2=true
    DoInitTab3=true
    DoInitTab4=true
    DoInitTab5=true
    DoInitTab6=true
    DoInitTab7=true
    DoInitTab8=true
    DoInitTab9=true
end

function HealBot_Options_OnShow(self)
    HealBot_Options_ShowPanel(self, self.selectedTab)
end

function HealBot_Options_Close()
    if HealBot_Options_SoftReset_flag then
        HealBot_Options_SoftReset_flag=false
        HealBot_Action_SetAllAttribs()
    end
end

function HealBot_Options_Init(tabNo)
    if tabNo==1 then
        if DoInitTab1 then
            HealBot_Options_DisableHealBot:SetChecked(HealBot_Config.DisableHealBot)
            HealBot_Options_ShowMinimapButton:SetChecked(HealBot_Config.ButtonShown)
            HealBot_Options_ActionLocked:SetChecked(HealBot_Config.ActionLocked)
            HealBot_Options_AutoShow:SetChecked(HealBot_Config.AutoClose)
            HealBot_Options_PanelSounds:SetChecked(HealBot_Config.PanelSounds)
            HealBot_Options_CastNotify_OnClick(nil,HealBot_Config.CastNotify)
            HealBot_Options_HideOptions:SetChecked(HealBot_Config.HideOptions)
            HealBot_Options_RightButtonOptions:SetChecked(HealBot_Config.RightButtonOptions)
            HealBot_Options_NotifyChan:SetText(HealBot_Config.NotifyChan)
            HealBot_Options_NotifyHealMsg:SetText(HealBot_Config.NotifyHealMsg)
            HealBot_Options_NotifyOtherMsg:SetText(HealBot_Config.NotifyOtherMsg)      
            HealBot_Options_CastNotifyResOnly:SetChecked(HealBot_Config.CastNotifyResOnly)
            HealBot_Options_PartyFrames:SetChecked(HealBot_Config.HidePartyFrames)
            HealBot_Options_EnableLibQuickHealth:SetChecked(HealBot_Config.EnLibQuickHealth)
            HealBot_Options_PlayerTargetFrames:SetChecked(HealBot_Config.HidePlayerTarget)
            HealBot_Options_ActionAnchor_Refresh()
            HealBot_Options_UseHBinHeals_Refresh()
            DoInitTab1=nil
        end
        CPUProfiler=GetCVar("scriptProfile")
        HealBot_Options_CPUProfiler:SetChecked(CPUProfiler)
    elseif tabNo==2 and DoInitTab2 then
        HealBot_Options_ProtectPvP:SetChecked(HealBot_Config.ProtectPvP)
        HealBot_Options_EnableSmartCast:SetChecked(HealBot_Config.SmartCast)
        HealBot_Options_SmartCastDisspell:SetChecked(HealBot_Config.SmartCastDebuff)
        HealBot_Options_SmartCastBuff:SetChecked(HealBot_Config.SmartCastBuff)
        HealBot_Options_SmartCastHeal:SetChecked(HealBot_Config.SmartCastHeal)
        HealBot_Options_SmartCastRes:SetChecked(HealBot_Config.SmartCastRes)
        HealBot_Options_EnableHealthy:SetChecked(HealBot_Config.EnableHealthy)
        HealBot_Options_ActionBarsCombo_Refresh()
        HealBot_ComboButtons_Button_OnClick(nil,HealBot_Options_ComboButtons_Button)
        HealBot_Options_EnableTargetStatus:SetChecked(HealBot_Config.UseTargetCombatStatus)
        HealBot_Options_UseUniqueSpec:SetChecked(HealBot_Config.UniqueSpellComboToSpec)
        DoInitTab2=nil
    elseif tabNo==3 and DoInitTab3 then
        HealBot_Options_SelfHeals:SetChecked(HealBot_Config.SelfHeals)
        HealBot_Options_PetHeals:SetChecked(HealBot_Config.PetHeals)
        HealBot_Options_GroupHeals:SetChecked(HealBot_Config.GroupHeals)
        HealBot_Options_TankHeals:SetChecked(HealBot_Config.TankHeals)
        HealBot_Options_SelfPet:SetChecked(HealBot_Config.SelfPet)
        HealBot_Options_EmergencyHeals:SetChecked(HealBot_Config.EmergencyHeals)
        HealBot_Options_FocusBar:SetChecked(HealBot_Config.SetFocusBar)
        HealBot_Options_VehicleHeals:SetChecked(HealBot_Config.VehicleHeals)
        HealBot_Options_MyTargetsList:SetChecked(HealBot_Config.ShowMyTargetsList)
        HealBot_Options_TargetBar:SetChecked(HealBot_Config.TargetHeals)
        HealBot_Options_TargetIncSelf:SetChecked(HealBot_Config.TargetIncSelf)
        HealBot_Options_TargetIncGroup:SetChecked(HealBot_Config.TargetIncGroup)
        HealBot_Options_TargetIncRaid:SetChecked(HealBot_Config.TargetIncRaid)
        HealBot_Options_TargetIncPet:SetChecked(HealBot_Config.TargetIncPet)
        HealBot_Options_TargetMode:SetChecked(HealBot_Config.TargetBarNormalMode)
        HealBot_Options_AlertLevel:SetValue(HealBot_Config.AlertLevel)
        HealBot_Options_RangeCheckFreq:SetValue((HealBot_Config.RangeCheckFreq or 0.2)*10)
        HealBot_Options_VisibleRange:SetChecked(HealBot_Config.NotVisibleDisable)
        HealBot_Options_EmergencyFilter_Refresh()
        HealBot_Options_EmergencyFClass_Refresh()
        HealBot_Options_EFClass_Reset()
        HealBot_Options_ExtraSort_Refresh()
        HealBot_Options_SetEFGroups()
        DoInitTab3=nil
    elseif tabNo==4 and DoInitTab4 then
        HealBot_Options_UpdateMedia(tabNo)
        HealBot_Options_SoundDebuffWarning:SetChecked(HealBot_Config.SoundDebuffWarning)
        HealBot_Options_MonitorDebuffs:SetChecked(HealBot_Config.DebuffWatch)
        HealBot_Options_IgnoreDebuffsClass:SetChecked(HealBot_Config.IgnoreClassDebuffs)
        HealBot_Options_IgnoreDebuffsNoHarm:SetChecked(HealBot_Config.IgnoreNonHarmfulDebuffs)
        HealBot_Options_IgnoreDebuffsDuration:SetChecked(HealBot_Config.IgnoreFastDurDebuffs)
        HealBot_Options_IgnoreDebuffsDurationSecs:SetValue(HealBot_Config.IgnoreFastDurDebuffsSecs)
        HealBot_Options_IgnoreDebuffsMovement:SetChecked(HealBot_Config.IgnoreMovementDebuffs)
        HealBot_Options_WarningSound:SetValue(soundsIndex[HealBot_Config.SoundDebuffPlay] or 0);    
        HealBot_Options_MonitorDebuffsInCombat:SetChecked(HealBot_Config.DebuffWatchInCombat)
        HealBot_Options_CDCTxt1_Refresh()
        HealBot_Options_CDCTxt2_Refresh()
        HealBot_Options_CDCTxt3_Refresh()
        HealBot_Options_CDCGroups1_Refresh()
        HealBot_Options_CDCGroups2_Refresh()
        HealBot_Options_CDCGroups3_Refresh()
        HealBot_Options_ShowDebuffWarning:SetChecked(HealBot_Config.ShowDebuffWarning)
        HealBot_SetCDCBarColours()
        HealBot_Options_CDCCol_ShowOnHealthBar:SetChecked(HealBot_Config.CDCshownHB)
        HealBot_Options_CDCCol_ShowOnAggroBar:SetChecked(HealBot_Config.CDCshownAB)
        DoInitTab4=nil
    elseif tabNo==5 and DoInitTab5 then
        HealBot_Options_UpdateMedia(tabNo)
        HealBot_Options_NewSkinb:Disable()
        HealBot_Options_Skins_Refresh()
        DoInitTab5=nil
    elseif tabNo==6 and DoInitTab6 then
        HealBot_Options_UpdateMedia(tabNo)
        HealBot_Options_Skins2_Refresh()
        DoInitTab6=nil
    elseif tabNo==7 and DoInitTab7 then
        HealBot_Options_ShowTooltip:SetChecked(HealBot_Config.ShowTooltip)
        HealBot_Options_ShowTooltipUpdate:SetChecked(HealBot_Config.TooltipUpdate)
        HealBot_Options_HideTooltipInCombat:SetChecked(HealBot_Config.DisableToolTipInCombat)
        HealBot_Options_ShowTooltipTarget:SetChecked(HealBot_Config.Tooltip_ShowTarget)
        HealBot_Options_ShowTooltipMyBuffs:SetChecked(HealBot_Config.Tooltip_ShowMyBuffs)
        HealBot_Options_ShowTooltipSpellDetail:SetChecked(HealBot_Config.Tooltip_ShowSpellDetail)
        HealBot_Options_ShowTooltipInstant:SetChecked(HealBot_Config.Tooltip_Recommend)
        HealBot_Options_ShowTooltipPreDefined:SetChecked(HealBot_Config.Tooltip_PreDefined)
        HealBot_Options_ShowIncomingHeals:SetChecked(HealBot_Config.ShowIncHeals)
        HealBot_Options_TooltipPos_Refresh()
        HealBot_Options_TTAlpha:SetValue(HealBot_Config.ttalpha)
        HealBot_Options_ShowIncomingHeals:SetChecked(HealBot_Config.ShowIncHeals)
        HealBot_Options_incHealsDirectDur:SetValue(HealBot_Config.incHealDur["D"])
        HealBot_Options_incHealsHoTDur:SetValue(HealBot_Config.incHealDur["H"])
        HealBot_Options_incHealsChanDur:SetValue(HealBot_Config.incHealDur["C"])
        DoInitTab7=nil
    elseif tabNo==8 and DoInitTab8 then
        HealBot_Options_MonitorBuffs:SetChecked(HealBot_Config.BuffWatch)
        HealBot_Options_MonitorBuffsInCombat:SetChecked(HealBot_Config.BuffWatchInCombat)
        HealBot_Options_BuffTxt1_Refresh()
        HealBot_Options_BuffTxt2_Refresh()
        HealBot_Options_BuffTxt3_Refresh()
        HealBot_Options_BuffTxt4_Refresh()
        HealBot_Options_BuffTxt5_Refresh()
        HealBot_Options_BuffTxt6_Refresh()
        HealBot_Options_BuffTxt7_Refresh()
        HealBot_Options_BuffTxt8_Refresh()
        HealBot_Options_BuffTxt9_Refresh()
        HealBot_Options_BuffTxt10_Refresh()
        HealBot_Options_BuffGroups1_Refresh()
        HealBot_Options_BuffGroups2_Refresh()
        HealBot_Options_BuffGroups3_Refresh()
        HealBot_Options_BuffGroups4_Refresh()
        HealBot_Options_BuffGroups5_Refresh()
        HealBot_Options_BuffGroups6_Refresh()
        HealBot_Options_BuffGroups7_Refresh()
        HealBot_Options_BuffGroups8_Refresh()
        HealBot_Options_BuffGroups9_Refresh()
        HealBot_Options_BuffGroups10_Refresh()
        HealBot_Options_ShortBuffTimer:SetValue(HealBot_Config.ShortBuffTimer)
        HealBot_Options_LongBuffTimer:SetValue(HealBot_Config.LongBuffTimer)
        DoInitTab8=nil
    elseif tabNo==9 and DoInitTab9 then
        HealBot_Options_DisableHealBot:SetChecked(HealBot_Config.DisableHealBot)
        HealBot_Options_EnableSmartCast:SetChecked(HealBot_Config.SmartCast)
        HealBot_Options_MonitorDebuffs:SetChecked(HealBot_Config.DebuffWatch)
        HealBot_Options_MonitorBuffs:SetChecked(HealBot_Config.BuffWatch)
        DoInitTab9=nil
        LSM.RegisterCallback("HealBot", "LibSharedMedia_Registered", function(event, mediatype, key) HealBot_UpdateUsedMedia(event, mediatype, key) end)  
        LSM.RegisterCallback("HealBot", "LibSharedMedia_SetGlobal", function(event, mediatype, key) HealBot_UpdateUsedMedia(event, mediatype, key) end) 
    end
    if not HealBot_Options_Opened then
        HealBot_setOptions_Timer(100)
        HealBot_Options_Opened=true
        if HealBot_Config.SoundDebuffWarning>0 then
            HealBot_Options_WarningSound:Enable();
            HealBot_Options_PlaySound:Enable();
        else
            HealBot_Options_WarningSound:Disable();
            HealBot_Options_PlaySound:Disable();
        end
        if Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Current_Skin]==0 then
            HealBot_BarHealthType1:Disable();
            HealBot_BarHealthType2:Disable();
            HealBot_BarHealthIncHeal:Disable();
            HealBot_BarHealthSepHeal:Disable();
        else
            HealBot_BarHealthType1:Enable();
            HealBot_BarHealthType2:Enable();
            HealBot_BarHealthIncHeal:Enable();
            HealBot_BarHealthSepHeal:Enable();
        end
        if Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin]==0 then
            HealBot_Options_ShowClassOnBarType1:Disable();
            HealBot_Options_ShowClassOnBarType2:Disable();
        else
            HealBot_Options_ShowClassOnBarType1:Enable();
            HealBot_Options_ShowClassOnBarType2:Enable();
        end
        if Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Current_Skin]>0 then
            HealBot_Options_BarClassCustomColour1:Enable();
            HealBot_Options_BarClassCustomColour2:Enable();
        else
            HealBot_Options_BarClassCustomColour1:Disable();
            HealBot_Options_BarClassCustomColour2:Disable();
        end
    end
end

function HealBot_Options_SetEFGroups()
    for x=1,8 do
        if HealBot_Config.ExtraIncGroup[x] then 
            getglobal("HealBot_Options_EFGroup"..x):SetChecked(1)
        else
            getglobal("HealBot_Options_EFGroup"..x):SetChecked(nil)
        end
    end
end

function HealBot_Options_SetSkins()
    HealBot_Options_BarAlpha:SetValue(Healbot_Config_Skins.Barcola[Healbot_Config_Skins.Current_Skin] or 95);
    HealBot_Options_BarAlphaInHeal:SetValue(Healbot_Config_Skins.BarcolaInHeal[Healbot_Config_Skins.Current_Skin] or 35);
    HealBot_Options_BarTextureS:SetValue(texturesIndex[Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin]] or 0)
    HealBot_Options_BarHeightS:SetValue(Healbot_Config_Skins.bheight[Healbot_Config_Skins.Current_Skin] or 22)
    HealBot_Options_BarWidthS:SetValue(Healbot_Config_Skins.bwidth[Healbot_Config_Skins.Current_Skin] or 95)
    HealBot_Options_BarNumColsS:SetValue(Healbot_Config_Skins.numcols[Healbot_Config_Skins.Current_Skin] or 2)
    HealBot_Options_BarBRSpaceS:SetValue(Healbot_Config_Skins.brspace[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_BarBCSpaceS:SetValue(Healbot_Config_Skins.bcspace[Healbot_Config_Skins.Current_Skin] or 4)
    HealBot_Options_FontName:SetValue(fontsIndex[Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]] or 0)
    HealBot_Options_FontHeight:SetValue(Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Current_Skin] or 10)
    HealBot_Options_BarAlphaDis:SetValue(Healbot_Config_Skins.bardisa[Healbot_Config_Skins.Current_Skin] or 4)
    HealBot_Options_BarAlphaEor:SetValue(Healbot_Config_Skins.bareora[Healbot_Config_Skins.Current_Skin] or 32)
    HealBot_Options_Bar2Size:SetValue(Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin] or 0)
    HealBot_Options_HeadTextureS:SetValue(texturesIndex[Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Current_Skin]] or 0)
    HealBot_Options_HeadWidthS:SetValue(Healbot_Config_Skins.headwidth[Healbot_Config_Skins.Current_Skin] or 85)
    HealBot_Options_HeadFontNameS:SetValue(fontsIndex[Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]] or 0)
    HealBot_Options_HeadFontHeightS:SetValue(Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin] or 10)  
    HealBot_Options_ShowHeaders:SetChecked(Healbot_Config_Skins.ShowHeader[Healbot_Config_Skins.Current_Skin] or 0)
    HealBot_Options_AggroTrack:SetChecked(Healbot_Config_Skins.ShowAggro[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_AggroBar:SetChecked(Healbot_Config_Skins.ShowAggroBars[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_AggroTxt:SetChecked(Healbot_Config_Skins.ShowAggroText[Healbot_Config_Skins.Current_Skin] or 0)
    HealBot_Options_UseFluidBars:SetChecked(Healbot_Config_Skins.UseFluidBars[Healbot_Config_Skins.Current_Skin] or 0)
    HealBot_Options_BarUpdateFreq:SetValue((Healbot_Config_Skins.BarFreq[Healbot_Config_Skins.Current_Skin] or 2)*10)
    HealBot_Options_BarButtonShowHoT:SetChecked(Healbot_Config_Skins.ShowHoTicons[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_BarButtonShowRaidIcon:SetChecked(Healbot_Config_Skins.ShowRaidIcon[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_HoTonBar_OnClick(nil,Healbot_Config_Skins.HoTonBar[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_HoTposBar_OnClick(nil,Healbot_Config_Skins.HoTposBar[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_ShowClassOnBarType_OnClick(nil,Healbot_Config_Skins.ShowClassType[Healbot_Config_Skins.Current_Skin] or 2)
    HealBot_Options_ShowClassOnBar:SetChecked(Healbot_Config_Skins.ShowClassOnBar[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_BarInClassColour:SetChecked(Healbot_Config_Skins.SetBarClassColour[Healbot_Config_Skins.Current_Skin] or 0)
    HealBot_Options_ShowNameOnBar:SetChecked(Healbot_Config_Skins.ShowNameOnBar[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_ShowHealthOnBar:SetChecked(Healbot_Config_Skins.ShowHealthOnBar[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_BarHealthIncHeal:SetChecked(Healbot_Config_Skins.BarHealthIncHeals[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_BarHealthSepHeal:SetChecked(Healbot_Config_Skins.BarHealthSepHeals[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_BarHealthType_OnClick(nil,Healbot_Config_Skins.BarHealthType[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_BarClassCustom_OnClick(nil,Healbot_Config_Skins.SetBarCustomColour[Healbot_Config_Skins.Current_Skin] or 2)
    HealBot_Options_BarTextInClassColour:SetChecked(Healbot_Config_Skins.SetClassColourText[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_Options_ShowDebuffIcon:SetChecked(Healbot_Config_Skins.ShowDebuffIcon[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_BarButtonShowHoTTextCount:SetChecked(Healbot_Config_Skins.ShowIconTextCount[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_BarButtonShowHoTTextDuration:SetChecked(Healbot_Config_Skins.ShowIconTextDuration[Healbot_Config_Skins.Current_Skin] or 1)
    HealBot_BarButtonIconScale:SetValue((Healbot_Config_Skins.IconScale[Healbot_Config_Skins.Current_Skin] or 7.5)*10)
    HealBot_BarButtonIconTextScale:SetValue((Healbot_Config_Skins.IconTextScale[Healbot_Config_Skins.Current_Skin] or 7.5)*10)
    HealBot_Options_AggroBarSize:SetValue(Healbot_Config_Skins.AggroBarSize[Healbot_Config_Skins.Current_Skin] or 2)
    HealBot_Options_NumberTextLines:SetChecked(Healbot_Config_Skins.DoubleText[Healbot_Config_Skins.Current_Skin] or 0)
    HealBot_Options_TextAlign:SetValue(Healbot_Config_Skins.TextAlignment[Healbot_Config_Skins.Current_Skin] or 2)
    HealBot_setOptions_Timer(90)
    if Healbot_Config_Skins.Current_Skin==HEALBOT_SKINS_STD then
        HealBot_Options_DeleteSkin:Disable();
    else
        HealBot_Options_DeleteSkin:Enable();
    end
    if (Healbot_Config_Skins.bar2size[Healbot_Config_Skins.Current_Skin] or 0)==0 then
        HealBot_UnRegister_Mana()
    else
        HealBot_Register_Mana()
    end
    HealBot_Config.Current_Skin = Healbot_Config_Skins.Current_Skin
    HealBot_Config.Skin_ID = Healbot_Config_Skins.Skin_ID
end

local HealBot_Options_CurrentPanel = 0;

function HealBot_Options_ShowPanel(self, tabNo)
    if HealBot_Options_CurrentPanel>0 then
        getglobal("HealBot_Options_Panel"..HealBot_Options_CurrentPanel):Hide();
    end
    HealBot_Options_CurrentPanel = tabNo;
    if HealBot_Options_CurrentPanel>0 then
        getglobal("HealBot_Options_Panel"..HealBot_Options_CurrentPanel):Show();
        getglobal("HealBot_OptionsTab"..HealBot_Options_CurrentPanel):Show();
        HealBot_Options_Init(HealBot_Options_CurrentPanel)
    end
end

function HealBot_Options_OnMouseDown(self)
    HealBot_StartMoving(self);
end

function HealBot_Options_OnMouseUp(self)
    HealBot_StopMoving(self);
end

function HealBot_Options_OnDragStart(self)
    HealBot_StartMoving(self);
end

function HealBot_Options_OnDragStop(self)
    HealBot_StopMoving(self);
end

function HealBot_Options_DisablePlayerFrame()
    PlayerFrame:UnregisterAllEvents()
    PlayerFrameHealthBar:UnregisterAllEvents()
    PlayerFrameManaBar:UnregisterAllEvents()
    PlayerFrame:Hide()
end

function HealBot_Options_EnablePlayerFrame()
    PlayerFrame:RegisterAllEvents()
    PlayerFrameHealthBar:RegisterAllEvents()
    PlayerFrameManaBar:RegisterAllEvents()
    PlayerFrame:Show();
end

function HealBot_Options_DisablePetFrame()
    PetFrame:UnregisterAllEvents()
    PetFrame:Hide()
end

function HealBot_Options_EnablePetFrame()
    PetFrame:RegisterAllEvents()
    PetFrame:Show();
end

local f=nil
function HealBot_Options_DisablePartyFrame()
    HIDE_PARTY_INTERFACE = "1"
    hooksecurefunc("ShowPartyFrame", function()
        if (not InCombatLockdown()) then
            for x = 1,4 do
                getglobal("PartyMemberFrame"..x):Hide()
            end
        end
    end)
    for x = 1, 4 do
        f = getglobal("PartyMemberFrame"..x)
        f:Hide()
        f:UnregisterAllEvents()
        getglobal("PartyMemberFrame"..x.."HealthBar"):UnregisterAllEvents()
        getglobal("PartyMemberFrame"..x.."ManaBar"):UnregisterAllEvents()
    end
end

function HealBot_Options_EnablePartyFrame()
    HIDE_PARTY_INTERFACE = "0"
    hooksecurefunc("ShowPartyFrame", function()
        if (not InCombatLockdown()) then
            for x = 1,4 do
                getglobal("PartyMemberFrame"..x):Show()
            end
        end
    end)
    for x = 1, 4 do
        f = getglobal("PartyMemberFrame"..x)
        if GetPartyMember(x) then
            f:Show()
        end
        f:RegisterAllEvents()
        getglobal("PartyMemberFrame"..x.."HealthBar"):RegisterAllEvents()
        getglobal("PartyMemberFrame"..x.."ManaBar"):RegisterAllEvents()
    end
end

function HealBot_Options_DisableTargetFrame()
    TargetFrame:UnregisterAllEvents()
    TargetFrameHealthBar:UnregisterAllEvents()
    TargetFrameManaBar:UnregisterAllEvents()
    TargetFrame:Hide()
    TargetofTargetFrame:UnregisterAllEvents()
    TargetofTargetFrame:Hide()
end

function HealBot_Options_EnableTargetFrame()
    TargetFrame:RegisterAllEvents()
    TargetFrameHealthBar:RegisterAllEvents()
    TargetFrameManaBar:RegisterAllEvents()
    TargetofTargetFrame:RegisterAllEvents()
end

function HealBot_Options_SetSliderValue(slider,value,updating)
    updatingMedia = updating
    slider:SetValue(-1) -- Pre change value so that text gets updated if value does not change but media does
    updatingMedia = updating
    slider:SetValue(value or 0)
end

function HealBot_Options_UpdateMedia(panel)
    HealBot_AddDebug("Update Media Called")
    if panel == 5 or panel == 6 then
        textures = LSM:List('statusbar');
        for x,_ in pairs(texturesIndex) do
            texturesIndex[x]=nil
        end 
        for i=1,#textures do
            texturesIndex[textures[i]] = i
        end
        fonts = LSM:List('font');
        for x,_ in pairs(fontsIndex) do
            fontsIndex[x]=nil
        end 
        for i=1,#fonts do
            fontsIndex[fonts[i]] = i
        end
        if panel == 5 then
            HealBot_Options_val_OnLoad(HealBot_Options_HeadTextureS,HEALBOT_OPTIONS_SKINTEXTURE,1,#textures)
            HealBot_Options_val_OnLoad(HealBot_Options_HeadFontNameS,HEALBOT_OPTIONS_SKINFONT,1,#fonts)
            HealBot_Options_SetSliderValue(HealBot_Options_HeadTextureS,texturesIndex[Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Current_Skin]],true)
            HealBot_Options_SetSliderValue(HealBot_Options_HeadFontNameS,fontsIndex[Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]],true)
        end
        if panel == 6 then
            HealBot_Options_val_OnLoad(HealBot_Options_BarTextureS,HEALBOT_OPTIONS_SKINTEXTURE,1,#textures)
            HealBot_Options_val_OnLoad(HealBot_Options_FontName,HEALBOT_OPTIONS_SKINFONT,1,#fonts)
            HealBot_Options_SetSliderValue(HealBot_Options_BarTextureS,texturesIndex[Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin]],true)
            HealBot_Options_SetSliderValue(HealBot_Options_FontName,fontsIndex[Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]],true)
        end
    end
    if panel == 4 and DoInitTab4 then
        sounds = LSM:List('sound');
        for x,_ in pairs(soundsIndex) do
            soundsIndex[x]=nil
        end 
        for i=1,#sounds do
            soundsIndex[sounds[i]] = i
        end
        HealBot_Options_val_OnLoad(HealBot_Options_WarningSound,HEALBOT_OPTIONS_SOUND,1,#sounds)
        HealBot_Options_SetSliderValue(HealBot_Options_WarningSound,soundsIndex[HealBot_Config.SoundDebuffPlay],true)
    end
end

function HealBot_UpdateUsedMedia(event, mediatype, key)
    if mediatype == "statusbar" then
        if Healbot_Config_Skins.headtexture and key == Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Current_Skin] then 
            for x=1,15 do
                h=getglobal("HealBot_Action_Header"..x);
                bar = HealBot_Action_HealthBar(h);
                bar:SetStatusBarTexture(LSM:Fetch('statusbar',Healbot_Config_Skins.headtexture[Healbot_Config_Skins.Current_Skin]));
                bar.txt = getglobal(bar:GetName().."_text");
                bar.txt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]),Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin],"");
            end
        end
        if Healbot_Config_Skins.btexture and key == Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin] then 
            for x=1,51 do
                b=getglobal("HealBot_Action_HealUnit"..x);
                bar = HealBot_Action_HealthBar(b);
                bar2 = HealBot_Action_HealthBar2(b);
                bar3 = HealBot_Action_HealthBar3(b);
                bar:SetStatusBarTexture(LSM:Fetch('statusbar',Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin]));
                bar2:SetStatusBarTexture(LSM:Fetch('statusbar',Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin]));
                bar3:SetStatusBarTexture(LSM:Fetch('statusbar',Healbot_Config_Skins.btexture[Healbot_Config_Skins.Current_Skin]));
            end            
        end
    elseif mediatype == "font" then
        if Healbot_Config_Skins.headtextfont and key == Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin] then
            for x=1,15 do
                h=getglobal("HealBot_Action_Header"..x);
                bar = HealBot_Action_HealthBar(h);
                bar.txt = getglobal(bar:GetName().."_text");
                bar.txt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.headtextfont[Healbot_Config_Skins.Current_Skin]),Healbot_Config_Skins.headtextheight[Healbot_Config_Skins.Current_Skin],"");
            end
        end
        if Healbot_Config_Skins.btextfont and key == Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin] then
            for x=1,51 do
                b=getglobal("HealBot_Action_HealUnit"..x);
                bar = HealBot_Action_HealthBar(b);
                bar.txt = getglobal(bar:GetName().."_text");
                bar.txt:SetFont(LSM:Fetch('font',Healbot_Config_Skins.btextfont[Healbot_Config_Skins.Current_Skin]),Healbot_Config_Skins.btextheight[Healbot_Config_Skins.Current_Skin],"");
            end        
        end
    --elseif mediatype == "background" then
    --elseif mediatype == "border" then
    elseif mediatype == "sound" then
        if key == HealBot_Config.SoundDebuffPlay then
        -- Do nothing
        end
    end
end
