Quantcast

Added Tooltip interactions for social and guild

Mikeprod [10-29-16 - 21:01]
Added Tooltip interactions for social and guild
Filename
Libs/LibQTip-1.0/Changelog-LibQTip-1.0-r178-release.txt
Libs/LibQTip-1.0/LICENSE.txt
Libs/LibQTip-1.0/LibQTip-1.0.lua
Libs/LibQTip-1.0/LibQTip-1.0.toc
Libs/LibQTip-1.0/LibStub/LibStub.lua
Libs/LibQTip-1.0/LibStub/LibStub.toc
Libs/LibQTip-1.0/LibStub/tests/test.lua
Libs/LibQTip-1.0/LibStub/tests/test2.lua
Libs/LibQTip-1.0/LibStub/tests/test3.lua
Libs/LibQTip-1.0/LibStub/tests/test4.lua
Libs/LibQTip-1.0/lib.xml
embeds.xml
modules/micromenu.lua
diff --git a/Libs/LibQTip-1.0/Changelog-LibQTip-1.0-r178-release.txt b/Libs/LibQTip-1.0/Changelog-LibQTip-1.0-r178-release.txt
new file mode 100644
index 0000000..7bee041
--- /dev/null
+++ b/Libs/LibQTip-1.0/Changelog-LibQTip-1.0-r178-release.txt
@@ -0,0 +1,13 @@
+------------------------------------------------------------------------
+r178 | torhal | 2016-07-19 07:09:42 +0000 (Tue, 19 Jul 2016) | 1 line
+Changed paths:
+   A /tags/r178-release (from /trunk:177)
+
+Tagging as r178-release
+------------------------------------------------------------------------
+r177 | torhal | 2016-07-19 07:09:09 +0000 (Tue, 19 Jul 2016) | 1 line
+Changed paths:
+   M /trunk/LibQTip-1.0.toc
+
+Bump ToC Interface to 70000
+------------------------------------------------------------------------
diff --git a/Libs/LibQTip-1.0/LICENSE.txt b/Libs/LibQTip-1.0/LICENSE.txt
new file mode 100644
index 0000000..54cdb47
--- /dev/null
+++ b/Libs/LibQTip-1.0/LICENSE.txt
@@ -0,0 +1,29 @@
+Copyright (c) 2008, LibQTip Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Redistribution of a stand alone version is strictly prohibited without
+      prior written authorization from the Lead of the LibQTip Development Team.
+    * Neither the name of the LibQTip Development Team nor the names of its contributors
+      may be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Libs/LibQTip-1.0/LibQTip-1.0.lua b/Libs/LibQTip-1.0/LibQTip-1.0.lua
new file mode 100644
index 0000000..2d68ef1
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibQTip-1.0.lua
@@ -0,0 +1,1420 @@
+local MAJOR = "LibQTip-1.0"
+local MINOR = 44 -- Should be manually increased
+assert(LibStub, MAJOR .. " requires LibStub")
+
+local lib, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
+if not lib then return end -- No upgrade needed
+
+------------------------------------------------------------------------------
+-- Upvalued globals
+------------------------------------------------------------------------------
+local _G = getfenv(0)
+
+local type = type
+local select = select
+local error = error
+local pairs, ipairs = pairs, ipairs
+local tonumber, tostring = tonumber, tostring
+local strfind = string.find
+local math = math
+local next = next
+local min, max = math.min, math.max
+local setmetatable = setmetatable
+local tinsert, tremove = tinsert, tremove
+local wipe = wipe
+
+local CreateFrame = CreateFrame
+local UIParent = UIParent
+
+------------------------------------------------------------------------------
+-- Tables and locals
+------------------------------------------------------------------------------
+lib.frameMetatable = lib.frameMetatable or { __index = CreateFrame("Frame") }
+
+lib.tipPrototype = lib.tipPrototype or setmetatable({}, lib.frameMetatable)
+lib.tipMetatable = lib.tipMetatable or { __index = lib.tipPrototype }
+
+lib.providerPrototype = lib.providerPrototype or {}
+lib.providerMetatable = lib.providerMetatable or { __index = lib.providerPrototype }
+
+lib.cellPrototype = lib.cellPrototype or setmetatable({}, lib.frameMetatable)
+lib.cellMetatable = lib.cellMetatable or { __index = lib.cellPrototype }
+
+lib.activeTooltips = lib.activeTooltips or {}
+
+lib.tooltipHeap = lib.tooltipHeap or {}
+lib.frameHeap = lib.frameHeap or {}
+lib.tableHeap = lib.tableHeap or {}
+
+lib.onReleaseHandlers = lib.onReleaseHandlers or {}
+
+local tipPrototype = lib.tipPrototype
+local tipMetatable = lib.tipMetatable
+
+local providerPrototype = lib.providerPrototype
+local providerMetatable = lib.providerMetatable
+
+local cellPrototype = lib.cellPrototype
+local cellMetatable = lib.cellMetatable
+
+local activeTooltips = lib.activeTooltips
+
+local highlightFrame = CreateFrame("Frame", nil, UIParent)
+highlightFrame:SetFrameStrata("TOOLTIP")
+highlightFrame:Hide()
+
+local DEFAULT_HIGHLIGHT_TEXTURE_PATH = [[Interface\QuestFrame\UI-QuestTitleHighlight]]
+
+local highlightTexture = highlightFrame:CreateTexture(nil, "OVERLAY")
+highlightTexture:SetTexture(DEFAULT_HIGHLIGHT_TEXTURE_PATH)
+highlightTexture:SetBlendMode("ADD")
+highlightTexture:SetAllPoints(highlightFrame)
+
+------------------------------------------------------------------------------
+-- Private methods for Caches and Tooltip
+------------------------------------------------------------------------------
+local AcquireTooltip, ReleaseTooltip
+local AcquireCell, ReleaseCell
+local AcquireTable, ReleaseTable
+
+local InitializeTooltip, SetTooltipSize, ResetTooltipSize, FixCellSizes
+local ClearTooltipScripts
+local SetFrameScript, ClearFrameScripts
+
+------------------------------------------------------------------------------
+-- Cache debugging.
+------------------------------------------------------------------------------
+-- @debug @
+local usedTables, usedFrames, usedTooltips = 0, 0, 0
+--@end-debug@
+
+------------------------------------------------------------------------------
+-- Internal constants to tweak the layout
+------------------------------------------------------------------------------
+local TOOLTIP_PADDING = 10
+local CELL_MARGIN_H = 6
+local CELL_MARGIN_V = 3
+
+------------------------------------------------------------------------------
+-- Public library API
+------------------------------------------------------------------------------
+--- Create or retrieve the tooltip with the given key.
+-- If additional arguments are passed, they are passed to :SetColumnLayout for the acquired tooltip.
+-- @name LibQTip:Acquire(key[, numColumns, column1Justification, column2justification, ...])
+-- @param key string or table - the tooltip key. Any value that can be used as a table key is accepted though you should try to provide unique keys to avoid conflicts.
+-- Numbers and booleans should be avoided and strings should be carefully chosen to avoid namespace clashes - no "MyTooltip" - you have been warned!
+-- @return tooltip Frame object - the acquired tooltip.
+-- @usage Acquire a tooltip with at least 5 columns, justification : left, center, left, left, left
+-- <pre>local tip = LibStub('LibQTip-1.0'):Acquire('MyFooBarTooltip', 5, "LEFT", "CENTER")</pre>
+function lib:Acquire(key, ...)
+	if key == nil then
+		error("attempt to use a nil key", 2)
+	end
+	local tooltip = activeTooltips[key]
+
+	if not tooltip then
+		tooltip = AcquireTooltip()
+		InitializeTooltip(tooltip, key)
+		activeTooltips[key] = tooltip
+	end
+
+	if select('#', ...) > 0 then
+		-- Here we catch any error to properly report it for the calling code
+		local ok, msg = pcall(tooltip.SetColumnLayout, tooltip, ...)
+
+		if not ok then
+			error(msg, 2)
+		end
+	end
+	return tooltip
+end
+
+function lib:Release(tooltip)
+	local key = tooltip and tooltip.key
+
+	if not key or activeTooltips[key] ~= tooltip then
+		return
+	end
+	ReleaseTooltip(tooltip)
+	activeTooltips[key] = nil
+end
+
+function lib:IsAcquired(key)
+	if key == nil then
+		error("attempt to use a nil key", 2)
+	end
+	return not not activeTooltips[key]
+end
+
+function lib:IterateTooltips()
+	return pairs(activeTooltips)
+end
+
+------------------------------------------------------------------------------
+-- Frame cache
+------------------------------------------------------------------------------
+local frameHeap = lib.frameHeap
+
+local function AcquireFrame(parent)
+	local frame = tremove(frameHeap) or CreateFrame("Frame")
+	frame:SetParent(parent)
+	--[===[@debug@
+	usedFrames = usedFrames + 1
+	--@end-debug@]===]
+	return frame
+end
+
+local function ReleaseFrame(frame)
+	frame:Hide()
+	frame:SetParent(nil)
+	frame:ClearAllPoints()
+	frame:SetBackdrop(nil)
+	ClearFrameScripts(frame)
+	tinsert(frameHeap, frame)
+	--[===[@debug@
+	usedFrames = usedFrames - 1
+	--@end-debug@]===]
+end
+
+------------------------------------------------------------------------------
+-- Dirty layout handler
+------------------------------------------------------------------------------
+lib.layoutCleaner = lib.layoutCleaner or CreateFrame('Frame')
+
+local layoutCleaner = lib.layoutCleaner
+layoutCleaner.registry = layoutCleaner.registry or {}
+
+function layoutCleaner:RegisterForCleanup(tooltip)
+	self.registry[tooltip] = true
+	self:Show()
+end
+
+function layoutCleaner:CleanupLayouts()
+	self:Hide()
+	for tooltip in pairs(self.registry) do
+		FixCellSizes(tooltip)
+	end
+	wipe(self.registry)
+end
+
+layoutCleaner:SetScript('OnUpdate', layoutCleaner.CleanupLayouts)
+
+------------------------------------------------------------------------------
+-- CellProvider and Cell
+------------------------------------------------------------------------------
+function providerPrototype:AcquireCell()
+	local cell = tremove(self.heap)
+	if not cell then
+		cell = setmetatable(CreateFrame("Frame", nil, UIParent), self.cellMetatable)
+		if type(cell.InitializeCell) == 'function' then
+			cell:InitializeCell()
+		end
+	end
+	self.cells[cell] = true
+	return cell
+end
+
+function providerPrototype:ReleaseCell(cell)
+	if not self.cells[cell] then return end
+	if type(cell.ReleaseCell) == 'function' then
+		cell:ReleaseCell()
+	end
+	self.cells[cell] = nil
+	tinsert(self.heap, cell)
+end
+
+function providerPrototype:GetCellPrototype()
+	return self.cellPrototype, self.cellMetatable
+end
+
+function providerPrototype:IterateCells()
+	return pairs(self.cells)
+end
+
+function lib:CreateCellProvider(baseProvider)
+	local cellBaseMetatable, cellBasePrototype
+	if baseProvider and baseProvider.GetCellPrototype then
+		cellBasePrototype, cellBaseMetatable = baseProvider:GetCellPrototype()
+	else
+		cellBaseMetatable = cellMetatable
+	end
+	local cellPrototype = setmetatable({}, cellBaseMetatable)
+	local cellProvider = setmetatable({}, providerMetatable)
+	cellProvider.heap = {}
+	cellProvider.cells = {}
+	cellProvider.cellPrototype = cellPrototype
+	cellProvider.cellMetatable = { __index = cellPrototype }
+	return cellProvider, cellPrototype, cellBasePrototype
+end
+
+------------------------------------------------------------------------------
+-- Basic label provider
+------------------------------------------------------------------------------
+if not lib.LabelProvider then
+	lib.LabelProvider, lib.LabelPrototype = lib:CreateCellProvider()
+end
+
+local labelProvider = lib.LabelProvider
+local labelPrototype = lib.LabelPrototype
+
+function labelPrototype:InitializeCell()
+	self.fontString = self:CreateFontString()
+	self.fontString:SetFontObject(_G.GameTooltipText)
+end
+
+function labelPrototype:SetupCell(tooltip, value, justification, font, l_pad, r_pad, max_width, min_width, ...)
+	local fs = self.fontString
+	local line = tooltip.lines[self._line]
+
+	-- detatch fs from cell for size calculations
+	fs:ClearAllPoints()
+	fs:SetFontObject(font or (line.is_header and tooltip:GetHeaderFont() or tooltip:GetFont()))
+	fs:SetJustifyH(justification)
+	fs:SetText(tostring(value))
+
+	l_pad = l_pad or 0
+	r_pad = r_pad or 0
+
+	local width = fs:GetStringWidth() + l_pad + r_pad
+
+	if max_width and min_width and (max_width < min_width) then
+		error("maximum width cannot be lower than minimum width: " .. tostring(max_width) .. " < " .. tostring(min_width), 2)
+	end
+
+	if max_width and (max_width < (l_pad + r_pad)) then
+		error("maximum width cannot be lower than the sum of paddings: " .. tostring(max_width) .. " < " .. tostring(l_pad) .. " + " .. tostring(r_pad), 2)
+	end
+
+	if min_width and width < min_width then
+		width = min_width
+	end
+
+	if max_width and max_width < width then
+		width = max_width
+	end
+	fs:SetWidth(width - (l_pad + r_pad))
+	-- Use GetHeight() instead of GetStringHeight() so lines which are longer than width will wrap.
+	local height = fs:GetHeight()
+
+	-- reanchor fs to cell
+	fs:SetWidth(0)
+	fs:SetPoint("TOPLEFT", self, "TOPLEFT", l_pad, 0)
+	fs:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -r_pad, 0)
+	--~ 	fs:SetPoint("TOPRIGHT", self, "TOPRIGHT", -r_pad, 0)
+
+	self._paddingL = l_pad
+	self._paddingR = r_pad
+
+	return width, height
+end
+
+function labelPrototype:getContentHeight()
+	local fs = self.fontString
+	fs:SetWidth(self:GetWidth() - (self._paddingL + self._paddingR))
+	local height = self.fontString:GetHeight()
+	fs:SetWidth(0)
+	return height
+end
+
+function labelPrototype:GetPosition() return self._line, self._column end
+
+------------------------------------------------------------------------------
+-- Tooltip cache
+------------------------------------------------------------------------------
+local tooltipHeap = lib.tooltipHeap
+
+-- Returns a tooltip
+function AcquireTooltip()
+	local tooltip = tremove(tooltipHeap)
+
+	if not tooltip then
+		tooltip = CreateFrame("Frame", nil, UIParent)
+
+		local scrollFrame = CreateFrame("ScrollFrame", nil, tooltip)
+		scrollFrame:SetPoint("TOP", tooltip, "TOP", 0, -TOOLTIP_PADDING)
+		scrollFrame:SetPoint("BOTTOM", tooltip, "BOTTOM", 0, TOOLTIP_PADDING)
+		scrollFrame:SetPoint("LEFT", tooltip, "LEFT", TOOLTIP_PADDING, 0)
+		scrollFrame:SetPoint("RIGHT", tooltip, "RIGHT", -TOOLTIP_PADDING, 0)
+		tooltip.scrollFrame = scrollFrame
+
+		local scrollChild = CreateFrame("Frame", nil, tooltip.scrollFrame)
+		scrollFrame:SetScrollChild(scrollChild)
+		tooltip.scrollChild = scrollChild
+		setmetatable(tooltip, tipMetatable)
+	end
+	--[===[@debug@
+	usedTooltips = usedTooltips + 1
+	--@end-debug@]===]
+	return tooltip
+end
+
+-- Cleans the tooltip and stores it in the cache
+function ReleaseTooltip(tooltip)
+	if tooltip.releasing then
+		return
+	end
+	tooltip.releasing = true
+
+	tooltip:Hide()
+
+	local releaseHandler = lib.onReleaseHandlers[tooltip]
+	if releaseHandler then
+		lib.onReleaseHandlers[tooltip] = nil
+
+		local success, errorMessage = pcall(releaseHandler, tooltip)
+		if not success then
+			geterrorhandler()(errorMessage)
+		end
+	elseif tooltip.OnRelease then
+		local success, errorMessage = pcall(tooltip.OnRelease, tooltip)
+		if not success then
+			geterrorhandler()(errorMessage)
+		end
+		tooltip.OnRelease = nil
+	end
+
+	tooltip.releasing = nil
+	tooltip.key = nil
+	tooltip.step = nil
+
+	ClearTooltipScripts(tooltip)
+
+	tooltip:SetAutoHideDelay(nil)
+	tooltip:ClearAllPoints()
+	tooltip:Clear()
+
+	if tooltip.slider then
+		tooltip.slider:SetValue(0)
+		tooltip.slider:Hide()
+		tooltip.scrollFrame:SetPoint("RIGHT", tooltip, "RIGHT", -TOOLTIP_PADDING, 0)
+		tooltip:EnableMouseWheel(false)
+	end
+
+	for i, column in ipairs(tooltip.columns) do
+		tooltip.columns[i] = ReleaseFrame(column)
+	end
+	tooltip.columns = ReleaseTable(tooltip.columns)
+	tooltip.lines = ReleaseTable(tooltip.lines)
+	tooltip.colspans = ReleaseTable(tooltip.colspans)
+
+	layoutCleaner.registry[tooltip] = nil
+	tinsert(tooltipHeap, tooltip)
+
+	highlightTexture:SetTexture(DEFAULT_HIGHLIGHT_TEXTURE_PATH)
+	highlightTexture:SetTexCoord(0, 1, 0, 1)
+
+	--[===[@debug@
+	usedTooltips = usedTooltips - 1
+	--@end-debug@]===]
+end
+
+------------------------------------------------------------------------------
+-- Cell 'cache' (just a wrapper to the provider's cache)
+------------------------------------------------------------------------------
+-- Returns a cell for the given tooltip from the given provider
+function AcquireCell(tooltip, provider)
+	local cell = provider:AcquireCell(tooltip)
+
+	cell:SetParent(tooltip.scrollChild)
+	cell:SetFrameLevel(tooltip.scrollChild:GetFrameLevel() + 3)
+	cell._provider = provider
+	return cell
+end
+
+-- Cleans the cell hands it to its provider for storing
+function ReleaseCell(cell)
+	if cell.fontString then
+		cell.fontString:SetFontObject(cell._font)
+
+		if cell.r then
+			cell.fontString:SetTextColor(cell.r, cell.g, cell.b)
+		end
+	end
+	cell._font = nil
+	cell._justification = nil
+	cell._colSpan = nil
+	cell._line = nil
+	cell._column = nil
+
+	cell:Hide()
+	cell:ClearAllPoints()
+	cell:SetParent(nil)
+	cell:SetBackdrop(nil)
+	ClearFrameScripts(cell)
+
+	cell._provider:ReleaseCell(cell)
+	cell._provider = nil
+end
+
+------------------------------------------------------------------------------
+-- Table cache
+------------------------------------------------------------------------------
+local tableHeap = lib.tableHeap
+
+-- Returns a table
+function AcquireTable()
+	local tbl = tremove(tableHeap) or {}
+	--[===[@debug@
+	usedTables = usedTables + 1
+	--@end-debug@]===]
+	return tbl
+end
+
+-- Cleans the table and stores it in the cache
+function ReleaseTable(table)
+	wipe(table)
+	tinsert(tableHeap, table)
+	--[===[@debug@
+	usedTables = usedTables - 1
+	--@end-debug@]===]
+end
+
+------------------------------------------------------------------------------
+-- Tooltip prototype
+------------------------------------------------------------------------------
+function InitializeTooltip(tooltip, key)
+	----------------------------------------------------------------------
+	-- (Re)set frame settings
+	----------------------------------------------------------------------
+	local backdrop = GameTooltip:GetBackdrop()
+
+	tooltip:SetBackdrop(backdrop)
+
+	if backdrop then
+		tooltip:SetBackdropColor(GameTooltip:GetBackdropColor())
+		tooltip:SetBackdropBorderColor(GameTooltip:GetBackdropBorderColor())
+	end
+	tooltip:SetScale(GameTooltip:GetScale())
+	tooltip:SetAlpha(1)
+	tooltip:SetFrameStrata("TOOLTIP")
+	tooltip:SetClampedToScreen(false)
+
+	----------------------------------------------------------------------
+	-- Internal data. Since it's possible to Acquire twice without calling
+	-- release, check for pre-existence.
+	----------------------------------------------------------------------
+	tooltip.key = key
+	tooltip.columns = tooltip.columns or AcquireTable()
+	tooltip.lines = tooltip.lines or AcquireTable()
+	tooltip.colspans = tooltip.colspans or AcquireTable()
+	tooltip.regularFont = GameTooltipText
+	tooltip.headerFont = GameTooltipHeaderText
+	tooltip.labelProvider = labelProvider
+	tooltip.cell_margin_h = tooltip.cell_margin_h or CELL_MARGIN_H
+	tooltip.cell_margin_v = tooltip.cell_margin_v or CELL_MARGIN_V
+
+	----------------------------------------------------------------------
+	-- Finishing procedures
+	----------------------------------------------------------------------
+	tooltip:SetAutoHideDelay(nil)
+	tooltip:Hide()
+	ResetTooltipSize(tooltip)
+end
+
+function tipPrototype:SetDefaultProvider(myProvider)
+	if not myProvider then
+		return
+	end
+	self.labelProvider = myProvider
+end
+
+function tipPrototype:GetDefaultProvider()
+	return self.labelProvider
+end
+
+local function checkJustification(justification, level, silent)
+	if justification ~= "LEFT" and justification ~= "CENTER" and justification ~= "RIGHT" then
+		if silent then
+			return false
+		end
+		error("invalid justification, must one of LEFT, CENTER or RIGHT, not: " .. tostring(justification), level + 1)
+	end
+	return true
+end
+
+function tipPrototype:SetColumnLayout(numColumns, ...)
+	if type(numColumns) ~= "number" or numColumns < 1 then
+		error("number of columns must be a positive number, not: " .. tostring(numColumns), 2)
+	end
+
+	for i = 1, numColumns do
+		local justification = select(i, ...) or "LEFT"
+
+		checkJustification(justification, 2)
+
+		if self.columns[i] then
+			self.columns[i].justification = justification
+		else
+			self:AddColumn(justification)
+		end
+	end
+end
+
+function tipPrototype:AddColumn(justification)
+	justification = justification or "LEFT"
+	checkJustification(justification, 2)
+
+	local colNum = #self.columns + 1
+	local column = self.columns[colNum] or AcquireFrame(self.scrollChild)
+	column:SetFrameLevel(self.scrollChild:GetFrameLevel() + 1)
+	column.justification = justification
+	column.width = 0
+	column:SetWidth(1)
+	column:SetPoint("TOP", self.scrollChild)
+	column:SetPoint("BOTTOM", self.scrollChild)
+
+	if colNum > 1 then
+		local h_margin = self.cell_margin_h or CELL_MARGIN_H
+
+		column:SetPoint("LEFT", self.columns[colNum - 1], "RIGHT", h_margin, 0)
+		SetTooltipSize(self, self.width + h_margin, self.height)
+	else
+		column:SetPoint("LEFT", self.scrollChild)
+	end
+	column:Show()
+	self.columns[colNum] = column
+	return colNum
+end
+
+------------------------------------------------------------------------------
+-- Convenient methods
+------------------------------------------------------------------------------
+function tipPrototype:Release()
+	lib:Release(self)
+end
+
+function tipPrototype:IsAcquiredBy(key)
+	return key ~= nil and self.key == key
+end
+
+------------------------------------------------------------------------------
+-- Script hooks
+------------------------------------------------------------------------------
+
+local RawSetScript = lib.frameMetatable.__index.SetScript
+
+function ClearTooltipScripts(tooltip)
+	if tooltip.scripts then
+		for scriptType in pairs(tooltip.scripts) do
+			RawSetScript(tooltip, scriptType, nil)
+		end
+		tooltip.scripts = ReleaseTable(tooltip.scripts)
+	end
+end
+
+function tipPrototype:SetScript(scriptType, handler)
+	RawSetScript(self, scriptType, handler)
+	if handler then
+		if not self.scripts then
+			self.scripts = AcquireTable()
+		end
+		self.scripts[scriptType] = true
+	elseif self.scripts then
+		self.scripts[scriptType] = nil
+	end
+end
+
+-- That might break some addons ; those addons were breaking other
+-- addons' tooltip though.
+function tipPrototype:HookScript()
+	geterrorhandler()(":HookScript is not allowed on LibQTip tooltips")
+end
+
+------------------------------------------------------------------------------
+-- Scrollbar data and functions
+------------------------------------------------------------------------------
+local sliderBackdrop = {
+	["bgFile"] = [[Interface\Buttons\UI-SliderBar-Background]],
+	["edgeFile"] = [[Interface\Buttons\UI-SliderBar-Border]],
+	["tile"] = true,
+	["edgeSize"] = 8,
+	["tileSize"] = 8,
+	["insets"] = {
+		["left"] = 3,
+		["right"] = 3,
+		["top"] = 3,
+		["bottom"] = 3,
+	},
+}
+
+local function slider_OnValueChanged(self)
+	self.scrollFrame:SetVerticalScroll(self:GetValue())
+end
+
+local function tooltip_OnMouseWheel(self, delta)
+	local slider = self.slider
+	local currentValue = slider:GetValue()
+	local minValue, maxValue = slider:GetMinMaxValues()
+	local stepValue = self.step or 10
+
+	if delta < 0 and currentValue < maxValue then
+		slider:SetValue(min(maxValue, currentValue + stepValue))
+	elseif delta > 0 and currentValue > minValue then
+		slider:SetValue(max(minValue, currentValue - stepValue))
+	end
+end
+
+-- Set the step size for the scroll bar
+function tipPrototype:SetScrollStep(step)
+	self.step = step
+end
+
+-- will resize the tooltip to fit the screen and show a scrollbar if needed
+function tipPrototype:UpdateScrolling(maxheight)
+	self:SetClampedToScreen(false)
+
+	-- all data is in the tooltip; fix colspan width and prevent the layout cleaner from messing up the tooltip later
+	FixCellSizes(self)
+	layoutCleaner.registry[self] = nil
+
+	local scale = self:GetScale()
+	local topside = self:GetTop()
+	local bottomside = self:GetBottom()
+	local screensize = UIParent:GetHeight() / scale
+	local tipsize = (topside - bottomside)
+
+	-- if the tooltip would be too high, limit its height and show the slider
+	if bottomside < 0 or topside > screensize or (maxheight and tipsize > maxheight) then
+		local shrink = (bottomside < 0 and (5 - bottomside) or 0) + (topside > screensize and (topside - screensize + 5) or 0)
+
+		if maxheight and tipsize - shrink > maxheight then
+			shrink = tipsize - maxheight
+		end
+		self:SetHeight(2 * TOOLTIP_PADDING + self.height - shrink)
+		self:SetWidth(2 * TOOLTIP_PADDING + self.width + 20)
+		self.scrollFrame:SetPoint("RIGHT", self, "RIGHT", -(TOOLTIP_PADDING + 20), 0)
+
+		if not self.slider then
+			local slider = CreateFrame("Slider", nil, self)
+
+			self.slider = slider
+
+			slider:SetOrientation("VERTICAL")
+			slider:SetPoint("TOPRIGHT", self, "TOPRIGHT", -TOOLTIP_PADDING, -TOOLTIP_PADDING)
+			slider:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -TOOLTIP_PADDING, TOOLTIP_PADDING)
+			slider:SetBackdrop(sliderBackdrop)
+			slider:SetThumbTexture([[Interface\Buttons\UI-SliderBar-Button-Vertical]])
+			slider:SetMinMaxValues(0, 1)
+			slider:SetValueStep(1)
+			slider:SetWidth(12)
+			slider.scrollFrame = self.scrollFrame
+			slider:SetScript("OnValueChanged", slider_OnValueChanged)
+			slider:SetValue(0)
+		end
+		self.slider:SetMinMaxValues(0, shrink)
+		self.slider:Show()
+		self:EnableMouseWheel(true)
+		self:SetScript("OnMouseWheel", tooltip_OnMouseWheel)
+	else
+		self:SetHeight(2 * TOOLTIP_PADDING + self.height)
+		self:SetWidth(2 * TOOLTIP_PADDING + self.width)
+		self.scrollFrame:SetPoint("RIGHT", self, "RIGHT", -TOOLTIP_PADDING, 0)
+
+		if self.slider then
+			self.slider:SetValue(0)
+			self.slider:Hide()
+			self:EnableMouseWheel(false)
+			self:SetScript("OnMouseWheel", nil)
+		end
+	end
+end
+
+------------------------------------------------------------------------------
+-- Tooltip methods for changing its contents.
+------------------------------------------------------------------------------
+function tipPrototype:Clear()
+	for i, line in ipairs(self.lines) do
+		for j, cell in pairs(line.cells) do
+			if cell then
+				ReleaseCell(cell)
+			end
+		end
+		ReleaseTable(line.cells)
+		line.cells = nil
+		line.is_header = nil
+		ReleaseFrame(line)
+		self.lines[i] = nil
+	end
+
+	for i, column in ipairs(self.columns) do
+		column.width = 0
+		column:SetWidth(1)
+	end
+	wipe(self.colspans)
+	self.cell_margin_h = nil
+	self.cell_margin_v = nil
+	ResetTooltipSize(self)
+end
+
+function tipPrototype:SetCellMarginH(size)
+	if #self.lines > 0 then
+		error("Unable to set horizontal margin while the tooltip has lines.", 2)
+	end
+
+	if not size or type(size) ~= "number" or size < 0 then
+		error("Margin size must be a positive number or zero.", 2)
+	end
+	self.cell_margin_h = size
+end
+
+function tipPrototype:SetCellMarginV(size)
+	if #self.lines > 0 then
+		error("Unable to set vertical margin while the tooltip has lines.", 2)
+	end
+
+	if not size or type(size) ~= "number" or size < 0 then
+		error("Margin size must be a positive number or zero.", 2)
+	end
+	self.cell_margin_v = size
+end
+
+function SetTooltipSize(tooltip, width, height)
+	tooltip:SetHeight(2 * TOOLTIP_PADDING + height)
+	tooltip.scrollChild:SetHeight(height)
+	tooltip.height = height
+
+	tooltip:SetWidth(2 * TOOLTIP_PADDING + width)
+	tooltip.scrollChild:SetWidth(width)
+	tooltip.width = width
+end
+
+-- Add 2 pixels to height so dangling letters (g, y, p, j, etc) are not clipped.
+function ResetTooltipSize(tooltip)
+	local h_margin = tooltip.cell_margin_h or CELL_MARGIN_H
+
+	SetTooltipSize(tooltip, max(0, (h_margin * (#tooltip.columns - 1)) + (h_margin / 2)), 2)
+end
+
+local function EnlargeColumn(tooltip, column, width)
+	if width > column.width then
+		SetTooltipSize(tooltip, tooltip.width + width - column.width, tooltip.height)
+
+		column.width = width
+		column:SetWidth(width)
+	end
+end
+
+local function ResizeLine(tooltip, line, height)
+	SetTooltipSize(tooltip, tooltip.width, tooltip.height + height - line.height)
+
+	line.height = height
+	line:SetHeight(height)
+end
+
+function FixCellSizes(tooltip)
+	local columns = tooltip.columns
+	local colspans = tooltip.colspans
+	local lines = tooltip.lines
+
+	-- resize columns to make room for the colspans
+	local h_margin = tooltip.cell_margin_h or CELL_MARGIN_H
+	while next(colspans) do
+		local maxNeedCols
+		local maxNeedWidthPerCol = 0
+
+		-- calculate the colspan with the highest additional width need per column
+		for colRange, width in pairs(colspans) do
+			local left, right = colRange:match("^(%d+)%-(%d+)$")
+			left, right = tonumber(left), tonumber(right)
+
+			for col = left, right - 1 do
+				width = width - columns[col].width - h_margin
+			end
+			width = width - columns[right].width
+
+			if width <= 0 then
+				colspans[colRange] = nil
+			else
+				width = width / (right - left + 1)
+				if width > maxNeedWidthPerCol then
+					maxNeedCols = colRange
+					maxNeedWidthPerCol = width
+				end
+			end
+		end
+		-- resize all columns for that colspan
+		if maxNeedCols then
+			local left, right = maxNeedCols:match("^(%d+)%-(%d+)$")
+			for col = left, right do
+				EnlargeColumn(tooltip, columns[col], columns[col].width + maxNeedWidthPerCol)
+			end
+			colspans[maxNeedCols] = nil
+		end
+	end
+
+	--now that the cell width is set, recalculate the rows' height
+	for _, line in ipairs(lines) do
+		if #(line.cells) > 0 then
+			local lineheight = 0
+			for _, cell in pairs(line.cells) do
+				if cell then
+					lineheight = max(lineheight, cell:getContentHeight())
+				end
+			end
+			if lineheight > 0 then
+				ResizeLine(tooltip, line, lineheight)
+			end
+		end
+	end
+end
+
+local function _SetCell(tooltip, lineNum, colNum, value, font, justification, colSpan, provider, ...)
+	local line = tooltip.lines[lineNum]
+	local cells = line.cells
+
+	-- Unset: be quick
+	if value == nil then
+		local cell = cells[colNum]
+
+		if cell then
+			for i = colNum, colNum + cell._colSpan - 1 do
+				cells[i] = nil
+			end
+			ReleaseCell(cell)
+		end
+		return lineNum, colNum
+	end
+	font = font or (line.is_header and tooltip.headerFont or tooltip.regularFont)
+
+	-- Check previous cell
+	local cell
+	local prevCell = cells[colNum]
+
+	if prevCell then
+		-- There is a cell here
+		justification = justification or prevCell._justification
+		colSpan = colSpan or prevCell._colSpan
+
+		-- Clear the currently marked colspan
+		for i = colNum + 1, colNum + prevCell._colSpan - 1 do
+			cells[i] = nil
+		end
+
+		if provider == nil or prevCell._provider == provider then
+			-- Reuse existing cell
+			cell = prevCell
+			provider = cell._provider
+		else
+			-- A new cell is required
+			cells[colNum] = ReleaseCell(prevCell)
+		end
+	elseif prevCell == nil then
+		-- Creating a new cell, using meaningful defaults.
+		provider = provider or tooltip.labelProvider
+		justification = justification or tooltip.columns[colNum].justification or "LEFT"
+		colSpan = colSpan or 1
+	else
+		error("overlapping cells at column " .. colNum, 3)
+	end
+	local tooltipWidth = #tooltip.columns
+	local rightColNum
+
+	if colSpan > 0 then
+		rightColNum = colNum + colSpan - 1
+
+		if rightColNum > tooltipWidth then
+			error("ColSpan too big, cell extends beyond right-most column", 3)
+		end
+	else
+		-- Zero or negative: count back from right-most columns
+		rightColNum = max(colNum, tooltipWidth + colSpan)
+		-- Update colspan to its effective value
+		colSpan = 1 + rightColNum - colNum
+	end
+
+	-- Cleanup colspans
+	for i = colNum + 1, rightColNum do
+		local cell = cells[i]
+
+		if cell then
+			ReleaseCell(cell)
+		elseif cell == false then
+			error("overlapping cells at column " .. i, 3)
+		end
+		cells[i] = false
+	end
+
+	-- Create the cell
+	if not cell then
+		cell = AcquireCell(tooltip, provider)
+		cells[colNum] = cell
+	end
+
+	-- Anchor the cell
+	cell:SetPoint("LEFT", tooltip.columns[colNum])
+	cell:SetPoint("RIGHT", tooltip.columns[rightColNum])
+	cell:SetPoint("TOP", line)
+	cell:SetPoint("BOTTOM", line)
+
+	-- Store the cell settings directly into the cell
+	-- That's a bit risky but is really cheap compared to other ways to do it
+	cell._font, cell._justification, cell._colSpan, cell._line, cell._column = font, justification, colSpan, lineNum, colNum
+
+	-- Setup the cell content
+	local width, height = cell:SetupCell(tooltip, value, justification, font, ...)
+	cell:Show()
+
+	if colSpan > 1 then
+		-- Postpone width changes until the tooltip is shown
+		local colRange = colNum .. "-" .. rightColNum
+
+		tooltip.colspans[colRange] = max(tooltip.colspans[colRange] or 0, width)
+		layoutCleaner:RegisterForCleanup(tooltip)
+	else
+		-- Enlarge the column and tooltip if need be
+		EnlargeColumn(tooltip, tooltip.columns[colNum], width)
+	end
+
+	-- Enlarge the line and tooltip if need be
+	if height > line.height then
+		SetTooltipSize(tooltip, tooltip.width, tooltip.height + height - line.height)
+
+		line.height = height
+		line:SetHeight(height)
+	end
+
+	if rightColNum < tooltipWidth then
+		return lineNum, rightColNum + 1
+	else
+		return lineNum, nil
+	end
+end
+
+do
+	local function CreateLine(tooltip, font, ...)
+		if #tooltip.columns == 0 then
+			error("column layout should be defined before adding line", 3)
+		end
+		local lineNum = #tooltip.lines + 1
+		local line = tooltip.lines[lineNum] or AcquireFrame(tooltip.scrollChild)
+
+		line:SetFrameLevel(tooltip.scrollChild:GetFrameLevel() + 2)
+		line:SetPoint('LEFT', tooltip.scrollChild)
+		line:SetPoint('RIGHT', tooltip.scrollChild)
+
+		if lineNum > 1 then
+			local v_margin = tooltip.cell_margin_v or CELL_MARGIN_V
+
+			line:SetPoint('TOP', tooltip.lines[lineNum - 1], 'BOTTOM', 0, -v_margin)
+			SetTooltipSize(tooltip, tooltip.width, tooltip.height + v_margin)
+		else
+			line:SetPoint('TOP', tooltip.scrollChild)
+		end
+		tooltip.lines[lineNum] = line
+		line.cells = line.cells or AcquireTable()
+		line.height = 0
+		line:SetHeight(1)
+		line:Show()
+
+		local colNum = 1
+
+		for i = 1, #tooltip.columns do
+			local value = select(i, ...)
+
+			if value ~= nil then
+				lineNum, colNum = _SetCell(tooltip, lineNum, i, value, font, nil, 1, tooltip.labelProvider)
+			end
+		end
+		return lineNum, colNum
+	end
+
+	function tipPrototype:AddLine(...)
+		return CreateLine(self, self.regularFont, ...)
+	end
+
+	function tipPrototype:AddHeader(...)
+		local line, col = CreateLine(self, self.headerFont, ...)
+
+		self.lines[line].is_header = true
+		return line, col
+	end
+end -- do-block
+
+local GenericBackdrop = {
+	bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
+}
+
+function tipPrototype:AddSeparator(height, r, g, b, a)
+	local lineNum, colNum = self:AddLine()
+	local line = self.lines[lineNum]
+	local color = _G.NORMAL_FONT_COLOR
+
+	height = height or 1
+	SetTooltipSize(self, self.width, self.height + height)
+	line.height = height
+	line:SetHeight(height)
+	line:SetBackdrop(GenericBackdrop)
+	line:SetBackdropColor(r or color.r, g or color.g, b or color.b, a or 1)
+	return lineNum, colNum
+end
+
+function tipPrototype:SetCellColor(lineNum, colNum, r, g, b, a)
+	local cell = self.lines[lineNum].cells[colNum]
+
+	if cell then
+		local sr, sg, sb, sa = self:GetBackdropColor()
+		cell:SetBackdrop(GenericBackdrop)
+		cell:SetBackdropColor(r or sr, g or sg, b or sb, a or sa)
+	end
+end
+
+function tipPrototype:SetColumnColor(colNum, r, g, b, a)
+	local column = self.columns[colNum]
+
+	if column then
+		local sr, sg, sb, sa = self:GetBackdropColor()
+		column:SetBackdrop(GenericBackdrop)
+		column:SetBackdropColor(r or sr, g or sg, b or sb, a or sa)
+	end
+end
+
+function tipPrototype:SetLineColor(lineNum, r, g, b, a)
+	local line = self.lines[lineNum]
+
+	if line then
+		local sr, sg, sb, sa = self:GetBackdropColor()
+		line:SetBackdrop(GenericBackdrop)
+		line:SetBackdropColor(r or sr, g or sg, b or sb, a or sa)
+	end
+end
+
+function tipPrototype:SetCellTextColor(lineNum, colNum, r, g, b, a)
+	local line = self.lines[lineNum]
+	local column = self.columns[colNum]
+
+	if not line or not column then
+		return
+	end
+	local cell = self.lines[lineNum].cells[colNum]
+
+	if cell then
+		if not cell.fontString then
+			error("cell's label provider did not assign a fontString field", 2)
+		end
+
+		if not cell.r then
+			cell.r, cell.g, cell.b = cell.fontString:GetTextColor()
+		end
+		local font = (line.is_header and self.headerFont or self.regularFont)
+		local sr, sg, sb, sa = font:GetTextColor()
+		cell.fontString:SetTextColor(r or sr, g or sg, b or sb, a or sa)
+	end
+end
+
+function tipPrototype:SetColumnTextColor(colNum, r, g, b, a)
+	if not self.columns[colNum] then
+		return
+	end
+
+	for line_index = 1, #self.lines do
+		self:SetCellTextColor(line_index, colNum, r, g, b, a)
+	end
+end
+
+function tipPrototype:SetLineTextColor(lineNum, r, g, b, a)
+	local line = self.lines[lineNum]
+
+	if not line then
+		return
+	end
+
+	for cell_index = 1, #line.cells do
+		self:SetCellTextColor(lineNum, line.cells[cell_index]._column, r, g, b, a)
+	end
+end
+
+function tipPrototype:SetHighlightTexture(...)
+	return highlightTexture:SetTexture(...)
+end
+
+function tipPrototype:SetHighlightTexCoord(...)
+	highlightTexture:SetTexCoord(...)
+end
+
+do
+	local function checkFont(font, level, silent)
+		local bad = false
+
+		if not font then
+			bad = true
+		elseif type(font) == "string" then
+			local ref = _G[font]
+
+			if not ref or type(ref) ~= 'table' or type(ref.IsObjectType) ~= 'function' or not ref:IsObjectType("Font") then
+				bad = true
+			end
+		elseif type(font) ~= 'table' or type(font.IsObjectType) ~= 'function' or not font:IsObjectType("Font") then
+			bad = true
+		end
+
+		if bad then
+			if silent then
+				return false
+			end
+			error("font must be a Font instance or a string matching the name of a global Font instance, not: " .. tostring(font), level + 1)
+		end
+		return true
+	end
+
+	function tipPrototype:SetFont(font)
+		local is_string = type(font) == "string"
+
+		checkFont(font, 2)
+		self.regularFont = is_string and _G[font] or font
+	end
+
+	function tipPrototype:SetHeaderFont(font)
+		local is_string = type(font) == "string"
+
+		checkFont(font, 2)
+		self.headerFont = is_string and _G[font] or font
+	end
+
+	-- TODO: fixed argument positions / remove checks for performance?
+	function tipPrototype:SetCell(lineNum, colNum, value, ...)
+		-- Mandatory argument checking
+		if type(lineNum) ~= "number" then
+			error("line number must be a number, not: " .. tostring(lineNum), 2)
+		elseif lineNum < 1 or lineNum > #self.lines then
+			error("line number out of range: " .. tostring(lineNum), 2)
+		elseif type(colNum) ~= "number" then
+			error("column number must be a number, not: " .. tostring(colNum), 2)
+		elseif colNum < 1 or colNum > #self.columns then
+			error("column number out of range: " .. tostring(colNum), 2)
+		end
+
+		-- Variable argument checking
+		local font, justification, colSpan, provider
+		local i, arg = 1, ...
+
+		if arg == nil or checkFont(arg, 2, true) then
+			i, font, arg = 2, ...
+		end
+
+		if arg == nil or checkJustification(arg, 2, true) then
+			i, justification, arg = i + 1, select(i, ...)
+		end
+
+		if arg == nil or type(arg) == 'number' then
+			i, colSpan, arg = i + 1, select(i, ...)
+		end
+
+		if arg == nil or type(arg) == 'table' and type(arg.AcquireCell) == 'function' then
+			i, provider = i + 1, arg
+		end
+
+		return _SetCell(self, lineNum, colNum, value, font, justification, colSpan, provider, select(i, ...))
+	end
+end -- do-block
+
+function tipPrototype:GetFont()
+	return self.regularFont
+end
+
+function tipPrototype:GetHeaderFont()
+	return self.headerFont
+end
+
+function tipPrototype:GetLineCount() return #self.lines end
+
+function tipPrototype:GetColumnCount() return #self.columns end
+
+
+------------------------------------------------------------------------------
+-- Frame Scripts
+------------------------------------------------------------------------------
+local scripts = {
+	OnEnter = function(frame, ...)
+		highlightFrame:SetParent(frame)
+		highlightFrame:SetAllPoints(frame)
+		highlightFrame:Show()
+
+		if frame._OnEnter_func then
+			frame:_OnEnter_func(frame._OnEnter_arg, ...)
+		end
+	end,
+	OnLeave = function(frame, ...)
+		highlightFrame:Hide()
+		highlightFrame:ClearAllPoints()
+		highlightFrame:SetParent(nil)
+
+		if frame._OnLeave_func then
+			frame:_OnLeave_func(frame._OnLeave_arg, ...)
+		end
+	end,
+	OnMouseDown = function(frame, ...)
+		frame:_OnMouseDown_func(frame._OnMouseDown_arg, ...)
+	end,
+	OnMouseUp = function(frame, ...)
+		frame:_OnMouseUp_func(frame._OnMouseUp_arg, ...)
+	end,
+	OnReceiveDrag = function(frame, ...)
+		frame:_OnReceiveDrag_func(frame._OnReceiveDrag_arg, ...)
+	end,
+}
+
+function SetFrameScript(frame, script, func, arg)
+	if not scripts[script] then
+		return
+	end
+	frame["_" .. script .. "_func"] = func
+	frame["_" .. script .. "_arg"] = arg
+
+	if script == "OnMouseDown" or script == "OnMouseUp" or script == "OnReceiveDrag" then
+		if func then
+			frame:SetScript(script, scripts[script])
+		else
+			frame:SetScript(script, nil)
+		end
+	end
+
+	-- if at least one script is set, set the OnEnter/OnLeave scripts for the highlight
+	if frame._OnEnter_func or frame._OnLeave_func or frame._OnMouseDown_func or frame._OnMouseUp_func or frame._OnReceiveDrag_func then
+		frame:EnableMouse(true)
+		frame:SetScript("OnEnter", scripts.OnEnter)
+		frame:SetScript("OnLeave", scripts.OnLeave)
+	else
+		frame:EnableMouse(false)
+		frame:SetScript("OnEnter", nil)
+		frame:SetScript("OnLeave", nil)
+	end
+end
+
+function ClearFrameScripts(frame)
+	if frame._OnEnter_func or frame._OnLeave_func or frame._OnMouseDown_func or frame._OnMouseUp_func or frame._OnReceiveDrag_func then
+		frame:EnableMouse(false)
+		frame:SetScript("OnEnter", nil)
+		frame._OnEnter_func = nil
+		frame._OnEnter_arg = nil
+		frame:SetScript("OnLeave", nil)
+		frame._OnLeave_func = nil
+		frame._OnLeave_arg = nil
+		frame:SetScript("OnReceiveDrag", nil)
+		frame._OnReceiveDrag_func = nil
+		frame._OnReceiveDrag_arg = nil
+		frame:SetScript("OnMouseDown", nil)
+		frame._OnMouseDown_func = nil
+		frame._OnMouseDown_arg = nil
+		frame:SetScript("OnMouseUp", nil)
+		frame._OnMouseUp_func = nil
+		frame._OnMouseUp_arg = nil
+	end
+end
+
+function tipPrototype:SetLineScript(lineNum, script, func, arg)
+	SetFrameScript(self.lines[lineNum], script, func, arg)
+end
+
+function tipPrototype:SetColumnScript(colNum, script, func, arg)
+	SetFrameScript(self.columns[colNum], script, func, arg)
+end
+
+function tipPrototype:SetCellScript(lineNum, colNum, script, func, arg)
+	local cell = self.lines[lineNum].cells[colNum]
+	if cell then
+		SetFrameScript(cell, script, func, arg)
+	end
+end
+
+------------------------------------------------------------------------------
+-- Auto-hiding feature
+------------------------------------------------------------------------------
+
+-- Script of the auto-hiding child frame
+local function AutoHideTimerFrame_OnUpdate(self, elapsed)
+	self.checkElapsed = self.checkElapsed + elapsed
+	if self.checkElapsed > 0.1 then
+		if self.parent:IsMouseOver() or (self.alternateFrame and self.alternateFrame:IsMouseOver()) then
+			self.elapsed = 0
+		else
+			self.elapsed = self.elapsed + self.checkElapsed
+			if self.elapsed >= self.delay then
+				lib:Release(self.parent)
+			end
+		end
+		self.checkElapsed = 0
+	end
+end
+
+-- Usage:
+-- :SetAutoHideDelay(0.25) => hides after 0.25sec outside of the tooltip
+-- :SetAutoHideDelay(0.25, someFrame) => hides after 0.25sec outside of both the tooltip and someFrame
+-- :SetAutoHideDelay() => disable auto-hiding (default)
+function tipPrototype:SetAutoHideDelay(delay, alternateFrame, releaseHandler)
+	local timerFrame = self.autoHideTimerFrame
+	delay = tonumber(delay) or 0
+
+	if releaseHandler then
+		if type(releaseHandler) ~= "function" then
+			error("releaseHandler must be a function", 2)
+		end
+		lib.onReleaseHandlers[self] = releaseHandler
+	end
+
+	if delay > 0 then
+		if not timerFrame then
+			timerFrame = AcquireFrame(self)
+			timerFrame:SetScript("OnUpdate", AutoHideTimerFrame_OnUpdate)
+			self.autoHideTimerFrame = timerFrame
+		end
+		timerFrame.parent = self
+		timerFrame.checkElapsed = 0
+		timerFrame.elapsed = 0
+		timerFrame.delay = delay
+		timerFrame.alternateFrame = alternateFrame
+		timerFrame:Show()
+	elseif timerFrame then
+		self.autoHideTimerFrame = nil
+		timerFrame.alternateFrame = nil
+		timerFrame:SetScript("OnUpdate", nil)
+		ReleaseFrame(timerFrame)
+	end
+end
+
+------------------------------------------------------------------------------
+-- "Smart" Anchoring
+------------------------------------------------------------------------------
+local function GetTipAnchor(frame)
+	local x, y = frame:GetCenter()
+	if not x or not y then return "TOPLEFT", "BOTTOMLEFT" end
+	local hhalf = (x > UIParent:GetWidth() * 2 / 3) and "RIGHT" or (x < UIParent:GetWidth() / 3) and "LEFT" or ""
+	local vhalf = (y > UIParent:GetHeight() / 2) and "TOP" or "BOTTOM"
+	return vhalf .. hhalf, frame, (vhalf == "TOP" and "BOTTOM" or "TOP") .. hhalf
+end
+
+function tipPrototype:SmartAnchorTo(frame)
+	if not frame then
+		error("Invalid frame provided.", 2)
+	end
+	self:ClearAllPoints()
+	self:SetClampedToScreen(true)
+	self:SetPoint(GetTipAnchor(frame))
+end
+
+------------------------------------------------------------------------------
+-- Debug slashcmds
+------------------------------------------------------------------------------
+-- @debug @
+local print = print
+local function PrintStats()
+	local tipCache = tostring(#tooltipHeap)
+	local frameCache = tostring(#frameHeap)
+	local tableCache = tostring(#tableHeap)
+	local header = false
+
+	print("Tooltips used: " .. usedTooltips .. ", Cached: " .. tipCache .. ", Total: " .. tipCache + usedTooltips)
+	print("Frames used: " .. usedFrames .. ", Cached: " .. frameCache .. ", Total: " .. frameCache + usedFrames)
+	print("Tables used: " .. usedTables .. ", Cached: " .. tableCache .. ", Total: " .. tableCache + usedTables)
+
+	for k, v in pairs(activeTooltips) do
+		if not header then
+			print("Active tooltips:")
+			header = true
+		end
+		print("- " .. k)
+	end
+end
+
+SLASH_LibQTip1 = "/qtip"
+SlashCmdList["LibQTip"] = PrintStats
+--@end-debug@
diff --git a/Libs/LibQTip-1.0/LibQTip-1.0.toc b/Libs/LibQTip-1.0/LibQTip-1.0.toc
new file mode 100644
index 0000000..6962d93
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibQTip-1.0.toc
@@ -0,0 +1,18 @@
+## Interface: 70000
+## Title: Lib: QTip-1.0
+## Notes: Library providing multi-column tooltips.
+## Author: Torhal, Adirelle, Elkano, Tristanian
+## Version: r178-release
+## LoadOnDemand: 1
+## X-Date: 2016-07-19T07:09:09Z
+## X-Credits: Kaelten (input on initial design)
+## X-Category: Library, Tooltip
+## X-License: Ace3 BSD-like license
+## X-Website: http://www.wowace.com/addons/libqtip-1-0/
+## X-Curse-Packaged-Version: r178-release
+## X-Curse-Project-Name: LibQTip-1.0
+## X-Curse-Project-ID: libqtip-1-0
+## X-Curse-Repository-ID: wow/libqtip-1-0/mainline
+
+LibStub\LibStub.lua
+lib.xml
diff --git a/Libs/LibQTip-1.0/LibStub/LibStub.lua b/Libs/LibQTip-1.0/LibStub/LibStub.lua
new file mode 100644
index 0000000..7e9b5cd
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibStub/LibStub.lua
@@ -0,0 +1,51 @@
+-- $Id: LibStub.lua 103 2014-10-16 03:02:50Z mikk $
+-- LibStub is a simple versioning stub meant for use in Libraries.  http://www.wowace.com/addons/libstub/ for more info
+-- LibStub is hereby placed in the Public Domain
+-- Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
+local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2  -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
+local LibStub = _G[LIBSTUB_MAJOR]
+
+-- Check to see is this version of the stub is obsolete
+if not LibStub or LibStub.minor < LIBSTUB_MINOR then
+	LibStub = LibStub or {libs = {}, minors = {} }
+	_G[LIBSTUB_MAJOR] = LibStub
+	LibStub.minor = LIBSTUB_MINOR
+
+	-- LibStub:NewLibrary(major, minor)
+	-- major (string) - the major version of the library
+	-- minor (string or number ) - the minor version of the library
+	--
+	-- returns nil if a newer or same version of the lib is already present
+	-- returns empty library object or old library object if upgrade is needed
+	function LibStub:NewLibrary(major, minor)
+		assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
+		minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.")
+
+		local oldminor = self.minors[major]
+		if oldminor and oldminor >= minor then return nil end
+		self.minors[major], self.libs[major] = minor, self.libs[major] or {}
+		return self.libs[major], oldminor
+	end
+
+	-- LibStub:GetLibrary(major, [silent])
+	-- major (string) - the major version of the library
+	-- silent (boolean) - if true, library is optional, silently return nil if its not found
+	--
+	-- throws an error if the library can not be found (except silent is set)
+	-- returns the library object if found
+	function LibStub:GetLibrary(major, silent)
+		if not self.libs[major] and not silent then
+			error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
+		end
+		return self.libs[major], self.minors[major]
+	end
+
+	-- LibStub:IterateLibraries()
+	--
+	-- Returns an iterator for the currently registered libraries
+	function LibStub:IterateLibraries()
+		return pairs(self.libs)
+	end
+
+	setmetatable(LibStub, { __call = LibStub.GetLibrary })
+end
diff --git a/Libs/LibQTip-1.0/LibStub/LibStub.toc b/Libs/LibQTip-1.0/LibStub/LibStub.toc
new file mode 100644
index 0000000..ac4a1c4
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibStub/LibStub.toc
@@ -0,0 +1,13 @@
+## Interface: 60000
+## Title: Lib: LibStub
+## Notes: Universal Library Stub
+## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel
+## X-Website: http://www.wowace.com/addons/libstub/
+## X-Category: Library
+## X-License: Public Domain
+## X-Curse-Packaged-Version: 1.0.2.60000
+## X-Curse-Project-Name: LibStub
+## X-Curse-Project-ID: libstub
+## X-Curse-Repository-ID: wow/libstub/mainline
+
+LibStub.lua
diff --git a/Libs/LibQTip-1.0/LibStub/tests/test.lua b/Libs/LibQTip-1.0/LibStub/tests/test.lua
new file mode 100644
index 0000000..276ddab
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibStub/tests/test.lua
@@ -0,0 +1,41 @@
+debugstack = debug.traceback
+strmatch = string.match
+
+loadfile("../LibStub.lua")()
+
+local lib, oldMinor = LibStub:NewLibrary("Pants", 1) -- make a new thingy
+assert(lib) -- should return the library table
+assert(not oldMinor) -- should not return the old minor, since it didn't exist
+
+-- the following is to create data and then be able to check if the same data exists after the fact
+function lib:MyMethod()
+end
+local MyMethod = lib.MyMethod
+lib.MyTable = {}
+local MyTable = lib.MyTable
+
+local newLib, newOldMinor = LibStub:NewLibrary("Pants", 1) -- try to register a library with the same version, should silently fail
+assert(not newLib) -- should not return since out of date
+
+local newLib, newOldMinor = LibStub:NewLibrary("Pants", 0) -- try to register a library with a previous, should silently fail
+assert(not newLib) -- should not return since out of date
+
+local newLib, newOldMinor = LibStub:NewLibrary("Pants", 2) -- register a new version
+assert(newLib) -- library table
+assert(rawequal(newLib, lib)) -- should be the same reference as the previous
+assert(newOldMinor == 1) -- should return the minor version of the previous version
+
+assert(rawequal(lib.MyMethod, MyMethod)) -- verify that values were saved
+assert(rawequal(lib.MyTable, MyTable)) -- verify that values were saved
+
+local newLib, newOldMinor = LibStub:NewLibrary("Pants", "Blah 3 Blah") -- register a new version with a string minor version (instead of a number)
+assert(newLib) -- library table
+assert(newOldMinor == 2) -- previous version was 2
+
+local newLib, newOldMinor = LibStub:NewLibrary("Pants", "Blah 4 and please ignore 15 Blah") -- register a new version with a string minor version (instead of a number)
+assert(newLib)
+assert(newOldMinor == 3) -- previous version was 3 (even though it gave a string)
+
+local newLib, newOldMinor = LibStub:NewLibrary("Pants", 5) -- register a new library, using a normal number instead of a string
+assert(newLib)
+assert(newOldMinor == 4) -- previous version was 4 (even though it gave a string)
\ No newline at end of file
diff --git a/Libs/LibQTip-1.0/LibStub/tests/test2.lua b/Libs/LibQTip-1.0/LibStub/tests/test2.lua
new file mode 100644
index 0000000..eae7172
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibStub/tests/test2.lua
@@ -0,0 +1,27 @@
+debugstack = debug.traceback
+strmatch = string.match
+
+loadfile("../LibStub.lua")()
+
+for major, library in LibStub:IterateLibraries() do
+	-- check that MyLib doesn't exist yet, by iterating through all the libraries
+	assert(major ~= "MyLib")
+end
+
+assert(not LibStub:GetLibrary("MyLib", true)) -- check that MyLib doesn't exist yet by direct checking
+assert(not pcall(LibStub.GetLibrary, LibStub, "MyLib")) -- don't silently fail, thus it should raise an error.
+local lib = LibStub:NewLibrary("MyLib", 1) -- create the lib
+assert(lib) -- check it exists
+assert(rawequal(LibStub:GetLibrary("MyLib"), lib)) -- verify that :GetLibrary("MyLib") properly equals the lib reference
+
+assert(LibStub:NewLibrary("MyLib", 2))	-- create a new version
+
+local count=0
+for major, library in LibStub:IterateLibraries() do
+	-- check that MyLib exists somewhere in the libraries, by iterating through all the libraries
+	if major == "MyLib" then -- we found it!
+		count = count +1
+		assert(rawequal(library, lib)) -- verify that the references are equal
+	end
+end
+assert(count == 1) -- verify that we actually found it, and only once
diff --git a/Libs/LibQTip-1.0/LibStub/tests/test3.lua b/Libs/LibQTip-1.0/LibStub/tests/test3.lua
new file mode 100644
index 0000000..30f7b94
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibStub/tests/test3.lua
@@ -0,0 +1,14 @@
+debugstack = debug.traceback
+strmatch = string.match
+
+loadfile("../LibStub.lua")()
+
+local proxy = newproxy() -- non-string
+
+assert(not pcall(LibStub.NewLibrary, LibStub, proxy, 1)) -- should error, proxy is not a string, it's userdata
+local success, ret = pcall(LibStub.GetLibrary, proxy, true)
+assert(not success or not ret) -- either error because proxy is not a string or because it's not actually registered.
+
+assert(not pcall(LibStub.NewLibrary, LibStub, "Something", "No number in here")) -- should error, minor has no string in it.
+
+assert(not LibStub:GetLibrary("Something", true)) -- shouldn't've created it from the above statement
\ No newline at end of file
diff --git a/Libs/LibQTip-1.0/LibStub/tests/test4.lua b/Libs/LibQTip-1.0/LibStub/tests/test4.lua
new file mode 100644
index 0000000..43eb338
--- /dev/null
+++ b/Libs/LibQTip-1.0/LibStub/tests/test4.lua
@@ -0,0 +1,41 @@
+debugstack = debug.traceback
+strmatch = string.match
+
+loadfile("../LibStub.lua")()
+
+
+-- Pretend like loaded libstub is old and doesn't have :IterateLibraries
+assert(LibStub.minor)
+LibStub.minor = LibStub.minor - 0.0001
+LibStub.IterateLibraries = nil
+
+loadfile("../LibStub.lua")()
+
+assert(type(LibStub.IterateLibraries)=="function")
+
+
+-- Now pretend that we're the same version -- :IterateLibraries should NOT be re-created
+LibStub.IterateLibraries = 123
+
+loadfile("../LibStub.lua")()
+
+assert(LibStub.IterateLibraries == 123)
+
+
+-- Now pretend that a newer version is loaded -- :IterateLibraries should NOT be re-created
+LibStub.minor = LibStub.minor + 0.0001
+
+loadfile("../LibStub.lua")()
+
+assert(LibStub.IterateLibraries == 123)
+
+
+-- Again with a huge number
+LibStub.minor = LibStub.minor + 1234567890
+
+loadfile("../LibStub.lua")()
+
+assert(LibStub.IterateLibraries == 123)
+
+
+print("OK")
\ No newline at end of file
diff --git a/Libs/LibQTip-1.0/lib.xml b/Libs/LibQTip-1.0/lib.xml
new file mode 100644
index 0000000..5531be0
--- /dev/null
+++ b/Libs/LibQTip-1.0/lib.xml
@@ -0,0 +1,4 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<Script file="LibQTip-1.0.lua"/>
+</Ui>
\ No newline at end of file
diff --git a/embeds.xml b/embeds.xml
index c10ad7d..cfaa140 100644
--- a/embeds.xml
+++ b/embeds.xml
@@ -12,6 +12,7 @@
   <Include file="Libs\AceConfig-3.0\AceConfig-3.0.xml"/>
 	<Include file="Libs\LibSharedMedia-3.0\lib.xml"/>
   <Include file="Libs\LibArtifactData-1.0\LibArtifactData-1.0.lua"/>
+  <Include file="Libs\LibQTip-1.0\LibQTip-1.0.lua"/>
 </Ui>

 <!--
diff --git a/modules/micromenu.lua b/modules/micromenu.lua
index 6a1bc5a..b9e1fa1 100644
--- a/modules/micromenu.lua
+++ b/modules/micromenu.lua
@@ -10,6 +10,7 @@ function MenuModule:GetName()
 end

 function MenuModule:OnInitialize()
+  self.LTip=LibStub('LibQTip-1.0')
   self.mediaFolder = xb.constants.mediaPath..'microbar\\'
   self.socialIconPath = "Interface\\FriendsFrame\\"
   self.icons = {}
@@ -327,10 +328,7 @@ function MenuModule:RegisterFrameEvents()
     elseif name == 'social' then
       local leaveFunc = self:DefaultLeave(name)
       frame:SetScript("OnEnter", self:SocialHover(self:DefaultHover(name)))
-      frame:SetScript("OnLeave", function()
-        GameTooltip:Hide()
-        leaveFunc()
-      end)
+      frame:SetScript("OnLeave", leaveFunc)
     else
       frame:SetScript("OnEnter", self:DefaultHover(name))
       frame:SetScript("OnLeave", self:DefaultLeave(name))
@@ -384,6 +382,8 @@ function MenuModule:DefaultHover(name)
     if InCombatLockdown() then return; end
     if self.icons[name] ~= nil then
       self.icons[name]:SetVertexColor(unpack(xb:HoverColors()))
+	  self.tipHover=(name=="social")
+	  self.gtipHover=(name=="guild")
     end
   end
 end
@@ -403,19 +403,27 @@ function MenuModule:SocialHover(hoverFunc)
       hoverFunc()
       return
     end
+	if self.LTip:IsAcquired("SocialToolTip") then
+		self.LTip:Release(self.LTip:Acquire("SocialToolTip"))
+	end
+	local tooltip = self.LTip:Acquire("SocialToolTip", 2, "LEFT", "RIGHT")
+	tooltip:EnableMouse(true)
+	tooltip:SetScript("OnEnter",function() self.tipHover=true end)
+	tooltip:SetScript("OnLeave",function() self.tipHover=false end)
+	tooltip:SetScript("OnUpdate",function() if not self.tipHover and not self.lineHover then tooltip:Release() end end)
     local totalBNFriends, totalBNOnlineFriends = BNGetNumFriends()
     local totalFriends, totalOnlineFriends = GetNumFriends()
-
+	local charNameFormat
     if (totalOnlineFriends + totalBNOnlineFriends) > 0 then
-      GameTooltip:SetOwner(MenuModule.frames.social, 'ANCHOR_'..xb.miniTextPosition)
-      GameTooltip:AddLine('[|cff6699FF'..SOCIAL_LABEL..'|r]')
-      GameTooltip:AddLine(' ')
+      tooltip:SmartAnchorTo(MenuModule.frames.social)
+      tooltip:AddHeader('[|cff6699FF'..SOCIAL_LABEL..'|r]')
+      tooltip:AddLine(' ',' ')
     end

     if totalBNOnlineFriends then

       for i = 1, BNGetNumFriends() do
-        local _, battleName, battleTag, _, charName, gameAccount, gameClient, isOnline, _, isAfk, isDnd, _, note = BNGetFriendInfo(i)
+        local battleID, battleName, battleTag, _, charName, gameAccount, gameClient, isOnline, _, isAfk, isDnd, _, note = BNGetFriendInfo(i)
         if isOnline then
           if not battleTag then
             battleTag = '['..L['No Tag']..']'
@@ -437,9 +445,9 @@ function MenuModule:SocialHover(hoverFunc)
           end

           if gameClient == BNET_CLIENT_WOW then
-            charName = "(|cffecd672"..charName.."-"..realmName.."|r)"
+            charNameFormat = "(|cffecd672"..charName.."-"..realmName.."|r)"
           else
-            charName = ''
+            charNameFormat = ''
           end

           if note ~= '' then
@@ -447,8 +455,25 @@ function MenuModule:SocialHover(hoverFunc)
           end

           local lineLeft = string.format("|T%s:16|t|cff82c5ff %s|r %s", statusIcon, battleName, note)
-          local lineRight = string.format("%s %s |T%s:16|t", charName, gameName, socialIcon)
-          GameTooltip:AddDoubleLine(lineLeft, lineRight)
+          local lineRight = string.format("%s %s |T%s:16|t", charNameFormat, gameName, socialIcon)
+          tooltip:AddLine(lineLeft, lineRight)
+		  tooltip:SetLineScript(tooltip:GetLineCount(),"OnEnter",function() self.lineHover = true;end)
+		  tooltip:SetLineScript(tooltip:GetLineCount(),"OnLeave",function() self.lineHover = false; end)
+		  tooltip:SetLineScript(tooltip:GetLineCount(),"OnMouseUp",function(self,_,button)
+		    if button == "LeftButton" then
+				if IsShiftKeyDown() then
+					if CanGroupWithAccount(battleID) then
+						InviteToGroup(charName.."-"..realmName)
+					end
+				else
+					local name = battleName
+					if charName then
+						name = charName.."-"..realmName
+					end
+					ChatFrame_OpenChat(SLASH_SMART_WHISPER1.." "..name.." ")
+				end
+			end
+		  end)
         end -- isOnline
       end -- for in BNGetNumFriends
     end -- totalBNOnlineFriends
@@ -470,13 +495,27 @@ function MenuModule:SocialHover(hoverFunc)

           local lineLeft = string.format("|T%s:16|t %s, "..LEVEL..":%s %s", statusIcon, name, level, class)
           local lineRight = string.format("%s", area)
-          GameTooltip:AddDoubleLine(lineLeft, lineRight)
+          tooltip:AddLine(lineLeft, lineRight)
+		  tooltip:SetLineScript(tooltip:GetLineCount(),"OnEnter",function() self.lineHover = true;end)
+		  tooltip:SetLineScript(tooltip:GetLineCount(),"OnLeave",function() self.lineHover = false; end)
+		  tooltip:SetLineScript(tooltip:GetLineCount(),"OnMouseUp",function(self,_,button)
+		    if button == "LeftButton" then
+				if IsShiftKeyDown() then
+					if not name:find('%u%U*-%u%U') then
+						local homeRealm = GetRealmName()
+						homeRealm = homeRealm:gsub("%s+", "")
+						name=name.."-"..homeRealm
+					end
+					InviteUnit(name)
+				end
+				ChatFrame_OpenChat(SLASH_SMART_WHISPER1.." "..name.." ")
+			end
+		  end)
         end -- isOnline
       end -- for in GetNumFriends
     end -- totalOnlineFriends
-
     if (totalOnlineFriends + totalBNOnlineFriends) > 0 then
-      GameTooltip:Show()
+      tooltip:Show()
     end
     hoverFunc()
   end
@@ -492,12 +531,22 @@ function MenuModule:GuildHover(hoverFunc)
       hoverFunc()
       return
     end
+
+	if self.LTip:IsAcquired("GuildToolTip") then
+		self.LTip:Release(self.LTip:Acquire("GuildToolTip"))
+	end
+	local tooltip = self.LTip:Acquire("GuildToolTip", 2, "LEFT","RIGHT")
+	tooltip:EnableMouse(true)
+	tooltip:SetScript("OnEnter",function() self.gtipHover=true end)
+	tooltip:SetScript("OnLeave",function() self.gtipHover=false end)
+	tooltip:SetScript("OnUpdate",function() if not self.gtipHover and not self.glineHover then tooltip:Release() end end)
+
     GuildRoster()
-    GameTooltip:SetOwner(MenuModule.frames.guild, 'ANCHOR_'..xb.miniTextPosition)
-    GameTooltip:AddLine("[|cff6699FF"..GUILD.."|r]")
-    GameTooltip:AddLine(" ")
+    tooltip:SmartAnchorTo(MenuModule.frames.guild)
+    tooltip:AddHeader("[|cff6699FF"..GUILD.."|r]")
+    tooltip:AddLine(" "," ")
     local gName, _, _, _ = GetGuildInfo('player')
-    GameTooltip:AddDoubleLine(GUILD..':', gName, 1, 1, 0, 0, 1, 0)
+    tooltip:AddLine('|cffff00ff'..GUILD..':|r', '|c00ff00ff'..gName..'|r')

     local totalGuild, _ = GetNumGuildMembers()
     for i = 0, totalGuild do
@@ -512,13 +561,29 @@ function MenuModule:GuildHover(hoverFunc)
           status = ''
         end
         local lineLeft = string.format('%s |c%s%s|r %s %s', level, colorHex, name, status, note)
-        local lineRight = string.format('%s|cffffffff %s', (isMobile and "|cffffff00[M]|r " or ""), zone or '')
-        GameTooltip:AddDoubleLine(lineLeft, lineRight)
+        local lineRight = string.format('%s|cffffffff %s', (isMobile and "|cffffffa0[M]|r " or ""), zone or '')
+        tooltip:AddLine(lineLeft, lineRight)
+		tooltip:SetLineScript(tooltip:GetLineCount(),"OnEnter",function() self.glineHover = true;end)
+		tooltip:SetLineScript(tooltip:GetLineCount(),"OnLeave",function() self.glineHover = false; end)
+		tooltip:SetLineScript(tooltip:GetLineCount(),"OnMouseUp",function(self,_,button)
+		    if button == "LeftButton" then
+				if IsShiftKeyDown() then
+					if not name:find('%u%U*-%u%U') then
+						local homeRealm = GetRealmName()
+						homeRealm = homeRealm:gsub("%s+", "")
+						name=name.."-"..homeRealm
+					end
+					InviteUnit(name)
+				else
+					ChatFrame_OpenChat(SLASH_SMART_WHISPER1.." "..name.." ")
+				end
+			end
+		  end)
       end
     end
-    GameTooltip:AddLine(' ')
-    GameTooltip:AddDoubleLine('<'..L['Left-Click']..'>', L['Open Guild Page'], 1, 1, 0, 1, 1, 1)
-    GameTooltip:Show()
+    --tooltip:AddLine(' ',' ')
+    --tooltip:AddLine('|cffff00ff<'..L['Left-Click']..'>|r', '|cffffffff'..L['Open Guild Page']..'|r', 1, 1, 0, 1, 1, 1)
+    tooltip:Show()
     hoverFunc()
   end
 end