diff --git a/QuestHelper/libs/AstrolabeQH/Astrolabe.lua b/QuestHelper/libs/AstrolabeQH/Astrolabe.lua
deleted file mode 100644
index e44f800..0000000
--- a/QuestHelper/libs/AstrolabeQH/Astrolabe.lua
+++ /dev/null
@@ -1,2060 +0,0 @@
---[[
-Name: AstrolabeQH
-Revision: $Rev: 92 $
-$Date: 2008-10-05 17:22:44 -0700 (Sun, 05 Oct 2008) $
-Author(s): Esamynn (esamynn at wowinterface.com), Zorba (see questhelper docs)
-Inspired By: Gatherer by Norganna
- MapLibrary by Kristofer Karlsson (krka at kth.se)
-Documentation: http://wiki.esamynn.org/Astrolabe
-SVN: http://svn.esamynn.org/astrolabe/
-Description:
- This is a library for the World of Warcraft UI system to place
- icons accurately on both the Minimap and on Worldmaps.
- This library also manages and updates the position of Minimap icons
- automatically.
-
- Modified to support Death Knight starting zone.
-
-Copyright (C) 2006-2008 James Carrothers
-
-License:
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-Note:
- This library's source code is specifically designed to work with
- World of Warcraft's interpreted AddOn system. You have an implicit
- licence to use this library with these facilities since that is its
- designated purpose as per:
- http://www.fsf.org/licensing/licenses/gpl-faq.html#InterpreterIncompat
-]]
-
-QuestHelper_File["AstrolabeQH/Astrolabe.lua"] = "4.0.1.$svnversion$"
-QuestHelper_Loadtime["AstrolabeQH/Astrolabe.lua"] = GetTime()
-
--- WARNING!!!
--- DO NOT MAKE CHANGES TO THIS LIBRARY WITHOUT FIRST CHANGING THE LIBRARY_VERSION_MAJOR
--- STRING (to something unique) OR ELSE YOU MAY BREAK OTHER ADDONS THAT USE THIS LIBRARY!!!
-local LIBRARY_VERSION_MAJOR = "Astrolabe-0.4-QuestHelper"
-local LIBRARY_VERSION_MINOR = 105 -- this is a completely randomly chosen number, the only point being that it was larger than the original 92 and larger than the later 100
-
-if not DongleStub then error(LIBRARY_VERSION_MAJOR .. " requires DongleStub.") end
-if not DongleStub:IsNewerVersion(LIBRARY_VERSION_MAJOR, LIBRARY_VERSION_MINOR) then return end
-
-local Astrolabe = {};
-
-local Minimap = _G.Minimap
-
--- define local variables for Data Tables (defined at the end of this file)
-local WorldMapSize, MinimapSize, ValidMinimapShapes, VirtualContinentIndexes;
-
-function Astrolabe:GetVersion()
- return LIBRARY_VERSION_MAJOR, LIBRARY_VERSION_MINOR;
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Config Constants
---------------------------------------------------------------------------------------------------------------
-
-local configConstants = {
- MinimapUpdateMultiplier = true,
-}
-
--- this constant is multiplied by the current framerate to determine
--- how many icons are updated each frame
-Astrolabe.MinimapUpdateMultiplier = 1;
-
-
---------------------------------------------------------------------------------------------------------------
--- Working Tables
---------------------------------------------------------------------------------------------------------------
-
-Astrolabe.LastPlayerPosition = { 0, 0, 0, 0 };
-Astrolabe.MinimapIcons = {};
-Astrolabe.IconsOnEdge = {};
-Astrolabe.IconsOnEdge_GroupChangeCallbacks = {};
-
-Astrolabe.MinimapIconCount = 0
-Astrolabe.ForceNextUpdate = false;
-Astrolabe.IconsOnEdgeChanged = false;
-
--- This variable indicates whether we know of a visible World Map or not.
--- The state of this variable is controlled by the AstrolabeMapMonitor library.
-Astrolabe.WorldMapVisible = false;
-
-local AddedOrUpdatedIcons = {}
-local MinimapIconsMetatable = { __index = AddedOrUpdatedIcons }
-
-
---------------------------------------------------------------------------------------------------------------
--- Local Pointers for often used API functions
---------------------------------------------------------------------------------------------------------------
-
-local twoPi = math.pi * 2;
-local atan2 = math.atan2;
-local sin = math.sin;
-local cos = math.cos;
-local abs = math.abs;
-local sqrt = math.sqrt;
-local min = math.min
-local max = math.max
-local yield = coroutine.yield
-local GetFramerate = GetFramerate
-
-
---------------------------------------------------------------------------------------------------------------
--- Internal Utility Functions
---------------------------------------------------------------------------------------------------------------
-
-local function assert(level,condition,message)
- if not condition then
- error(message,level)
- end
-end
-
-local function argcheck(value, num, ...)
- assert(1, type(num) == "number", "Bad argument #2 to 'argcheck' (number expected, got " .. type(level) .. ")")
-
- for i=1,select("#", ...) do
- if type(value) == select(i, ...) then return end
- end
-
- local types = strjoin(", ", ...)
- local name = string.match(debugstack(2,2,0), ": in function [`<](.-)['>]")
- error(string.format("Bad argument #%d to 'Astrolabe.%s' (%s expected, got %s)", num, name, types, type(value)), 3)
-end
-
-local function getContPosition( zoneData, z, x, y )
- if ( z ~= 0 ) then
- zoneData = zoneData[z];
- if not zoneData then return end
- x = x * zoneData.width + zoneData.xOffset;
- y = y * zoneData.height + zoneData.yOffset;
- else
- x = x * zoneData.width;
- y = y * zoneData.height;
- end
- return x, y;
-end
-
---------------------------------------------------------------------------------------------------------------
--- Virtual Continent Functions
---------------------------------------------------------------------------------------------------------------
-
-function Astrolabe:GetCurrentVirtualMapCZ()
- local C, Z = GetCurrentMapContinent(), GetCurrentMapZone();
- if C == -1 and Z == 0 then
- -- welllllp
- local mapname = GetMapInfo()
- if mapname == "Gilneas" then mapname = "GilneasZone" end -- We created a name conflict by remapping Ruins of Gilneas City. So... we resolve by remapping again.
- if VirtualContinentIndexes[mapname] and GetCurrentMapDungeonLevel() == 0 then
- C = VirtualContinentIndexes[mapname]
- Z = 1
- elseif mapname and VirtualContinentIndexes[mapname .. GetCurrentMapDungeonLevel()] then
- C = VirtualContinentIndexes[mapname .. GetCurrentMapDungeonLevel()]
- Z = 1
- elseif mapname == "CoTStratholme" and GetCurrentMapDungeonLevel() == 0 then
- -- why do you gotta make me angry, baby
- C = VirtualContinentIndexes["CoTStratholme2"]
- Z = 1
- end
- end
- return C, Z
-end
-
-function Astrolabe:GetCurrentVirtualMapContinent() local C, Z = self:GetCurrentVirtualMapCZ() return C end
-function Astrolabe:GetCurrentVirtualMapZone() local C, Z = self:GetCurrentVirtualMapCZ() return Z end
-
--- Does much the same as GetMapContinents, but returns as an array and includes the virtual continents in the mix
-function Astrolabe:GetMapVirtualContinents()
- local rv = {GetMapContinents()}
- rv[5] = rv[5] .. " Continent"
- for k, v in pairs(VirtualContinentIndexes) do
- rv[v] = k .. "_Continent"
- end
- return rv
-end
-
--- Does much the same as GetMapContinents, but returns as an array and includes the virtual continents in the mix
-function Astrolabe:GetMapVirtualZones(zone)
- for k, v in pairs(VirtualContinentIndexes) do
- if v == zone then
- return {[1] = k}
- end
- end
- local curMapID = GetCurrentMapAreaID()
- local zones = {GetMapZones(zone)}
-
- for k, v in pairs(zones) do
- SetMapZoom(zone, k)
- local mapFileName = GetMapInfo()
- if mapFileName == "RuinsofGilneasCity" then
- zones[k] = "Gilneas"
- break
- end
- end
-
- SetMapByID(curMapID)
- return zones
-end
-
-function Astrolabe:GetMapTexture(c, z)
- for k, v in pairs(VirtualContinentIndexes) do
- if v == c and z == 0 then
- return k .. "_Continent"
- elseif v == c and z == 1 then
- return k
- end
- end
-
- SetMapZoom(c, z)
- return (GetMapInfo())
-end
-
---------------------------------------------------------------------------------------------------------------
--- General Utility Functions
---------------------------------------------------------------------------------------------------------------
-
-function Astrolabe:ComputeDistance( c1, z1, x1, y1, c2, z2, x2, y2 )
- QuestHelper: Assert(c1 and z1 and x1 and y1 and c2 and z2 and x2 and y2)
- --[[
- argcheck(c1, 2, "number");
- assert(3, c1 >= 0, "ComputeDistance: Illegal continent index to c1: "..c1);
- argcheck(z1, 3, "number", "nil");
- argcheck(x1, 4, "number");
- argcheck(y1, 5, "number");
- argcheck(c2, 6, "number");
- assert(3, c2 >= 0, "ComputeDistance: Illegal continent index to c2: "..c2);
- argcheck(z2, 7, "number", "nil");
- argcheck(x2, 8, "number");
- argcheck(y2, 9, "number");
- --]]
-
- z1 = z1 or 0;
- z2 = z2 or 0;
-
- local dist, xDelta, yDelta;
- if ( c1 == c2 and z1 == z2 ) then
- -- points in the same zone
- local zoneData = WorldMapSize[c1];
- if ( z1 ~= 0 ) then
- zoneData = zoneData[z1];
- end
- xDelta = (x2 - x1) * zoneData.width;
- yDelta = (y2 - y1) * zoneData.height;
-
- elseif ( c1 == c2 ) then
- -- points on the same continent
- local zoneData = WorldMapSize[c1];
- x1, y1 = getContPosition(zoneData, z1, x1, y1);
- x2, y2 = getContPosition(zoneData, z2, x2, y2);
- xDelta = (x2 - x1);
- yDelta = (y2 - y1);
-
- elseif ( c1 and c2 ) then
- local cont1 = WorldMapSize[c1];
- local cont2 = WorldMapSize[c2];
- if ( cont1.parentContinent == cont2.parentContinent ) then
- x1, y1 = getContPosition(cont1, z1, x1, y1);
- x2, y2 = getContPosition(cont2, z2, x2, y2);
- if ( c1 ~= cont1.parentContinent ) then
- x1 = x1 + cont1.xOffset;
- y1 = y1 + cont1.yOffset;
- end
- if ( c2 ~= cont2.parentContinent ) then
- x2 = x2 + cont2.xOffset;
- y2 = y2 + cont2.yOffset;
- end
-
- xDelta = x2 - x1;
- yDelta = y2 - y1;
- end
-
- end
- if ( xDelta and yDelta ) then
- dist = sqrt(xDelta*xDelta + yDelta*yDelta);
- end
- return dist, xDelta, yDelta;
-end
-
-local yards
-
-function Astrolabe:TranslateWorldMapPosition( C, Z, xPos, yPos, nC, nZ )
- --[[
- argcheck(C, 2, "number");
- argcheck(Z, 3, "number", "nil");
- argcheck(xPos, 4, "number");
- argcheck(yPos, 5, "number");
- argcheck(nC, 6, "number");
- argcheck(nZ, 7, "number", "nil");
- --]]
-
- Z = Z or 0;
- nZ = nZ or 0;
- if ( nC < 0 and nC > -77 ) then
- --if ( nC < 0 and nC > -79 ) then
- return;
- end
-
- local zoneData;
- if ( C == nC and Z == nZ ) then
- return xPos, yPos;
-
- elseif ( C == nC ) then
- -- points on the same continent
- zoneData = WorldMapSize[C];
- xPos, yPos = getContPosition(zoneData, Z, xPos, yPos);
- if ( nZ ~= 0 ) then
- zoneData = WorldMapSize[C][nZ];
- xPos = xPos - zoneData.xOffset;
- yPos = yPos - zoneData.yOffset;
- end
-
- elseif ( C and nC ) and ( WorldMapSize[C].parentContinent == WorldMapSize[nC].parentContinent ) then
- -- different continents, same world
- zoneData = WorldMapSize[C];
- local parentContinent = zoneData.parentContinent;
- xPos, yPos = getContPosition(zoneData, Z, xPos, yPos);
- if not xPos or not yPos then return end -- there is no such zone. why are you asking me such silly things? you are a terrible person. leave me in my despair.
- if ( C ~= parentContinent ) then
- -- translate up to world map if we aren't there already
- xPos = xPos + zoneData.xOffset;
- yPos = yPos + zoneData.yOffset;
- zoneData = WorldMapSize[parentContinent];
- end
- if ( nC ~= parentContinent ) then
- -- translate down to the new continent
- zoneData = WorldMapSize[nC];
- xPos = xPos - zoneData.xOffset;
- yPos = yPos - zoneData.yOffset;
- if ( nZ ~= 0 ) then
- zoneData = zoneData[nZ];
- xPos = xPos - zoneData.xOffset;
- yPos = yPos - zoneData.yOffset;
- end
- end
-
- else
- return;
- end
-
- return (xPos / zoneData.width), (yPos / zoneData.height);
-end
-
-function Astrolabe:GetAbsoluteContinentPosition( C, Z, xPos, yPos )
- if C == -1 then -- We're in a battleground that doesn't have a virtual continent, we're just kind of fucked.
- return
- end
-
- if C == 6 then return end -- We're in Pandaria, we're just kind of fucked for now.
-
- assert(0, type(WorldMapSize[C].parentContinent) == "number")
-
- local x, y = Astrolabe:TranslateWorldMapPosition(C, Z, xPos, yPos, WorldMapSize[C].parentContinent, 0)
- if not x or not y then return end
- local zoneData = WorldMapSize[WorldMapSize[C].parentContinent]
- return WorldMapSize[C].parentContinent, (x * zoneData.width), (y * zoneData.height)
-end
-
-function Astrolabe:FromAbsoluteContinentPosition(C, xPos, yPos)
- QuestHelper: Assert(C and xPos and yPos, "One of the arguments is nil. " .. tostring(C) .. " " .. tostring(xPos) .. " " .. tostring(yPos))
- QuestHelper: Assert(WorldMapSize[C], string.format("WorldMapSize[%d] is nil.", C))
- QuestHelper: Assert(WorldMapSize[C].width and WorldMapSize[C].height, string.format("WorldMapSize[%d] is missing one or more of its dimensions.", C))
- return C, 0, xPos / WorldMapSize[C].width, yPos / WorldMapSize[C].height
-end
-
-function Astrolabe:GetZoneWidth(c, z)
- if z ~= 0 then
- return WorldMapSize[c][z].width
- else
- return WorldMapSize[c].width
- end
-end
-
-function Astrolabe:GetZoneHeight(c, z)
- if z ~= 0 then
- return WorldMapSize[c][z].height
- else
- return WorldMapSize[c].height
- end
-end
-
---*****************************************************************************
--- This function will do its utmost to retrieve some sort of valid position
--- for the specified unit, including changing the current map zoom (if needed).
--- Map Zoom is returned to its previous setting before this function returns.
---*****************************************************************************
-function Astrolabe:GetUnitPosition( unit, noMapChange )
- local x, y = GetPlayerMapPosition(unit);
- if ( x <= 0 and y <= 0 ) then
- if ( noMapChange ) then
- -- no valid position on the current map, and we aren't allowed
- -- to change map zoom, so return
- return;
- end
- local lastCont, lastZone = GetCurrentMapContinent(), GetCurrentMapZone();
- SetMapToCurrentZone();
- x, y = GetPlayerMapPosition(unit);
- if ( x <= 0 and y <= 0 ) then
- SetMapZoom(GetCurrentMapContinent());
- x, y = GetPlayerMapPosition(unit);
- if ( x <= 0 and y <= 0 ) then
- -- we are in an instance or otherwise off the continent map
- return;
- end
- end
- local C, Z = GetCurrentMapContinent(), GetCurrentMapZone();
- if ( C ~= lastCont or Z ~= lastZone ) then
- SetMapZoom(lastCont, lastZone); -- set map zoom back to what it was before
- end
- return C, Z, x, y;
- end
- return self:GetCurrentVirtualMapContinent(), self:GetCurrentVirtualMapZone(), x, y;
-end
-
---*****************************************************************************
--- This function will do its utmost to retrieve some sort of valid position
--- for the specified unit, including changing the current map zoom (if needed).
--- However, if a monitored WorldMapFrame (See AstrolabeMapMonitor.lua) is
--- visible, then will simply return nil if the current zoom does not provide
--- a valid position for the player unit. Map Zoom is returned to its previous
--- setting before this function returns, if it was changed.
---*****************************************************************************
-function Astrolabe:GetCurrentPlayerPosition()
- local x, y = GetPlayerMapPosition("player");
- if ( x <= 0 and y <= 0 ) then
- if ( self.WorldMapVisible ) then
- -- we know there is a visible world map, so don't cause
- -- WORLD_MAP_UPDATE events by changing map zoom
- return;
- end
- local lastCont, lastZone = GetCurrentMapContinent(), GetCurrentMapZone();
- SetMapToCurrentZone();
- x, y = GetPlayerMapPosition("player");
- if ( x <= 0 and y <= 0 ) then
- SetMapZoom(GetCurrentMapContinent());
- x, y = GetPlayerMapPosition("player");
- if ( x <= 0 and y <= 0 ) then
- -- we are in an instance or otherwise off the continent map
- return;
- end
- end
- local C, Z = GetCurrentMapContinent(), GetCurrentMapZone();
-
- if ( C ~= lastCont or Z ~= lastZone ) then
- SetMapZoom(lastCont, lastZone); --set map zoom back to what it was before
- end
- return C, Z, x, y;
- end
-
- return self:GetCurrentVirtualMapContinent(), self:GetCurrentVirtualMapZone(), x, y;
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Working Table Cache System
---------------------------------------------------------------------------------------------------------------
-
-local tableCache = {};
-tableCache["__mode"] = "v";
-setmetatable(tableCache, tableCache);
-
-local function GetWorkingTable( icon )
- if ( tableCache[icon] ) then
- return tableCache[icon];
- else
- local T = {};
- tableCache[icon] = T;
- return T;
- end
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Minimap Icon Placement
---------------------------------------------------------------------------------------------------------------
-
---*****************************************************************************
--- local variables specifically for use in this section
---*****************************************************************************
-local minimapRotationEnabled = false;
-local minimapShape = false;
-
-local MinimapCompassTexture = MinimapCompassTexture;
-local MinimapCompassRing = MiniMapCompassRing;
-function Astrolabe:GetFacing()
- if MinimapCompassRing then -- 3.1 hackery
- return MinimapCompassRing:GetFacing()
- else
- return -GetPlayerFacing()
- end
-end
-local minimapRotationOffset = -Astrolabe.GetFacing()
-
-function Astrolabe:GetMapDiameter()
- local minimapZoom = Minimap:GetZoom()
- if ( Astrolabe.minimapOutside ) then
- return MinimapSize.outdoor[minimapZoom];
- else
- return MinimapSize.indoor[minimapZoom];
- end
-end
-
-local function placeIconOnMinimap( minimap, minimapZoom, mapWidth, mapHeight, icon, dist, xDist, yDist )
- local mapDiameter;
- if ( Astrolabe.minimapOutside ) then
- mapDiameter = MinimapSize.outdoor[minimapZoom];
- else
- mapDiameter = MinimapSize.indoor[minimapZoom];
- end
- local mapRadius = mapDiameter / 2;
- local xScale = mapDiameter / mapWidth;
- local yScale = mapDiameter / mapHeight;
- local iconDiameter = ((icon:GetWidth() / 2) + 3) * xScale;
- local iconOnEdge = nil;
- local isRound = true;
-
- if ( minimapRotationEnabled ) then
- local sinTheta = sin(minimapRotationOffset)
- local cosTheta = cos(minimapRotationOffset)
- --[[
- Math Note
- The math that is acutally going on in the next 3 lines is:
- local dx, dy = xDist, -yDist
- xDist = (dx * cosTheta) + (dy * sinTheta)
- yDist = -((-dx * sinTheta) + (dy * cosTheta))
-
- This is because the origin for map coordinates is the top left corner
- of the map, not the bottom left, and so we have to reverse the vertical
- distance when doing the our rotation, and then reverse the result vertical
- distance because this rotation formula gives us a result with the origin based
- in the bottom left corner (of the (+, +) quadrant).
- The actual code is a simplification of the above.
- ]]
- local dx, dy = xDist, yDist
- xDist = (dx * cosTheta) - (dy * sinTheta)
- yDist = (dx * sinTheta) + (dy * cosTheta)
- end
-
- if ( minimapShape and not (xDist == 0 or yDist == 0) ) then
- isRound = (xDist < 0) and 1 or 3;
- if ( yDist < 0 ) then
- isRound = minimapShape[isRound];
- else
- isRound = minimapShape[isRound + 1];
- end
- end
-
- -- for non-circular portions of the Minimap edge
- if not ( isRound ) then
- dist = max(abs(xDist), abs(yDist))
- end
-
- if ( (dist + iconDiameter) > mapRadius ) then
- -- position along the outside of the Minimap
- iconOnEdge = true;
- local factor = (mapRadius - iconDiameter) / dist;
- xDist = xDist * factor;
- yDist = yDist * factor;
- end
-
- if ( Astrolabe.IconsOnEdge[icon] ~= iconOnEdge ) then
- Astrolabe.IconsOnEdge[icon] = iconOnEdge;
- Astrolabe.IconsOnEdgeChanged = true;
- end
-
- icon:ClearAllPoints();
- icon:SetPoint("CENTER", minimap, "CENTER", xDist/xScale, -yDist/yScale);
-end
-
-function Astrolabe:PlaceIconOnMinimap( icon, continent, zone, xPos, yPos )
- -- check argument types
- argcheck(icon, 2, "table");
- assert(3, icon.SetPoint and icon.ClearAllPoints, "Usage Message");
- argcheck(continent, 3, "number");
- argcheck(zone, 4, "number", "nil");
- argcheck(xPos, 5, "number");
- argcheck(yPos, 6, "number");
-
- local lC, lZ, lx, ly = unpack(self.LastPlayerPosition);
- local dist, xDist, yDist = self:ComputeDistance(lC, lZ, lx, ly, continent, zone, xPos, yPos);
- if not ( dist ) then
- --icon's position has no meaningful position relative to the player's current location
- return -1;
- end
-
- local iconData = GetWorkingTable(icon);
- if ( self.MinimapIcons[icon] ) then
- self.MinimapIcons[icon] = nil;
- else
- self.MinimapIconCount = self.MinimapIconCount + 1
- end
-
- -- We know this icon's position is valid, so we need to make sure the icon placement
- -- system is active. We call this here so that if this is the first icon being added to
- -- an empty buffer, the full recalc will not completely redo the work done by this function
- -- because the icon has not yet actually been placed in the buffer.
- self.processingFrame:Show()
-
- AddedOrUpdatedIcons[icon] = iconData
- iconData.continent = continent;
- iconData.zone = zone;
- iconData.xPos = xPos;
- iconData.yPos = yPos;
- iconData.dist = dist;
- iconData.xDist = xDist;
- iconData.yDist = yDist;
-
- minimapRotationEnabled = GetCVar("rotateMinimap") ~= "0"
- if ( minimapRotationEnabled ) then
- minimapRotationOffset = -Astrolabe.GetFacing()
- end
-
- -- check Minimap Shape
- minimapShape = GetMinimapShape and ValidMinimapShapes[GetMinimapShape()];
-
- -- place the icon on the Minimap and :Show() it
- local map = Minimap
- placeIconOnMinimap(map, map:GetZoom(), map:GetWidth(), map:GetHeight(), icon, dist, xDist, yDist);
- icon:Show()
-
- return 0;
-end
-
-function Astrolabe:RemoveIconFromMinimap( icon )
- if not ( self.MinimapIcons[icon] ) then
- return 1;
- end
- AddedOrUpdatedIcons[icon] = nil
- self.MinimapIcons[icon] = nil;
- self.IconsOnEdge[icon] = nil;
- icon:Hide();
-
- local MinimapIconCount = self.MinimapIconCount - 1
- if ( MinimapIconCount <= 0 ) then
- -- no icons left to manage
- self.processingFrame:Hide()
- MinimapIconCount = 0 -- because I'm paranoid
- end
- self.MinimapIconCount = MinimapIconCount
-
- return 0;
-end
-
-function Astrolabe:RemoveAllMinimapIcons()
- self:DumpNewIconsCache()
- local MinimapIcons = self.MinimapIcons;
- local IconsOnEdge = self.IconsOnEdge;
- for k, v in pairs(MinimapIcons) do
- MinimapIcons[k] = nil;
- IconsOnEdge[k] = nil;
- k:Hide();
- end
- self.MinimapIconCount = 0
- self.processingFrame:Hide()
-end
-
-local lastZoom; -- to remember the last seen Minimap zoom level
-
--- local variables to track the status of the two update coroutines
-local fullUpdateInProgress = true
-local resetIncrementalUpdate = false
-local resetFullUpdate = false
-
--- Incremental Update Code
-do
- -- local variables to track the incremental update coroutine
- local incrementalUpdateCrashed = true
- local incrementalUpdateThread
-
- local function UpdateMinimapIconPositions( self )
- yield()
-
- while ( true ) do
- self:DumpNewIconsCache() -- put new/updated icons into the main datacache
-
- resetIncrementalUpdate = false -- by definition, the incremental update is reset if it is here
-
- local C, Z, x, y = self:GetCurrentPlayerPosition();
- if ( C and C ~= -1 ) then
- local lastPosition = self.LastPlayerPosition;
- local lC, lZ, lx, ly = unpack(lastPosition);
-
- minimapRotationEnabled = GetCVar("rotateMinimap") ~= "0"
- if ( minimapRotationEnabled ) then
- minimapRotationOffset = -Astrolabe.GetFacing()
- end
-
- -- check current frame rate
- local numPerCycle = min(50, GetFramerate() * (self.MinimapUpdateMultiplier or 1))
-
- -- check Minimap Shape
- minimapShape = GetMinimapShape and ValidMinimapShapes[GetMinimapShape()];
-
- if ( lC == C and lZ == Z and lx == x and ly == y ) then
- -- player has not moved since the last update
- if ( lastZoom ~= Minimap:GetZoom() or self.ForceNextUpdate or minimapRotationEnabled ) then
- local currentZoom = Minimap:GetZoom();
- lastZoom = currentZoom;
- local mapWidth = Minimap:GetWidth();
- local mapHeight = Minimap:GetHeight();
- numPerCycle = numPerCycle * 2
- local count = 0
- for icon, data in pairs(self.MinimapIcons) do
- placeIconOnMinimap(Minimap, currentZoom, mapWidth, mapHeight, icon, data.dist, data.xDist, data.yDist);
-
- count = count + 1
- if ( count > numPerCycle ) then
- count = 0
- yield()
- -- check if the incremental update cycle needs to be reset
- -- because a full update has been run
- if ( resetIncrementalUpdate ) then
- break;
- end
- end
- end
- self.ForceNextUpdate = false;
- end
- else
- local dist, xDelta, yDelta = self:ComputeDistance(lC, lZ, lx, ly, C, Z, x, y);
- if ( dist ) then
- local currentZoom = Minimap:GetZoom();
- lastZoom = currentZoom;
- local mapWidth = Minimap:GetWidth();
- local mapHeight = Minimap:GetHeight();
- local count = 0
- for icon, data in pairs(self.MinimapIcons) do
- local xDist = data.xDist - xDelta;
- local yDist = data.yDist - yDelta;
- local dist = sqrt(xDist*xDist + yDist*yDist);
- placeIconOnMinimap(Minimap, currentZoom, mapWidth, mapHeight, icon, dist, xDist, yDist);
-
- data.dist = dist;
- data.xDist = xDist;
- data.yDist = yDist;
-
- count = count + 1
- if ( count >= numPerCycle ) then
- count = 0
- yield()
- -- check if the incremental update cycle needs to be reset
- -- because a full update has been run
- if ( resetIncrementalUpdate ) then
- break;
- end
- end
- end
- if not ( resetIncrementalUpdate ) then
- lastPosition[1] = C;
- lastPosition[2] = Z;
- lastPosition[3] = x;
- lastPosition[4] = y;
- end
- else
- self:RemoveAllMinimapIcons()
- lastPosition[1] = C;
- lastPosition[2] = Z;
- lastPosition[3] = x;
- lastPosition[4] = y;
- end
- end
- else
- if not ( self.WorldMapVisible ) then
- self.processingFrame:Hide();
- end
- end
-
- -- if we've been reset, then we want to start the new cycle immediately
- if not ( resetIncrementalUpdate ) then
- yield()
- end
- end
- end
-
- function Astrolabe:UpdateMinimapIconPositions()
- if ( fullUpdateInProgress ) then
- -- if we're in the middle a a full update, we want to finish that first
- self:CalculateMinimapIconPositions()
- else
- if ( incrementalUpdateCrashed ) then
- incrementalUpdateThread = coroutine.wrap(UpdateMinimapIconPositions)
- incrementalUpdateThread(self) --initialize the thread
- end
- incrementalUpdateCrashed = true
- incrementalUpdateThread()
- incrementalUpdateCrashed = false
- end
- end
-end
-
--- Full Update Code
-do
- -- local variables to track the full update coroutine
- local fullUpdateCrashed = true
- local fullUpdateThread
-
- local function CalculateMinimapIconPositions( self )
- yield()
-
- while ( true ) do
- self:DumpNewIconsCache() -- put new/updated icons into the main datacache
-
- resetFullUpdate = false -- by definition, the full update is reset if it is here
-
- fullUpdateInProgress = true -- set the flag the says a full update is in progress
-
- local C, Z, x, y = self:GetCurrentPlayerPosition();
- if ( C and C ~= -1 ) then
- minimapRotationEnabled = GetCVar("rotateMinimap") ~= "0"
- if ( minimapRotationEnabled ) then
- minimapRotationOffset = Astrolabe.GetFacing()
- end
-
- -- check current frame rate
- local numPerCycle = GetFramerate() * (self.MinimapUpdateMultiplier or 1) * 2
-
- -- check Minimap Shape
- minimapShape = GetMinimapShape and ValidMinimapShapes[GetMinimapShape()];
-
- local currentZoom = Minimap:GetZoom();
- lastZoom = currentZoom;
- local mapWidth = Minimap:GetWidth();
- local mapHeight = Minimap:GetHeight();
- local count = 0
- for icon, data in pairs(self.MinimapIcons) do
- local dist, xDist, yDist = self:ComputeDistance(C, Z, x, y, data.continent, data.zone, data.xPos, data.yPos);
- if ( dist ) then
- placeIconOnMinimap(Minimap, currentZoom, mapWidth, mapHeight, icon, dist, xDist, yDist);
-
- data.dist = dist;
- data.xDist = xDist;
- data.yDist = yDist;
- else
- self:RemoveIconFromMinimap(icon)
- end
-
- count = count + 1
- if ( count >= numPerCycle ) then
- count = 0
- yield()
- -- check if we need to restart due to the full update being reset
- if ( resetFullUpdate ) then
- break;
- end
- end
- end
-
- if not ( resetFullUpdate ) then
- local lastPosition = self.LastPlayerPosition;
- lastPosition[1] = C;
- lastPosition[2] = Z;
- lastPosition[3] = x;
- lastPosition[4] = y;
-
- resetIncrementalUpdate = true
- end
- else
- if not ( self.WorldMapVisible ) then
- self.processingFrame:Hide();
- end
- end
-
- -- if we've been reset, then we want to start the new cycle immediately
- if not ( resetFullUpdate ) then
- fullUpdateInProgress = false
- yield()
- end
- end
- end
-
- function Astrolabe:CalculateMinimapIconPositions( reset )
- if ( fullUpdateCrashed ) then
- fullUpdateThread = coroutine.wrap(CalculateMinimapIconPositions)
- fullUpdateThread(self) --initialize the thread
- elseif ( reset ) then
- resetFullUpdate = true
- end
- fullUpdateCrashed = true
- fullUpdateThread()
- fullUpdateCrashed = false
-
- -- return result flag
- if ( fullUpdateInProgress ) then
- return 1 -- full update started, but did not complete on this cycle
-
- else
- if ( resetIncrementalUpdate ) then
- return 0 -- update completed
- else
- return -1 -- full update did no occur for some reason
- end
-
- end
- end
-end
-
-function Astrolabe:GetDistanceToIcon( icon )
- local data = self.MinimapIcons[icon];
- if ( data ) then
- return data.dist, data.xDist, data.yDist;
- end
-end
-
-function Astrolabe:IsIconOnEdge( icon )
- return self.IconsOnEdge[icon];
-end
-
-function Astrolabe:GetDirectionToIcon( icon )
- local data = self.MinimapIcons[icon];
- if ( data ) then
- local dir = atan2(data.xDist, -(data.yDist))
- if ( dir > 0 ) then
- return twoPi - dir;
- else
- return -dir;
- end
- end
-end
-
-function Astrolabe:Register_OnEdgeChanged_Callback( func, ident )
- -- check argument types
- argcheck(func, 2, "function");
-
- self.IconsOnEdge_GroupChangeCallbacks[func] = ident;
-end
-
---*****************************************************************************
--- INTERNAL USE ONLY PLEASE!!!
--- Calling this function at the wrong time can cause errors
---*****************************************************************************
-function Astrolabe:DumpNewIconsCache()
- local MinimapIcons = self.MinimapIcons
- for icon, data in pairs(AddedOrUpdatedIcons) do
- MinimapIcons[icon] = data
- AddedOrUpdatedIcons[icon] = nil
- end
- -- we now need to restart any updates that were in progress
- resetIncrementalUpdate = true
- resetFullUpdate = true
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- World Map Icon Placement
---------------------------------------------------------------------------------------------------------------
-
-function Astrolabe:PlaceIconOnWorldMap( worldMapFrame, icon, continent, zone, xPos, yPos )
- -- check argument types
- argcheck(worldMapFrame, 2, "table");
- assert(3, worldMapFrame.GetWidth and worldMapFrame.GetHeight, "Usage Message");
- argcheck(icon, 3, "table");
- assert(3, icon.SetPoint and icon.ClearAllPoints, "Usage Message");
- argcheck(continent, 4, "number");
- argcheck(zone, 5, "number", "nil");
- argcheck(xPos, 6, "number");
- argcheck(yPos, 7, "number");
-
- local C, Z = self:GetCurrentVirtualMapCZ();
- local nX, nY = self:TranslateWorldMapPosition(continent, zone, xPos, yPos, C, Z);
-
- -- anchor and :Show() the icon if it is within the boundry of the current map, :Hide() it otherwise
- if ( nX and nY and (0 < nX and nX <= 1) and (0 < nY and nY <= 1) ) then
- icon:ClearAllPoints();
- icon:SetPoint("CENTER", worldMapFrame, "TOPLEFT", nX * worldMapFrame:GetWidth(), -nY * worldMapFrame:GetHeight());
- icon:Show();
- else
- icon:Hide();
- end
- return nX, nY;
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Handler Scripts
---------------------------------------------------------------------------------------------------------------
-
-function Astrolabe:OnEvent( frame, event )
- if ( event == "MINIMAP_UPDATE_ZOOM" ) then
- -- update minimap zoom scale
- local curZoom = Minimap:GetZoom();
- if ( GetCVar("minimapZoom") == GetCVar("minimapInsideZoom") ) then
- if ( curZoom < 2 ) then
- Minimap:SetZoom(curZoom + 1);
- else
- Minimap:SetZoom(curZoom - 1);
- end
- end
- if ( GetCVar("minimapZoom")+0 == Minimap:GetZoom() ) then
- self.minimapOutside = true;
- else
- self.minimapOutside = false;
- end
- Minimap:SetZoom(curZoom);
-
- -- re-calculate all Minimap Icon positions
- if ( frame:IsVisible() ) then
- self:CalculateMinimapIconPositions(true);
- end
-
- elseif ( event == "PLAYER_LEAVING_WORLD" ) then
- frame:Hide(); -- yes, I know this is redunant
- self:RemoveAllMinimapIcons(); --dump all minimap icons
-
- elseif ( event == "PLAYER_ENTERING_WORLD" ) then
- frame:Show();
- if not ( frame:IsVisible() ) then
- -- do the minimap recalculation anyways if the OnShow script didn't execute
- -- this is done to ensure the accuracy of information about icons that were
- -- inserted while the Player was in the process of zoning
- self:CalculateMinimapIconPositions(true);
- end
-
- elseif ( event == "ZONE_CHANGED_NEW_AREA" ) then
- frame:Hide();
- frame:Show();
-
- end
-end
-
-function Astrolabe:OnUpdate( frame, elapsed )
- -- on-edge group changed call-backs
- if ( self.IconsOnEdgeChanged ) then
- self.IconsOnEdgeChanged = false;
- for func in pairs(self.IconsOnEdge_GroupChangeCallbacks) do
- pcall(func);
- end
- end
-
- self:UpdateMinimapIconPositions();
-end
-
-function Astrolabe:OnShow( frame )
- -- set the world map to a zoom with a valid player position
- if not ( self.WorldMapVisible ) then
- SetMapToCurrentZone();
- end
- local C, Z = Astrolabe:GetCurrentPlayerPosition();
- if ( C and C ~= -1 ) then
- if C >= 0 then -- If we're in Wackyland, we can't change the world map anyway, so at least it's probably right
- SetMapZoom(C, Z);
- end
- else
- frame:Hide();
- return
- end
-
- -- re-calculate minimap icon positions
- self:CalculateMinimapIconPositions(true);
-
- if ( self.MinimapIconCount <= 0 ) then
- -- no icons left to manage
- self.processingFrame:Hide()
- end
-end
-
--- called by AstrolabMapMonitor when all world maps are hidden
-function Astrolabe:AllWorldMapsHidden()
- if ( IsLoggedIn() ) then
- self.processingFrame:Hide();
- self.processingFrame:Show();
- end
-end
-
-function Astrolabe:SetMinimapObject(minimap)
- Minimap = minimap
- self:UpdateMinimapIconPositions()
-end
-function Astrolabe:GetMinimapObject()
- return Minimap
-end
-
---------------------------------------------------------------------------------------------------------------
--- Library Registration
---------------------------------------------------------------------------------------------------------------
-
-local function activate( newInstance, oldInstance )
- if ( oldInstance ) then -- this is an upgrade activate
- if ( oldInstance.DumpNewIconsCache ) then
- oldInstance:DumpNewIconsCache()
- end
- for k, v in pairs(oldInstance) do
- if ( type(v) ~= "function" and (not configConstants[k]) ) then
- newInstance[k] = v;
- end
- end
- -- sync up the current MinimapIconCount value
- local iconCount = 0
- for _ in pairs(newInstance.MinimapIcons) do
- iconCount = iconCount + 1
- end
- newInstance.MinimapIconCount = iconCount
-
- Astrolabe = oldInstance;
- else
- local frame = CreateFrame("Frame");
- newInstance.processingFrame = frame;
-
- newInstance.ContinentList = Astrolabe:GetMapVirtualContinents();
-
- for C in pairs(newInstance.ContinentList) do
- local zones = Astrolabe:GetMapVirtualZones(C);
- newInstance.ContinentList[C] = zones;
- for Z in ipairs(zones) do
- zones[Z] = Astrolabe:GetMapTexture(C, Z);
- end
- end
- end
- configConstants = nil -- we don't need this anymore
-
- local frame = newInstance.processingFrame;
- frame:Hide();
- frame:SetParent("Minimap");
- frame:UnregisterAllEvents();
- frame:RegisterEvent("MINIMAP_UPDATE_ZOOM");
- frame:RegisterEvent("PLAYER_LEAVING_WORLD");
- frame:RegisterEvent("PLAYER_ENTERING_WORLD");
- frame:RegisterEvent("ZONE_CHANGED_NEW_AREA");
- frame:SetScript("OnEvent",
- function( frame, event, ... )
- Astrolabe:OnEvent(frame, event, ...);
- end
- );
- frame:SetScript("OnUpdate",
- function( frame, elapsed )
- Astrolabe:OnUpdate(frame, elapsed);
- end
- );
- frame:SetScript("OnShow",
- function( frame )
- Astrolabe:OnShow(frame);
- end
- );
-
- setmetatable(Astrolabe.MinimapIcons, MinimapIconsMetatable)
-end
-
---------------------------------------------------------------------------------------------------------------
--- Data
---------------------------------------------------------------------------------------------------------------
-
--- diameter of the Minimap in game yards at
--- the various possible zoom levels
-MinimapSize = {
- indoor = {
- [0] = 300, -- scale
- [1] = 240, -- 1.25
- [2] = 180, -- 5/3
- [3] = 120, -- 2.5
- [4] = 80, -- 3.75
- [5] = 50, -- 6
- },
- outdoor = {
- [0] = 466 + 2/3, -- scale
- [1] = 400, -- 7/6
- [2] = 333 + 1/3, -- 1.4
- [3] = 266 + 2/6, -- 1.75
- [4] = 200, -- 7/3
- [5] = 133 + 1/3, -- 3.5
- },
-}
-
-ValidMinimapShapes = {
- -- { upper-left, lower-left, upper-right, lower-right }
- ["SQUARE"] = { false, false, false, false },
- ["CORNER-TOPLEFT"] = { true, false, false, false },
- ["CORNER-TOPRIGHT"] = { false, false, true, false },
- ["CORNER-BOTTOMLEFT"] = { false, true, false, false },
- ["CORNER-BOTTOMRIGHT"] = { false, false, false, true },
- ["SIDE-LEFT"] = { true, true, false, false },
- ["SIDE-RIGHT"] = { false, false, true, true },
- ["SIDE-TOP"] = { true, false, true, false },
- ["SIDE-BOTTOM"] = { false, true, false, true },
- ["TRICORNER-TOPLEFT"] = { true, true, true, false },
- ["TRICORNER-TOPRIGHT"] = { true, false, true, true },
- ["TRICORNER-BOTTOMLEFT"] = { true, true, false, true },
- ["TRICORNER-BOTTOMRIGHT"] = { false, true, true, true },
-}
-
--- distances across and offsets of the world maps
--- in game yards
-WorldMapSize = {
- -- World Map of Azeroth
- [0] = {
- parentContinent = 0,
- height = 31809.64857610083,
- width = 47714.278579261,
- },
- -- Kalimdor
- { -- [1]
- parentContinent = 0,
- height = 24533.025279205,
- width = 36800.210572494,
- xOffset = -8590.40725049343,
- yOffset = 5628.692856102324,
- zoneData = {
- AhnQirajTheFallenKingdom = {
- height = 2700.0,
- width = 4049.99983215332,
- xOffset = -3891.6665,
- yOffset = -8033.333,
- mapID = 772
- },
- Ashenvale = {
- height = 3843.722811451077,
- width = 5766.728884700476,
- xOffset = 15366.76755576002,
- yOffset = 8126.925260781192,
- mapID = 331,
- },
- Aszhara = {
- height = 3381.225696279877,
- width = 5070.888165752819,
- xOffset = 20343.90485013144,
- yOffset = 7458.180046130774,
- mapID = 16,
- },
- AzuremystIsle = {
- height = 2714.561862167815,
- width = 4070.883253576282,
- xOffset = 9966.70736478994,
- yOffset = 5460.278138661794,
- mapID = 3524,
- },
- Barrens = {
- height = 3831.24987792969,
- width = 5745.83332824707,
- xOffset = 14443.84117394525,
- yOffset = 11187.32013604393,
- mapID = 17,
- },
- BloodmystIsle = {
- height = 2174.984710698752,
- width = 3262.517428121028,
- xOffset = 9541.713418184554,
- yOffset = 3424.874558234072,
- mapID = 3525,
- },
- Darkshore = {
- height = 4366.636219106706,
- width = 6550.06962983463,
- xOffset = 14125.08809600818,
- yOffset = 4466.534412478246,
- mapID = 148,
- },
- Darnassus = {
- height = 705.7248633938184,
- width = 1058.342927027606,
- xOffset = 14128.39258617903,
- yOffset = 2561.565012455802,
- mapID = 1657,
- },
- Desolace = {
- height = 2997.895174253872,
- width = 4495.882023201739,
- xOffset = 12833.40729836031,
- yOffset = 12347.72848626745,
- mapID = 405,
- },
- Durotar = {
- height = 3524.975114832228,
- width = 5287.558038649864,
- xOffset = 19029.30699887344,
- yOffset = 10991.48801260963,
- mapID = 14,
- },
- Dustwallow = {
- height = 3499.975146240067,
- width = 5250.057259791282,
- xOffset = 18041.79657043901,
- yOffset = 14833.12751666842,
- mapID = 15,
- },
- Felwood = {
- height = 3833.305958270781,
- width = 5750.062034325837,
- xOffset = 15425.10163773161,
- yOffset = 5666.526367166872,
- mapID = 361,
- },
- Feralas = {
- height = 4633.30011661694,
- width = 6950.075260353015,
- xOffset = 11625.06045254075,
- yOffset = 15166.45834829251,
- mapID = 357,
- },
- Hyjal = {
- height = 2831.24975585938,
- width = 4245.83337402344,
- xOffset = 929.167,
- yOffset = 6195.833,
- mapID = 606
- },
- Hyjal_terrain1 = {
- height = 2831.24975585938,
- width = 4245.83337402344,
- xOffset = 929.167,
- yOffset = 6195.833,
- mapID = 683
- },
- Moonglade = {
- height = 1539.572509508711,
- width = 2308.356845256911,
- xOffset = 18448.05172159372,
- yOffset = 4308.20254319874,
- mapID = 493,
- },
- Mulgore = {
- height = 3424.975945100366,
- width = 5137.555355060729,
- xOffset = 15018.84750987729,
- yOffset = 13072.72336630089,
- mapID = 215,
- },
- Orgrimmar = {
- height = 935.4100697456119,
- width = 1402.621211455915,
- xOffset = 20747.42666130799,
- yOffset = 10525.94769396873,
- mapID = 1637,
- },
- Silithus = {
- height = 2322.899061688691,
- width = 3483.371975265956,
- xOffset = 14529.25864164056,
- yOffset = 18758.10068625832,
- mapID = 1377,
- },
- SouthernBarrens = {
- height = 4941.66665649414,
- width = 7412.5,
- xOffset = -1356.25,
- yOffset = 204.167,
- mapID = 607
- },
- StonetalonMountains = {
- height = 3256.226691571251,
- width = 4883.385977951072,
- xOffset = 13820.91773479217,
- yOffset = 9883.162892509636,
- mapID = 406,
- },
- Tanaris = {
- height = 4599.965662459992,
- width = 6900.073766103516,
- xOffset = 17285.539010128,
- yOffset = 18674.7673661939,
- mapID = 440,
- },
- Teldrassil = {
- height = 3393.726923234355,
- width = 5091.720903621394,
- xOffset = 13252.16205313556,
- yOffset = 968.6418744503761,
- mapID = 141,
- },
- TheExodar = {
- height = 704.6826864472878,
- width = 1056.781131437323,
- xOffset = 10533.08314172693,
- yOffset = 6276.205331713322,
- mapID = 3557,
- },
- ThousandNeedles = {
- height = 2933.312180524323,
- width = 4400.046681282484,
- xOffset = 17500.12437633161,
- yOffset = 16766.44698282704,
- mapID = 400,
- },
- ThunderBluff = {
- height = 695.8282721105132,
- width = 1043.761263579803,
- xOffset = 16550.11410485969,
- yOffset = 13649.80260929285,
- mapID = 1638,
- },
- Uldum = {
- height = 4129.16650390625,
- width = 6193.74975585938,
- xOffset = -2441.667,
- yOffset = -8029.1665,
- mapID = 720
- },
- UngoroCrater = {
- height = 2466.647220780505,
- width = 3700.040077455555,
- xOffset = 16533.44712326324,
- yOffset = 18766.4334494793,
- mapID = 490,
- },
- Winterspring = {
- height = 4733.299561046713,
- width = 7100.077599808275,
- xOffset = 17383.45606038691,
- yOffset = 4266.536453420381,
- mapID = 618,
- },
- },
- },
- -- Eastern Kingdoms
- { -- [2]
- parentContinent = 0,
- height = 27149.795290881,
- width = 40741.175327834,
- xOffset = 18542.31220836664,
- yOffset = 3585.574573158966,
- zoneData = {
- Arathi = {
- height = 2400.0092446309,
- width = 3599.999380663208,
- xOffset = 19038.63328411639,
- yOffset = 11309.72201070757,
- mapID = 3358,
- },
- Badlands = {
- height = 1658.340965090961,
- width = 2487.498490907989,
- xOffset = 20251.1337564772,
- yOffset = 17065.99404487956,
- mapID = 3,
- },
- BlastedLands = {
- height = 2233.343415116865,
- width = 3349.999381676505,
- xOffset = 19413.63362865575,
- yOffset = 21743.09582955139,
- mapID = 4,
- },
- BurningSteppes = {
- height = 1952.091972408385,
- width = 2929.16694293186,
- xOffset = 18438.633261567,
- yOffset = 18207.66513379744,
- mapID = 46,
- },
- DeadwindPass = {
- height = 1666.673818905317,
- width = 2499.999888210889,
- xOffset = 19005.29993968603,
- yOffset = 21043.0932328648,
- mapID = 41,
- },
- DunMorogh = {
- height = 3283.345779814337,
- width = 4924.998791911572,
- xOffset = 16369.8840376619,
- yOffset = 15053.48695195484,
- mapID = 1,
- },
- Duskwood = {
- height = 1800.007653419076,
- width = 2699.999669551933,
- xOffset = 17338.63354148773,
- yOffset = 20893.09259181909,
- mapID = 10,
- },
- EasternPlaguelands = {
- height = 2687.510360231216,
- width = 4031.249051993366,
- xOffset = 20459.46801235962,
- yOffset = 7472.207045901617,
- mapID = 139,
- },
- Elwynn = {
- height = 2314.591970284716,
- width = 3470.831971412848,
- xOffset = 16636.55099386465,
- yOffset = 19116.0027890283,
- mapID = 12,
- },
- EversongWoods = {
- height = 3283.346366715794,
- width = 4924.998483501337,
- xOffset = 20259.46725884782,
- yOffset = 2534.687567863296,
- mapID = 3430,
- },
- Ghostlands = {
- height = 2200.008945183733,
- width = 3300.002855743766,
- xOffset = 21055.29786070095,
- yOffset = 5309.698546426793,
- mapID = 3433,
- },
- HillsbradFoothills = {
- height = 2133.341840477916,
- width = 3200.000391416799,
- xOffset = 17105.29968281043,
- yOffset = 10776.38652289269,
- mapID = 267,
- },
- Hinterlands = {
- height = 2566.676323518885,
- width = 3849.998492380244,
- xOffset = 19746.96704279287,
- yOffset = 9709.715966757984,
- mapID = 47,
- },
- Ironforge = {
- height = 527.6056771582851,
- width = 790.6252518322632,
- xOffset = 18885.55815177769,
- yOffset = 15745.64795436116,
- mapID = 1537,
- },
- LochModan = {
- height = 1839.590356444166,
- width = 2758.33360594204,
- xOffset = 20165.71623436714,
- yOffset = 15663.90573348468,
- mapID = 38,
- },
- Redridge = {
- height = 1447.922213393415,
- width = 2170.833229570681,
- xOffset = 19742.79960560691,
- yOffset = 19751.42209395218,
- mapID = 44,
- },
- RuinsofGilneas = {
- height = 2097.916668701172,
- width = 3145.83325195312,
- xOffset = -3439.583,
- yOffset = -533.333,
- mapID = 611
- },
- RuinsofGilneasCity = {
- height = 889.583251953125,
- width = 593.749877929688,
- xOffset = -1933.333,
- yOffset = -1306.25,
- mapID = 685
- },
- SearingGorge = {
- height = 1487.505203229038,
- width = 2231.250200533406,
- xOffset = 18494.88325409831,
- yOffset = 17276.41231120941,
- mapID = 51,
- },
- SilvermoonCity = {
- height = 806.7751969249011,
- width = 1211.458551923779,
- xOffset = 22172.71573747824,
- yOffset = 3422.647395021269,
- mapID = 3487,
- },
- Silverpine = {
- height = 2800.011187621704,
- width = 4200.000573479695,
- xOffset = 14721.96646274185,
- yOffset = 9509.714741967448,
- mapID = 130,
- },
- StormwindCity = {
- height = 1158.33686894901,
- width = 1737.498058940429,
- xOffset = 16449.05164642256,
- yOffset = 19172.25350774846,
- mapID = 1519,
- },
- StranglethornVale = { -- Split to Vale, Jungle and Cape
- height = 4368.75,
- width = 6552.0830078125,
- xOffset = 15951.13375783437,
- yOffset = 22345.18258706305,
- mapID = 33,
- },
- StranglethornJungle = {
- height = 2733.3330078125,
- width = 4099.99987792969,
- xOffset = -1743.750,
- yOffset = -11016.666,
- mapID = 37
- },
- Sunwell = {
- height = 2218.756638064149,
- width = 3327.084777999942,
- xOffset = 21074.0484502027,
- yOffset = 7.595267688679496,
- mapID = 4080,
- },
- SwampOfSorrows = {
- height = 1529.173695058727,
- width = 2293.753807610138,
- xOffset = 20394.88183258176,
- yOffset = 20797.25913588854,
- mapID = 8,
- },
- TheCapeOfStranglethorn = {
- height = 2631.25,
- width = 3945.83312988281,
- xOffset = -2108.333,
- yOffset = -12516.666,
- mapID = 673
- },
- Tirisfal = {
- height = 3012.510490816506,
- width = 4518.749381850256,
- xOffset = 15138.63417865412,
- yOffset = 7338.874503644808,
- mapID = 85,
- },
- TolBarad = {
- height = 1343.75,
- width = 2014.58329248428,
- xOffset = -2010.417,
- yOffset = -560.417,
- mapID = 708
- },
- TolBaradDailyArea = {
- height = 1224.99993896484,
- width = 1837.5,
- xOffset = -2412.5,
- yOffset = 377.083,
- mapID = 709
- },
- TwilightHighlands = {
- height = 3514.5830078125,
- width = 5270.8330078125,
- xOffset = 2437.5,
- yOffset = -2156.25,
- mapID = 700
- },
- TwilightHighlands_terrain1 = {
- height = 3514.5830078125,
- width = 5270.8330078125,
- xOffset = 2437.5,
- yOffset = -2156.25,
- mapID = 770
- },
- Undercity = {
- height = 640.1067253394195,
- width = 959.3752013853186,
- xOffset = 17298.77399735696,
- yOffset = 9298.435338905521,
- mapID = 1497,
- },
- Vashjir = {
- height = 4631.24975585938,
- width = 6945.83276367188,
- xOffset = -8754.166,
- yOffset = -3720.833,
- mapID = 613
- },
- VashjirDepths = {
- height = 2716.66650390625,
- width = 4075.0,
- xOffset = -8233.333,
- yOffset = -4906.25,
- mapID = 614
- },
- VashjirKelpForest = {
- height = 1868.75024414062,
- width = 2802.0830078125,
- xOffset = -5070.833,
- yOffset = -4018.75,
- mapID = 610
- },
- VashjirRuins = {
- height = 3233.3330078125,
- width = 4849.99963378906,
- xOffset = -6681.25,
- yOffset = -4756.25,
- mapID = 615
- },
- WesternPlaguelands = {
- height = 2866.677213191588,
- width = 4299.998717025251,
- xOffset = 17755.30067544475,
- yOffset = 7809.708745090687,
- mapID = 28,
- },
- Westfall = {
- height = 2333.342039971409,
- width = 3500.001170481545,
- xOffset = 15155.29922254704,
- yOffset = 20576.42557120998,
- mapID = 40,
- },
- Wetlands = {
- height = 2756.260286844545,
- width = 4135.414389381328,
- xOffset = 18561.55091405621,
- yOffset = 13324.31339403164,
- mapID = 11,
- },
- },
- },
- -- Outland
- { -- [3]
- parentContinent = 3,
- height = 11642.355227091,
- width = 17463.987300595,
- xOffset = 0,
- yOffset = 0,
- zoneData = {
- BladesEdgeMountains = {
- height = 3616.553511321226,
- width = 5424.972055480694,
- xOffset = 4150.184214583454,
- yOffset = 1412.98225932006,
- mapID = 3522,
- },
- Hellfire = {
- height = 3443.642450656037,
- width = 5164.556104714847,
- xOffset = 7456.417230912641,
- yOffset = 4339.973750274888,
- mapID = 3483,
- },
- Nagrand = {
- height = 3683.218538167106,
- width = 5524.971495006054,
- xOffset = 2700.192018521809,
- yOffset = 5779.511974812862,
- mapID = 3518,
- },
- Netherstorm = {
- height = 3716.550608724641,
- width = 5574.970083688359,
- xOffset = 7512.667416095402,
- yOffset = 365.0979827402549,
- mapID = 3523,
- },
- ShadowmoonValley = {
- height = 3666.552070430093,
- width = 5499.971770418525,
- xOffset = 8770.993458280615,
- yOffset = 7769.033264592288,
- mapID = 3520,
- },
- ShattrathCity = {
- height = 870.8059516186869,
- width = 1306.242821388422,
- xOffset = 6860.744740098593,
- yOffset = 7295.086120456203,
- mapID = 3703,
- },
- TerokkarForest = {
- height = 3599.887783533737,
- width = 5399.971351016305,
- xOffset = 5912.675516998205,
- yOffset = 6821.146319031154,
- mapID = 3519,
- },
- Zangarmarsh = {
- height = 3351.978710181591,
- width = 5027.057650868489,
- xOffset = 3521.020638264577,
- yOffset = 3885.821278366336,
- mapID = 3521,
- },
- },
- },
- -- Northrend
- {
- parentContinent = 0,
- height = 11834.31067391958,
- width = 17751.3936186856,
- xOffset = 16020.94093549576,
- yOffset = 454.2464807713226,
- zoneData = {
- BoreanTundra = {
- height = 3843.765503862232,
- width = 5764.58206497758,
- xOffset = 646.3186767730767,
- yOffset = 5695.480016983896,
- mapID = 3537,
- },
- CrystalsongForest = {
- height = 1814.590053385046,
- width = 2722.916164555434,
- xOffset = 7773.400227973558,
- yOffset = 4091.307437548815,
- mapID = 2817,
- },
- Dalaran = {
- height = 553.3419356683534,
- width = 830.014625253355,
- xOffset = 8164.640128758279,
- yOffset = 4526.722218200071,
- mapID = 4395,
- },
- Dragonblight = {
- height = 3739.597759999098,
- width = 5608.331259502691,
- xOffset = 5590.067753073641,
- yOffset = 5018.394106536425,
- mapID = 65,
- },
- GrizzlyHills = {
- height = 3500.013349296343,
- width = 5249.9986179934,
- xOffset = 10327.56614428777,
- yOffset = 5076.727864214266,
- mapID = 394,
- },
- HowlingFjord = {
- height = 4031.266275060274,
- width = 6045.831339550668,
- xOffset = 10615.0658552538,
- yOffset = 7476.736868262738,
- mapID = 495,
- },
- IcecrownGlacier = {
- height = 4181.266519840844,
- width = 6270.832975322177,
- xOffset = 3773.401695036191,
- yOffset = 1166.296622984233,
- mapID = 210,
- },
- LakeWintergrasp = {
- height = 1983.342901980711,
- width = 2974.999377667768,
- xOffset = 4887.984320612982,
- yOffset = 4876.725348039468,
- mapID = 4197,
- },
- SholazarBasin = {
- height = 2904.177559586215,
- width = 4356.248328680455,
- xOffset = 2287.985279107324,
- yOffset = 3305.887993444818,
- mapID = 3711,
- },
- TheStormPeaks = {
- height = 4741.684940421732,
- width = 7112.498205872217,
- xOffset = 7375.483315518691,
- yOffset = 395.4596828327046,
- mapID = 67,
- },
- ZulDrak = {
- height = 3329.179510740043,
- width = 4993.747919923504,
- xOffset = 9817.150055203074,
- yOffset = 2924.636381254688,
- mapID = 66,
- },
- HrothgarsLanding = {
- height = 2452.083984375,
- width = 3677.08312988281,
- xOffset = 6418.417,
- yOffset = -188.039,
- }
- },
- },
- -- The Maelstrom
- {
- parentContinent = 0,
- height = 0.0,
- width = 0.0,
- xOffset = 0.0,
- yOffset = 0.0,
- zoneData = {
- Deepholm = { height = 3399.999877929688, width = 5099.9987792969, xOffset = -3052.083, yOffset = 2795.833, mapID = 640 },
- Kezan = { height = 900.00048828125, width = 1352.08319091797, xOffset = -2129.167, yOffset = -7731.25, mapID = 605 },
- TheLostIsles = { height = 3010.41665649414, width = 4514.5830078125, xOffset = -4383.333, yOffset = 2881.25, mapID = 544 },
- TheLostIsles_terrain1 = { height = 3010.41665649414, width = 4514.5830078125, xOffset = -4383.333, yOffset = 2881.25, mapID = 681 },
- TheLostIsles_terrain2 = { height = 3010.41665649414, width = 4514.5830078125, xOffset = -4383.333, yOffset = 2881.25, mapID = 682 },
- TheMaelstrom = { height = 1033.33325195312, width = 1550.0, xOffset = -1556.25, yOffset = 1370.833, mapID = 737 }
- }
- }
-}
-
- local function VContinent(index, name, size)
- assert(1, not WorldMapSize[index], "denied")
-
- WorldMapSize[index] = {
- parentContinent = index,
- height = size,
- width = size*1.5,
- zoneData = { },
- }
- WorldMapSize[index].zoneData[name] = {
- height = size,
- width = size*1.5,
- xOffset = 0,
- yOffset = 0,
- }
-end
-
-VContinent(-77, "ScarletEnclave", 2125)
-VContinent(-78, "GilneasCity", 2125)
-VContinent(-79, "GilneasZone", 2125)
-
-
-VContinent(-80, "UtgardeKeep1", 100) -- temporary value
-VContinent(-81, "UtgardeKeep2", 100) -- temporary value
-VContinent(-82, "UtgardeKeep3", 100) -- temporary value
-
-VContinent(-83, "TheNexus", 734.2)
-
-VContinent(-84, "AzjolNerub1", 100) -- temporary value
-VContinent(-85, "AzjolNerub2", 100) -- temporary value
-VContinent(-86, "AzjolNerub3", 100) -- temporary value
-
-VContinent(-87, "Ahnkahet", 648.3)
-
-VContinent(-88, "DrakTharonKeep1", 100) -- temporary value
-VContinent(-89, "DrakTharonKeep2", 100) -- temporary value
-
-VContinent(-90, "VioletHold", 170.83)
-
-VContinent(-91, "Gundrak", 603.35)
-
-VContinent(-92, "Ulduar77", 613.5) -- Halls of Stone
-
-VContinent(-93, "HallsofLightning1", 100) -- temporary value
-VContinent(-94, "HallsofLightning2", 100) -- temporary value
-
-VContinent(-95, "Nexus801", 100) -- temporary value -- Oculus
-VContinent(-96, "Nexus802", 100) -- temporary value
-VContinent(-97, "Nexus803", 100) -- temporary value
-VContinent(-98, "Nexus804", 100) -- temporary value
-
-VContinent(-99, "CoTStratholme1", 750.2)
-VContinent(-100, "CoTStratholme2", 1216.66)
-
-VContinent(-101, "UtgardePinnacle1", 100) -- temporary value -- hey they spelled it right
-VContinent(-102, "UtgardePinnacle2", 100) -- temporary value
-
-VContinent(-103, "VaultofArchavon", 603.25) -- temporary value -- Weirdly, Emalon is actually within the "Vault of Archavon"
-
-VContinent(-104, "Naxxramas1", 1237.5) -- construct quarter
-VContinent(-105, "Naxxramas2", 1237.5) -- arachnid quarter
-VContinent(-106, "Naxxramas3", 1237.5) -- military quarter
-VContinent(-107, "Naxxramas4", 1237.5) -- plague quarter
-VContinent(-108, "Naxxramas5", 1379.9) -- overview
-VContinent(-109, "Naxxramas6", 437.3) -- lair
-
-VContinent(-110, "TheObsidianSanctum", 775.1)
-
-VContinent(-111, "TheEyeOfEternity", 286.7)
-
-VContinent(-112, "Ulduar", 2191.7) -- temporary value
-VContinent(-113, "Ulduar1", 446.5) -- temporary value
-VContinent(-114, "Ulduar2", 885.6) -- temporary value
-VContinent(-115, "Ulduar3", 100) -- temporary value
-VContinent(-116, "Ulduar4", 100) -- temporary value
-
-VContinent(-117, "TheForgeofSouls", 965.4) -- temporary value
-VContinent(-118, "PitofSaron", 1022.3)
-
-VirtualContinentIndexes = { -- Don't change values here, since programs might want to store them
- ["ScarletEnclave"] = -77,
--- ["GilneasCity"] = -78,
--- ["GilneasZone"] = -79,
-
--- ["UtgardeKeep1"] = -80,
--- ["UtgardeKeep2"] = -81,
--- ["UtgardeKeep3"] = -82,
-
--- ["TheNexus"] = -83,
-
--- ["AzjolNerub1"] = -84,
--- ["AzjolNerub2"] = -85,
--- ["AzjolNerub3"] = -86,
-
--- ["Ahnkahet"] = -87,
-
--- ["DrakTharonKeep1"] = -88,
--- ["DrakTharonKeep2"] = -89,
-
--- ["VioletHold"] = -90,
-
--- ["Gundrak"] = -91,
-
--- ["Ulduar77"] = -92, -- Halls of Stone
-
--- ["HallsofLightning1"] = -93,
--- ["HallsofLightning2"] = -94,
-
--- ["Nexus801"] = -95, -- Oculus
--- ["Nexus802"] = -96,
--- ["Nexus803"] = -97,
--- ["Nexus804"] = -98,
-
--- ["CoTStratholme1"] = -99,
--- ["CoTStratholme2"] = -100,
-
--- ["UtgardePinnacle1"] = -101, -- hey they spelled it right
--- ["UtgardePinnacle2"] = -102,
-
--- ["VaultofArchavon"] = -103, -- Weirdly, Emalon is actually within the "Vault of Archavon"
-
--- ["Naxxramas1"] = -104,
--- ["Naxxramas2"] = -105,
--- ["Naxxramas3"] = -106,
--- ["Naxxramas4"] = -107,
--- ["Naxxramas5"] = -108,
--- ["Naxxramas6"] = -109,
-
--- ["TheObsidianSanctum"] = -110,
-
--- ["TheEyeOfEternity"] = -111,
-
--- ["Ulduar"] = -112,
--- ["Ulduar1"] = -113,
--- ["Ulduar2"] = -114,
--- ["Ulduar3"] = -115,
--- ["Ulduar4"] = -116,
-
--- ["TheForgeofSouls"] = -117,
--- ["PitofSaron"] = -118
---[[
- ["AbyssalMaw"] = -120,
- ["ThroneOfTheTides"] = -130,
- ["BlackrockCaverns"] = -140,
- ["HallsOfOrigination"] = -150,
- ["LostCityOfTol'vir"] = -160,
- ["VortexPinnacle"] = -170,
- ["UnknownDeepholme"] = -180,
- ["UnknownGrimBatol"] = -190,
- ["BlackwingDescent"] = -200,
- ["BastionOfTwilight"] = -210,
- ["ThroneOfTheFourWinds"] = -220
---]]
-}
-
-DongleStub:Register(Astrolabe, activate)
-
-local zeroData;
-zeroData = { xOffset = 0, height = 0, yOffset = 0, width = 0, __index = function() return zeroData end };
-setmetatable(zeroData, zeroData);
-setmetatable(WorldMapSize, zeroData);
-
-for continent, zones in pairs(Astrolabe.ContinentList) do
- local mapData = WorldMapSize[continent];
- for index, mapName in pairs(zones) do
- if not ( mapData.zoneData[mapName] ) then
- ChatFrame1:AddMessage("Astrolabe is missing data for "..select(index, GetMapZones(continent))..".");
- mapData.zoneData[mapName] = zeroData;
- end
- mapData[index] = mapData.zoneData[mapName];
- mapData.zoneData[mapName] = nil;
- end
-end
-
-
--- register this library with AstrolabeMapMonitor, this will cause a full update if PLAYER_LOGIN has already fired
-local AstrolabeMapMonitor = DongleStub("AstrolabeMapMonitor");
-AstrolabeMapMonitor:RegisterAstrolabeLibrary(Astrolabe, LIBRARY_VERSION_MAJOR);
-
-
-QH_Astrolabe_Ready = true
diff --git a/QuestHelper/libs/AstrolabeQH/AstrolabeMapMonitor.lua b/QuestHelper/libs/AstrolabeQH/AstrolabeMapMonitor.lua
deleted file mode 100644
index 15e14a6..0000000
--- a/QuestHelper/libs/AstrolabeQH/AstrolabeMapMonitor.lua
+++ /dev/null
@@ -1,238 +0,0 @@
---[[
-Name: AstrolabeMapMonitor
-Revision: $Rev: 44 $
-$Date: 2007-03-30 11:56:21 -0700 (Fri, 30 Mar 2007) $
-Author(s): Esamynn (esamynn@wowinterface.com)
-Inspired By: Gatherer by Norganna
- MapLibrary by Kristofer Karlsson (krka@kth.se)
-Website: http://esamynn.wowinterface.com/
-Documentation: http://www.esamynn.org/wiki/Astrolabe/World_Map_Monitor
-SVN: http://esamynn.org/svn/astrolabe/
-Description:
- This is a small stub library to support the main Astrolabe
- library. It's purpose is to monitor the visibility of
- various World Map frames, so that Astrolabe can modify its
- behaviour accordingly.
-
-Copyright (C) 2007 James Carrothers
-
-License:
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-Note:
- This library's source code is specifically designed to work with
- World of Warcraft's interpreted AddOn system. You have an implicit
- licence to use this library with these facilities since that is its
- designated purpose as per:
- http://www.fsf.org/licensing/licenses/gpl-faq.html#InterpreterIncompat
-]]
-
-QuestHelper_File["AstrolabeQH/AstrolabeMapMonitor.lua"] = "4.0.1.$svnversion$"
-QuestHelper_Loadtime["AstrolabeQH/AstrolabeMapMonitor.lua"] = GetTime()
-
--- WARNING!!!
--- DO NOT MAKE CHANGES TO THIS LIBRARY WITHOUT FIRST CHANGING THE LIBRARY_VERSION_MAJOR
--- STRING (to something unique) OR ELSE YOU MAY BREAK OTHER ADDONS THAT USE THIS LIBRARY!!!
-local LIBRARY_VERSION_MAJOR = "AstrolabeMapMonitor"
-local LIBRARY_VERSION_MINOR = tonumber(string.match("$Revision: 44 $", "(%d+)") or 1)
-
-if not DongleStub then error(LIBRARY_VERSION_MAJOR .. " requires DongleStub.") end
-if not DongleStub:IsNewerVersion(LIBRARY_VERSION_MAJOR, LIBRARY_VERSION_MINOR) then return end
-
-local AstrolabeMapMonitor = {};
-
-function AstrolabeMapMonitor:GetVersion()
- return LIBRARY_VERSION_MAJOR, LIBRARY_VERSION_MINOR;
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Global World Map Frame Registration Table
---------------------------------------------------------------------------------------------------------------
-
-if ( type(WorldMapDisplayFrames) ~= "table" ) then
- WorldMapDisplayFrames = { WorldMapFrame };
-else
- local worldMapFound = false;
- for k, v in pairs(WorldMapDisplayFrames) do
- if ( v == WorldMapFrame ) then
- worldMapFound = true;
- break;
- end
- end
- if not ( worldMapFound ) then
- table.insert(WorldMapDisplayFrames, WorldMapFrame);
- end
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Working Tables and Config Constants
---------------------------------------------------------------------------------------------------------------
-
-AstrolabeMapMonitor.TrackedWorldMaps = {};
-AstrolabeMapMonitor.AstrolabeLibrarys = {};
-
-AstrolabeMapMonitor.NumVisibleWorldMaps = 0;
-
-
---------------------------------------------------------------------------------------------------------------
--- Monitor Frame Script Handlers
---------------------------------------------------------------------------------------------------------------
-
-local function onShow( frame )
- AstrolabeMapMonitor.NumVisibleWorldMaps = AstrolabeMapMonitor.NumVisibleWorldMaps + 1;
- AstrolabeMapMonitor:Update()
-end
-
-local function onHide( frame )
- AstrolabeMapMonitor.NumVisibleWorldMaps = AstrolabeMapMonitor.NumVisibleWorldMaps - 1;
- AstrolabeMapMonitor:Update()
-end
-
-local function setScripts( monitorFrame )
-QH_Hook( monitorFrame, "OnShow", onShow);
-QH_Hook( monitorFrame, "OnHide", onHide);
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Internal Utility Functions
---------------------------------------------------------------------------------------------------------------
-
-local function assert(level,condition,message)
- if not condition then
- error(message,level)
- end
-end
-
-local function argcheck(value, num, ...)
- assert(1, type(num) == "number",
- "Bad argument #2 to 'argcheck' (number expected, got " .. type(level) .. ")")
-
- for i=1,select("#", ...) do
- if type(value) == select(i, ...) then return end
- end
-
- local types = strjoin(", ", ...)
- local name = string.match(debugstack(2,2,0), ": in function [`<](.-)['>]")
- error(string.format("Bad argument #%d to 'AstrolabeMapMonitor.%s' (%s expected, got %s)", num, name, types, type(value)), 3)
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Public API
---------------------------------------------------------------------------------------------------------------
-
-function AstrolabeMapMonitor:MonitorWorldMap( worldMapFrame )
- -- check argument types
- argcheck(worldMapFrame, 2, "table");
- assert((worldMapFrame.SetParent), "Usage Message");
-
- local TrackedWorldMaps = self.TrackedWorldMaps;
- if ( TrackedWorldMaps[worldMapFrame] ) then
- return 1;
- end
- local monitorFrame = CreateFrame("Frame", nil, worldMapFrame);
- TrackedWorldMaps[worldMapFrame] = monitorFrame;
- setScripts(monitorFrame);
- self:ForceUpdate();
- return 0;
-end
-
-function AstrolabeMapMonitor:LookForMapsToRegister()
- for k, frame in pairs(WorldMapDisplayFrames) do
- if ( type(frame) == "table" and frame.SetParent ) then
- self:MonitorWorldMap(frame);
- end
- end
-end
-
-function AstrolabeMapMonitor:Update()
- local visibleMap = false;
- if ( (self.NumVisibleWorldMaps) > 0 ) then
- visibleMap = true;
- end
- for lib, versionString in pairs(self.AstrolabeLibrarys) do
- lib.WorldMapVisible = visibleMap;
- if ( (not visibleMap) and lib.AllWorldMapsHidden ) then
- lib:AllWorldMapsHidden();
- end
- end
- return visibleMap;
-end
-
-function AstrolabeMapMonitor:ForceUpdate()
- self.NumVisibleWorldMaps = 0;
- for worldMap, monitorFrame in pairs(self.TrackedWorldMaps) do
- if ( worldMap:IsVisible() ) then
- self.NumVisibleWorldMaps = self.NumVisibleWorldMaps + 1;
- end
- end
- return self:Update();
-end
-
-function AstrolabeMapMonitor:RegisterAstrolabeLibrary( lib, majorVersionString )
- -- check argument types
- argcheck(lib, 2, "table");
- argcheck(majorVersionString, 3, "string");
-
- self.AstrolabeLibrarys[lib] = majorVersionString;
- self:Update();
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Handler Scripts
---------------------------------------------------------------------------------------------------------------
-
-function AstrolabeMapMonitor:OnEvent( frame, event )
- if ( event == "ADDON_LOADED" ) then
- self:LookForMapsToRegister();
- self:ForceUpdate();
- end
-end
-
-
---------------------------------------------------------------------------------------------------------------
--- Library Registration
---------------------------------------------------------------------------------------------------------------
-
-local function activate( newInstance, oldInstance )
- if ( oldInstance ) then -- this is an upgrade activate
- for k, v in pairs(oldInstance) do
- if ( type(v) ~= "function" ) then
- newInstance[k] = v;
- end
- end
- AstrolabeMapMonitor = oldInstance;
- else
- AstrolabeMapMonitor.eventFrame = CreateFrame("Frame");
- end
- for worldMap, monitorFrame in pairs(AstrolabeMapMonitor.TrackedWorldMaps) do
- setScripts(monitorFrame);
- end
- local frame = AstrolabeMapMonitor.eventFrame;
- frame:Hide();
- frame:UnregisterAllEvents();
- frame:RegisterEvent("ADDON_LOADED");
- frame:SetScript("OnEvent",
- function( frame, event, ... )
- AstrolabeMapMonitor:OnEvent(frame, event, ...);
- end
- );
-end
-
-DongleStub:Register(AstrolabeMapMonitor, activate)
diff --git a/QuestHelper/libs/AstrolabeQH/DongleStub.lua b/QuestHelper/libs/AstrolabeQH/DongleStub.lua
deleted file mode 100644
index 0994164..0000000
--- a/QuestHelper/libs/AstrolabeQH/DongleStub.lua
+++ /dev/null
@@ -1,141 +0,0 @@
---[[------------------------------------------------------------------
--- $Id: DongleStub.lua 466 2007-06-23 19:17:46Z jnwhiteh $
---
--- DongleStub is a simple versioning stub that allows different
--- major versions of a library to exist alongside each other, while
--- providing a mechanism for library upgrades through minor version
--- differences.
---
--- The implementation of DongleStub, including the source code,
--- documentation and related data, is placed into the public domain.
---
--- The original author is James N. Whitehead II
---
--- THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND, NOT
--- EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY. THE AUTHOR OF THIS
--- SOFTWARE, ASSUMES _NO_ RESPONSIBILITY FOR ANY CONSEQUENCE RESULTING
--- FROM THE USE, MODIFICATION, OR REDISTRIBUTION OF THIS SOFTWARE.
-------------------------------------------------------------------]]--
-
-local major = "DongleStub"
-local minor = tonumber(string.match("$Revision: 466 $", "(%d+)") or 1)
-
-local g = getfenv(0)
-
-if not g.DongleStub or g.DongleStub:IsNewerVersion(major, minor) then
- local lib = setmetatable({}, {
- __call = function(t,k)
- if type(t.versions) == "table" and t.versions[k] then
- return t.versions[k].instance
- else
- error("Cannot find a library with name '"..tostring(k).."'", 2)
- end
- end
- })
-
- function lib:HasVersion(major)
- if type(major) ~= "string" then
- error("bad argument #2 to 'HasVersion' (string expected, got " .. type(major) .. ")", 2)
- end
-
- local instance = self.versions and self.versions[major]
- return instance ~= nil
- end
-
- function lib:IsNewerVersion(major, minor)
- local versionData = self.versions and self.versions[major]
- if not versionData then return true end
- local oldmajor,oldminor = versionData.instance:GetVersion()
- return minor > oldminor
- end
-
- local function NilCopyTable(src, dest)
- for k,v in pairs(dest) do dest[k] = nil end
- for k,v in pairs(src) do dest[k] = v end
- end
-
- function lib:Register(newInstance, activate, deactivate)
- if type(newInstance) ~= "table" then
- error("bad argument #2 to 'Register' (table expected, got " .. type(newInstance) .. ")", 2)
- end
-
- if type(newInstance.GetVersion) ~= "function" then
- error("Attempt to register a library with DongleStub that does not have a 'GetVersion' method.", 2)
- end
-
- local major,minor = newInstance:GetVersion()
- if type(major) ~= "string" then
- error("Attempt to register a library with DongleStub that does not have a proper major version.", 2)
- end
-
- if type(minor) ~= "number" then
- error("Attempt to register a library with DongleStub that does not have a proper minor version.", 2)
- end
-
- -- Generate a log of all library registrations
- if not self.log then self.log = {} end
- table.insert(self.log, string.format("Register: %s, %s", major, minor))
-
- if not self:IsNewerVersion(major, minor) then return false end
- if not self.versions then self.versions = {} end
-
- local versionData = self.versions[major]
- if not versionData then
- -- New major version
- versionData = {
- ["instance"] = newInstance,
- ["deactivate"] = deactivate,
- }
-
- self.versions[major] = versionData
- if type(activate) == "function" then
- table.insert(self.log, string.format("Activate: %s, %s", major, minor))
- activate(newInstance)
- end
- return newInstance
- end
-
- local oldDeactivate = versionData.deactivate
- local oldInstance = versionData.instance
-
- versionData.deactivate = deactivate
-
- local skipCopy
- if type(activate) == "function" then
- table.insert(self.log, string.format("Activate: %s, %s", major, minor))
- skipCopy = activate(newInstance, oldInstance)
- end
-
- -- Deactivate the old libary if necessary
- if type(oldDeactivate) == "function" then
- local major, minor = oldInstance:GetVersion()
- table.insert(self.log, string.format("Deactivate: %s, %s", major, minor))
- oldDeactivate(oldInstance, newInstance)
- end
-
- -- Re-use the old table, and discard the new one
- if not skipCopy then
- NilCopyTable(newInstance, oldInstance)
- end
- return oldInstance
- end
-
- function lib:GetVersion() return major,minor end
-
- local function Activate(new, old)
- -- This code ensures that we'll move the versions table even
- -- if the major version names are different, in the case of
- -- DongleStub
- if not old then old = g.DongleStub end
-
- if old then
- new.versions = old.versions
- new.log = old.log
- end
- g.DongleStub = new
- end
-
- -- Actually trigger libary activation here
- local stub = g.DongleStub or lib
- lib = stub:Register(lib, Activate)
-end
diff --git a/QuestHelper/libs/AstrolabeQH/Load.xml b/QuestHelper/libs/AstrolabeQH/Load.xml
deleted file mode 100644
index c63266f..0000000
--- a/QuestHelper/libs/AstrolabeQH/Load.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-
-
-
diff --git a/QuestHelper/libs/AstrolabeQH/lgpl.txt b/QuestHelper/libs/AstrolabeQH/lgpl.txt
deleted file mode 100644
index 5ab7695..0000000
--- a/QuestHelper/libs/AstrolabeQH/lgpl.txt
+++ /dev/null
@@ -1,504 +0,0 @@
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL. It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
- This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it. You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
- When we speak of free software, we are referring to freedom of use,
-not price. Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
- To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights. These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
- For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you. You must make sure that they, too, receive or can get the source
-code. If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it. And you must show them these terms so they know their rights.
-
- We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
- To protect each distributor, we want to make it very clear that
-there is no warranty for the free library. Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
- Finally, software patents pose a constant threat to the existence of
-any free program. We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder. Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
- Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License. This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License. We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
- When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library. The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom. The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
- We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License. It also provides other free software developers Less
-of an advantage over competing non-free programs. These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries. However, the Lesser license provides advantages in certain
-special circumstances.
-
- For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard. To achieve this, non-free programs must be
-allowed to use the library. A more frequent case is that a free
-library does the same job as widely used non-free libraries. In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
- In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software. For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
- Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
- The precise terms and conditions for copying, distribution and
-modification follow. Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library". The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
- GNU LESSER GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
- A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
- The "Library", below, refers to any such software library or work
-which has been distributed under these terms. A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language. (Hereinafter, translation is
-included without limitation in the term "modification".)
-
- "Source code" for a work means the preferred form of the work for
-making modifications to it. For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
- Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it). Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
- 1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
- You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
- 2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) The modified work must itself be a software library.
-
- b) You must cause the files modified to carry prominent notices
- stating that you changed the files and the date of any change.
-
- c) You must cause the whole of the work to be licensed at no
- charge to all third parties under the terms of this License.
-
- d) If a facility in the modified Library refers to a function or a
- table of data to be supplied by an application program that uses
- the facility, other than as an argument passed when the facility
- is invoked, then you must make a good faith effort to ensure that,
- in the event an application does not supply such function or
- table, the facility still operates, and performs whatever part of
- its purpose remains meaningful.
-
- (For example, a function in a library to compute square roots has
- a purpose that is entirely well-defined independent of the
- application. Therefore, Subsection 2d requires that any
- application-supplied function or table used by this function must
- be optional: if the application does not supply it, the square
- root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library. To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License. (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.) Do not make any other change in
-these notices.
-
- Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
- This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
- 4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
- If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
- 5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library". Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
- However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library". The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
- When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library. The
-threshold for this to be true is not precisely defined by law.
-
- If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work. (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
- Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
- 6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
- You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License. You must supply a copy of this License. If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License. Also, you must do one
-of these things:
-
- a) Accompany the work with the complete corresponding
- machine-readable source code for the Library including whatever
- changes were used in the work (which must be distributed under
- Sections 1 and 2 above); and, if the work is an executable linked
- with the Library, with the complete machine-readable "work that
- uses the Library", as object code and/or source code, so that the
- user can modify the Library and then relink to produce a modified
- executable containing the modified Library. (It is understood
- that the user who changes the contents of definitions files in the
- Library will not necessarily be able to recompile the application
- to use the modified definitions.)
-
- b) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (1) uses at run time a
- copy of the library already present on the user's computer system,
- rather than copying library functions into the executable, and (2)
- will operate properly with a modified version of the library, if
- the user installs one, as long as the modified version is
- interface-compatible with the version that the work was made with.
-
- c) Accompany the work with a written offer, valid for at
- least three years, to give the same user the materials
- specified in Subsection 6a, above, for a charge no more
- than the cost of performing this distribution.
-
- d) If distribution of the work is made by offering access to copy
- from a designated place, offer equivalent access to copy the above
- specified materials from the same place.
-
- e) Verify that the user has already received a copy of these
- materials or that you have already sent this user a copy.
-
- For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it. However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
- It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system. Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
- 7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
- a) Accompany the combined library with a copy of the same work
- based on the Library, uncombined with any other library
- facilities. This must be distributed under the terms of the
- Sections above.
-
- b) Give prominent notice with the combined library of the fact
- that part of it is a work based on the Library, and explaining
- where to find the accompanying uncombined form of the same work.
-
- 8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License. Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License. However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
- 9. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Library or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
- 10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
- 11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all. For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded. In such case, this License incorporates the limitation as if
-written in the body of this License.
-
- 13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation. If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
- 14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission. For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this. Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
- NO WARRANTY
-
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Libraries
-
- If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change. You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
- To apply these terms, attach the following notices to the library. It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-
- Copyright (C)
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary. Here is a sample; alter the names:
-
- Yoyodyne, Inc., hereby disclaims all copyright interest in the
- library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
- , 1 April 1990
- Ty Coon, President of Vice
-
-That's all there is to it!
-
-