diff --git a/libs/Astrolabe/Astrolabe.lua b/libs/Astrolabe/Astrolabe.lua
new file mode 100644
index 0000000..08ada85
--- /dev/null
+++ b/libs/Astrolabe/Astrolabe.lua
@@ -0,0 +1,1415 @@
+--[[
+Name: Astrolabe
+Revision: $Rev: 78 $
+$Date: 2008-03-28 06:05:05 +0000 (Fri, 28 Mar 2008) $
+Author(s): Esamynn (esamynn at wowinterface.com)
+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.
+
+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
+]]
+
+-- 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"
+local LIBRARY_VERSION_MINOR = tonumber(string.match("$Revision: 78 $", "(%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 Astrolabe = {};
+
+-- define local variables for Data Tables (defined at the end of this file)
+local WorldMapSize, MinimapSize, ValidMinimapShapes;
+
+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.UpdateTimer = 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 yield = coroutine.yield
+
+
+--------------------------------------------------------------------------------------------------------------
+-- 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];
+ 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
+
+
+--------------------------------------------------------------------------------------------------------------
+-- General Utility Functions
+--------------------------------------------------------------------------------------------------------------
+
+function Astrolabe:ComputeDistance( c1, z1, x1, y1, c2, z2, x2, 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
+
+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 ) 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 ( 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
+
+--*****************************************************************************
+-- 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 GetCurrentMapContinent(), GetCurrentMapZone(), 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 GetCurrentMapContinent(), GetCurrentMapZone(), 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;
+
+-- I don't cache the actual direction information because I don't want to
+-- encur the work required to retrieve it unless I'm actually going to use the information.
+local MinimapCompassRing = MiniMapCompassRing;
+
+
+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
+ -- for the life of me, I cannot figure out why the following
+ -- math works, but it does
+ local dir = atan2(xDist, yDist) + MinimapCompassRing:GetFacing();
+ xDist = dist * sin(dir);
+ yDist = dist * cos(dir);
+ 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 = (abs(xDist) > abs(yDist)) and abs(xDist) or 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;
+ end
+ 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"
+
+ -- 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();
+ 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
+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 >= 0 ) then
+ local Minimap = Minimap;
+ local lastPosition = self.LastPlayerPosition;
+ local lC, lZ, lx, ly = unpack(lastPosition);
+
+ minimapRotationEnabled = GetCVar("rotateMinimap") ~= "0"
+
+ -- 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 >= 0 ) then
+ minimapRotationEnabled = GetCVar("rotateMinimap") ~= "0"
+
+ -- 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 Minimap = Minimap;
+ 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 = GetCurrentMapContinent(), GetCurrentMapZone();
+ 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 Minimap = Minimap;
+ 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();
+ 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 >= 0 ) then
+ SetMapZoom(C, Z);
+ else
+ frame:Hide();
+ return
+ end
+
+ -- re-calculate minimap icon positions
+ self:CalculateMinimapIconPositions(true);
+end
+
+-- called by AstrolabMapMonitor when all world maps are hidden
+function Astrolabe:AllWorldMapsHidden()
+ if ( IsLoggedIn() ) then
+ self.processingFrame:Hide();
+ self.processingFrame:Show();
+ end
+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
+ Astrolabe = oldInstance;
+ else
+ local frame = CreateFrame("Frame");
+ newInstance.processingFrame = frame;
+
+ newInstance.ContinentList = { GetMapContinents() };
+ for C in pairs(newInstance.ContinentList) do
+ local zones = { GetMapZones(C) };
+ newInstance.ContinentList[C] = zones;
+ for Z in ipairs(zones) do
+ SetMapZoom(C, Z);
+ zones[Z] = GetMapInfo();
+ 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
+
+DongleStub:Register(Astrolabe, activate)
+
+
+--------------------------------------------------------------------------------------------------------------
+-- 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 = 29688.932932224,
+ width = 44537.340058402,
+ },
+ -- Kalimdor
+ { -- [1]
+ parentContinent = 0,
+ height = 24533.025279205,
+ width = 36800.210572494,
+ xOffset = -8311.793923510446,
+ yOffset = 1815.215685280706,
+ zoneData = {
+ Ashenvale = {
+ height = 3843.722811451077,
+ width = 5766.728884700476,
+ xOffset = 15366.76755576002,
+ yOffset = 8126.925260781192,
+ },
+ Aszhara = {
+ height = 3381.225696279877,
+ width = 5070.888165752819,
+ xOffset = 20343.90485013144,
+ yOffset = 7458.180046130774,
+ },
+ AzuremystIsle = {
+ height = 2714.561862167815,
+ width = 4070.883253576282,
+ xOffset = 9966.70736478994,
+ yOffset = 5460.278138661794,
+ },
+ Barrens = {
+ height = 6756.202067150937,
+ width = 10133.44343943073,
+ xOffset = 14443.84117394525,
+ yOffset = 11187.32013604393,
+ },
+ BloodmystIsle = {
+ height = 2174.984710698752,
+ width = 3262.517428121028,
+ xOffset = 9541.713418184554,
+ yOffset = 3424.874558234072,
+ },
+ Darkshore = {
+ height = 4366.636219106706,
+ width = 6550.06962983463,
+ xOffset = 14125.08809600818,
+ yOffset = 4466.534412478246,
+ },
+ Darnassis = {
+ height = 705.7248633938184,
+ width = 1058.342927027606,
+ xOffset = 14128.39258617903,
+ yOffset = 2561.565012455802,
+ },
+ Desolace = {
+ height = 2997.895174253872,
+ width = 4495.882023201739,
+ xOffset = 12833.40729836031,
+ yOffset = 12347.72848626745,
+ },
+ Durotar = {
+ height = 3524.975114832228,
+ width = 5287.558038649864,
+ xOffset = 19029.30699887344,
+ yOffset = 10991.48801260963,
+ },
+ Dustwallow = {
+ height = 3499.975146240067,
+ width = 5250.057259791282,
+ xOffset = 18041.79657043901,
+ yOffset = 14833.12751666842,
+ },
+ Felwood = {
+ height = 3833.305958270781,
+ width = 5750.062034325837,
+ xOffset = 15425.10163773161,
+ yOffset = 5666.526367166872,
+ },
+ Feralas = {
+ height = 4633.30011661694,
+ width = 6950.075260353015,
+ xOffset = 11625.06045254075,
+ yOffset = 15166.45834829251,
+ },
+ Moonglade = {
+ height = 1539.572509508711,
+ width = 2308.356845256911,
+ xOffset = 18448.05172159372,
+ yOffset = 4308.20254319874,
+ },
+ Mulgore = {
+ height = 3424.975945100366,
+ width = 5137.555355060729,
+ xOffset = 15018.84750987729,
+ yOffset = 13072.72336630089,
+ },
+ Ogrimmar = {
+ height = 935.4100697456119,
+ width = 1402.621211455915,
+ xOffset = 20747.42666130799,
+ yOffset = 10525.94769396873,
+ },
+ Silithus = {
+ height = 2322.899061688691,
+ width = 3483.371975265956,
+ xOffset = 14529.25864164056,
+ yOffset = 18758.10068625832,
+ },
+ StonetalonMountains = {
+ height = 3256.226691571251,
+ width = 4883.385977951072,
+ xOffset = 13820.91773479217,
+ yOffset = 9883.162892509636,
+ },
+ Tanaris = {
+ height = 4599.965662459992,
+ width = 6900.073766103516,
+ xOffset = 17285.539010128,
+ yOffset = 18674.7673661939,
+ },
+ Teldrassil = {
+ height = 3393.726923234355,
+ width = 5091.720903621394,
+ xOffset = 13252.16205313556,
+ yOffset = 968.6418744503761,
+ },
+ TheExodar = {
+ height = 704.6826864472878,
+ width = 1056.781131437323,
+ xOffset = 10533.08314172693,
+ yOffset = 6276.205331713322,
+ },
+ ThousandNeedles = {
+ height = 2933.312180524323,
+ width = 4400.046681282484,
+ xOffset = 17500.12437633161,
+ yOffset = 16766.44698282704,
+ },
+ ThunderBluff = {
+ height = 695.8282721105132,
+ width = 1043.761263579803,
+ xOffset = 16550.11410485969,
+ yOffset = 13649.80260929285,
+ },
+ UngoroCrater = {
+ height = 2466.647220780505,
+ width = 3700.040077455555,
+ xOffset = 16533.44712326324,
+ yOffset = 18766.4334494793,
+ },
+ Winterspring = {
+ height = 4733.299561046713,
+ width = 7100.077599808275,
+ xOffset = 17383.45606038691,
+ yOffset = 4266.536453420381,
+ },
+ },
+ },
+ -- Eastern Kingdoms
+ { -- [2]
+ parentContinent = 0,
+ height = 27149.795290881,
+ width = 40741.175327834,
+ xOffset = 14407.1086092051,
+ yOffset = 290.3230897653046,
+ zoneData = {
+ Alterac = {
+ height = 1866.673586850316,
+ width = 2800.000436369314,
+ xOffset = 17388.63313899802,
+ yOffset = 9676.382605411302,
+ },
+ Arathi = {
+ height = 2400.0092446309,
+ width = 3599.999380663208,
+ xOffset = 19038.63328411639,
+ yOffset = 11309.72201070757,
+ },
+ Badlands = {
+ height = 1658.340965090961,
+ width = 2487.498490907989,
+ xOffset = 20251.1337564772,
+ yOffset = 17065.99404487956,
+ },
+ BlastedLands = {
+ height = 2233.343415116865,
+ width = 3349.999381676505,
+ xOffset = 19413.63362865575,
+ yOffset = 21743.09582955139,
+ },
+ BurningSteppes = {
+ height = 1952.091972408385,
+ width = 2929.16694293186,
+ xOffset = 18438.633261567,
+ yOffset = 18207.66513379744,
+ },
+ DeadwindPass = {
+ height = 1666.673818905317,
+ width = 2499.999888210889,
+ xOffset = 19005.29993968603,
+ yOffset = 21043.0932328648,
+ },
+ DunMorogh = {
+ height = 3283.345779814337,
+ width = 4924.998791911572,
+ xOffset = 16369.8840376619,
+ yOffset = 15053.48695195484,
+ },
+ Duskwood = {
+ height = 1800.007653419076,
+ width = 2699.999669551933,
+ xOffset = 17338.63354148773,
+ yOffset = 20893.09259181909,
+ },
+ EasternPlaguelands = {
+ height = 2581.259876367526,
+ width = 3870.832396995169,
+ xOffset = 20357.38356562001,
+ yOffset = 7376.373692430854,
+ },
+ Elwynn = {
+ height = 2314.591970284716,
+ width = 3470.831971412848,
+ xOffset = 16636.55099386465,
+ yOffset = 19116.0027890283,
+ },
+ EversongWoods = {
+ height = 3283.346366715794,
+ width = 4924.998483501337,
+ xOffset = 20259.46725884782,
+ yOffset = 2534.687567863296,
+ },
+ Ghostlands = {
+ height = 2200.008945183733,
+ width = 3300.002855743766,
+ xOffset = 21055.29786070095,
+ yOffset = 5309.698546426793,
+ },
+ Hilsbrad = {
+ height = 2133.341840477916,
+ width = 3200.000391416799,
+ xOffset = 17105.29968281043,
+ yOffset = 10776.38652289269,
+ },
+ Hinterlands = {
+ height = 2566.676323518885,
+ width = 3849.998492380244,
+ xOffset = 19746.96704279287,
+ yOffset = 9709.715966757984,
+ },
+ Ironforge = {
+ height = 527.6056771582851,
+ width = 790.6252518322632,
+ xOffset = 18885.55815177769,
+ yOffset = 15745.64795436116,
+ },
+ LochModan = {
+ height = 1839.590356444166,
+ width = 2758.33360594204,
+ xOffset = 20165.71623436714,
+ yOffset = 15663.90573348468,
+ },
+ Redridge = {
+ height = 1447.922213393415,
+ width = 2170.833229570681,
+ xOffset = 19742.79960560691,
+ yOffset = 19751.42209395218,
+ },
+ SearingGorge = {
+ height = 1487.505203229038,
+ width = 2231.250200533406,
+ xOffset = 18494.88325409831,
+ yOffset = 17276.41231120941,
+ },
+ SilvermoonCity = {
+ height = 806.7751969249011,
+ width = 1211.458551923779,
+ xOffset = 22172.71573747824,
+ yOffset = 3422.647395021269,
+ },
+ Silverpine = {
+ height = 2800.011187621704,
+ width = 4200.000573479695,
+ xOffset = 14721.96646274185,
+ yOffset = 9509.714741967448,
+ },
+ Stormwind = {
+ height = 896.3598437319051,
+ width = 1344.270269919159,
+ xOffset = 16790.9956264139,
+ yOffset = 19455.27053790398,
+ },
+ Stranglethorn = {
+ height = 4254.18312444072,
+ width = 6381.248484543122,
+ xOffset = 15951.13375783437,
+ yOffset = 22345.18258706305,
+ },
+ Sunwell = {
+ height = 2218.756638064149,
+ width = 3327.084777999942,
+ xOffset = 21074.0484502027,
+ yOffset = 7.595267688679496,
+ },
+ SwampOfSorrows = {
+ height = 1529.173695058727,
+ width = 2293.753807610138,
+ xOffset = 20394.88183258176,
+ yOffset = 20797.25913588854,
+ },
+ Tirisfal = {
+ height = 3012.510490816506,
+ width = 4518.749381850256,
+ xOffset = 15138.63417865412,
+ yOffset = 7338.874503644808,
+ },
+ Undercity = {
+ height = 640.1067253394195,
+ width = 959.3752013853186,
+ xOffset = 17298.77399735696,
+ yOffset = 9298.435338905521,
+ },
+ WesternPlaguelands = {
+ height = 2866.677213191588,
+ width = 4299.998717025251,
+ xOffset = 17755.30067544475,
+ yOffset = 7809.708745090687,
+ },
+ Westfall = {
+ height = 2333.342039971409,
+ width = 3500.001170481545,
+ xOffset = 15155.29922254704,
+ yOffset = 20576.42557120998,
+ },
+ Wetlands = {
+ height = 2756.260286844545,
+ width = 4135.414389381328,
+ xOffset = 18561.55091405621,
+ yOffset = 13324.31339403164,
+ },
+ },
+ },
+ -- Outland
+ { -- [3]
+ parentContinent = 3,
+ height = 11642.355227091,
+ width = 17463.987300595,
+ zoneData = {
+ BladesEdgeMountains = {
+ height = 3616.553511321226,
+ width = 5424.972055480694,
+ xOffset = 4150.184214583454,
+ yOffset = 1412.98225932006,
+ },
+ Hellfire = {
+ height = 3443.642450656037,
+ width = 5164.556104714847,
+ xOffset = 7456.417230912641,
+ yOffset = 4339.973750274888,
+ },
+ Nagrand = {
+ height = 3683.218538167106,
+ width = 5524.971495006054,
+ xOffset = 2700.192018521809,
+ yOffset = 5779.511974812862,
+ },
+ Netherstorm = {
+ height = 3716.550608724641,
+ width = 5574.970083688359,
+ xOffset = 7512.667416095402,
+ yOffset = 365.0979827402549,
+ },
+ ShadowmoonValley = {
+ height = 3666.552070430093,
+ width = 5499.971770418525,
+ xOffset = 8770.993458280615,
+ yOffset = 7769.033264592288,
+ },
+ ShattrathCity = {
+ height = 870.8059516186869,
+ width = 1306.242821388422,
+ xOffset = 6860.744740098593,
+ yOffset = 7295.086120456203,
+ },
+ TerokkarForest = {
+ height = 3599.887783533737,
+ width = 5399.971351016305,
+ xOffset = 5912.675516998205,
+ yOffset = 6821.146319031154,
+ },
+ Zangarmarsh = {
+ height = 3351.978710181591,
+ width = 5027.057650868489,
+ xOffset = 3521.020638264577,
+ yOffset = 3885.821278366336,
+ },
+ },
+ },
+}
+
+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
+ --WE HAVE A PROBLEM!!!
+ 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);
diff --git a/libs/Astrolabe/AstrolabeMapMonitor.lua b/libs/Astrolabe/AstrolabeMapMonitor.lua
new file mode 100644
index 0000000..58b83cc
--- /dev/null
+++ b/libs/Astrolabe/AstrolabeMapMonitor.lua
@@ -0,0 +1,235 @@
+--[[
+Name: AstrolabeMapMonitor
+Revision: $Rev: 44 $
+$Date: 2007-03-30 19:56:21 +0100 (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
+]]
+
+-- 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 )
+ monitorFrame:SetScript("OnShow", onShow);
+ monitorFrame:SetScript("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/libs/Astrolabe/DongleStub.lua b/libs/Astrolabe/DongleStub.lua
new file mode 100644
index 0000000..b5211a9
--- /dev/null
+++ b/libs/Astrolabe/DongleStub.lua
@@ -0,0 +1,126 @@
+--[[-------------------------------------------------------------------------
+ James Whitehead II grants anyone the right to use this work for any purpose,
+ without any conditions, unless such conditions are required by law.
+---------------------------------------------------------------------------]]
+
+local major = "DongleStub"
+local minor = tonumber(string.match("$Revision: 313 $", "(%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:IsNewerVersion(major, minor)
+ local versionData = self.versions and self.versions[major]
+
+ -- If DongleStub versions have differing major version names
+ -- such as DongleStub-Beta0 and DongleStub-1.0-RC2 then a second
+ -- instance will be loaded, with older logic. This code attempts
+ -- to compensate for that by matching the major version against
+ -- "^DongleStub", and handling the version check correctly.
+
+ if major:match("^DongleStub") then
+ local oldmajor,oldminor = self:GetVersion()
+ if self.versions and self.versions[oldmajor] then
+ return minor > oldminor
+ else
+ return true
+ end
+ end
+
+ 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)
+ assert(type(newInstance.GetVersion) == "function",
+ "Attempt to register a library with DongleStub that does not have a 'GetVersion' method.")
+
+ local major,minor = newInstance:GetVersion()
+ assert(type(major) == "string",
+ "Attempt to register a library with DongleStub that does not have a proper major version.")
+ assert(type(minor) == "number",
+ "Attempt to register a library with DongleStub that does not have a proper minor version.")
+
+ -- 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/libs/Astrolabe/Load.xml b/libs/Astrolabe/Load.xml
new file mode 100644
index 0000000..c63266f
--- /dev/null
+++ b/libs/Astrolabe/Load.xml
@@ -0,0 +1,6 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+ <Script file="DongleStub.lua"/>
+ <Script file="AstrolabeMapMonitor.lua"/>
+ <Script file="Astrolabe.lua"/>
+</Ui>
diff --git a/libs/Astrolabe/lgpl.txt b/libs/Astrolabe/lgpl.txt
new file mode 100644
index 0000000..5ab7695
--- /dev/null
+++ b/libs/Astrolabe/lgpl.txt
@@ -0,0 +1,504 @@
+ 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.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ 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.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+