diff --git a/Astrolabe/Astrolabe.lua b/Astrolabe/Astrolabe.lua
new file mode 100644
index 0000000..7b80e8a
--- /dev/null
+++ b/Astrolabe/Astrolabe.lua
@@ -0,0 +1,1186 @@
+--[[
+Name: Astrolabe
+Revision: $Rev: 627 $
+$Date: 2007-04-20T00:59:57.617577Z $
+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
+SVN: http://esamynn.org/svn/astrolabe/
+Description:
+ This is a library for the World of Warcraft UI system to place
+ icons accurately on both the Minimap and the Worldmaps accurately
+ and maintain the accuracy of those positions.
+
+Copyright (C) 2006-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 = "Astrolabe-0.4"
+local LIBRARY_VERSION_MINOR = tonumber(string.match("$Revision: 627 $", "(%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;
+
+function Astrolabe:GetVersion()
+ return LIBRARY_VERSION_MAJOR, LIBRARY_VERSION_MINOR;
+end
+
+--------------------------------------------------------------------------------------------------------------
+-- Working Tables and Config Constants
+--------------------------------------------------------------------------------------------------------------
+
+Astrolabe.LastPlayerPosition = { 0, 0, 0, 0 };
+Astrolabe.MinimapIcons = {};
+Astrolabe.IconsOnEdge = {};
+Astrolabe.IconsOnEdge_GroupChangeCallbacks = {};
+
+
+Astrolabe.MinimapUpdateTime = 0.2;
+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;
+
+
+--------------------------------------------------------------------------------------------------------------
+-- 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 ( notMapChange ) 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 MinimapCompassRing = MiniMapCompassRing;
+local twoPi = math.pi * 2;
+local atan2 = math.atan2;
+local sin = math.sin;
+local cos = math.cos;
+
+local function placeIconOnMinimap( minimap, minimapZoom, mapWidth, mapHeight, icon, dist, xDist, yDist )
+ --TODO: add support for non-circular minimaps
+ 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;
+
+ 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 ( (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 = self.MinimapIcons[icon];
+ if not ( iconData ) then
+ iconData = GetWorkingTable(icon);
+ self.MinimapIcons[icon] = iconData;
+ end
+ iconData.continent = continent;
+ iconData.zone = zone;
+ iconData.xPos = xPos;
+ iconData.yPos = yPos;
+ iconData.dist = dist;
+ iconData.xDist = xDist;
+ iconData.yDist = yDist;
+
+ if ( GetCVar("rotateMinimap") ~= "0" ) then
+ minimapRotationEnabled = true;
+ else
+ minimapRotationEnabled = false;
+ end
+
+ -- 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
+ self.MinimapIcons[icon] = nil;
+ self.IconsOnEdge[icon] = nil;
+ icon:Hide();
+ return 0;
+end
+
+function Astrolabe:RemoveAllMinimapIcons()
+ 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;
+function Astrolabe:UpdateMinimapIconPositions()
+ local C, Z, x, y = self:GetCurrentPlayerPosition();
+ if not ( C and C >= 0 ) then
+ if not ( self.WorldMapVisible ) then
+ self.processingFrame:Hide();
+ end
+ return;
+ end
+ local Minimap = Minimap;
+ local lastPosition = self.LastPlayerPosition;
+ local lC, lZ, lx, ly = unpack(lastPosition);
+
+ if ( GetCVar("rotateMinimap") ~= "0" ) then
+ minimapRotationEnabled = true;
+ else
+ minimapRotationEnabled = false;
+ end
+
+ 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();
+ for icon, data in pairs(self.MinimapIcons) do
+ placeIconOnMinimap(Minimap, currentZoom, mapWidth, mapHeight, icon, data.dist, data.xDist, data.yDist);
+ 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();
+ 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;
+ end
+ else
+ self:RemoveAllMinimapIcons()
+ end
+
+ lastPosition[1] = C;
+ lastPosition[2] = Z;
+ lastPosition[3] = x;
+ lastPosition[4] = y;
+ end
+end
+
+function Astrolabe:CalculateMinimapIconPositions()
+ local C, Z, x, y = self:GetCurrentPlayerPosition();
+ if not ( C and C >= 0 ) then
+ if not ( self.WorldMapVisible ) then
+ self.processingFrame:Hide();
+ end
+ return;
+ end
+
+ if ( GetCVar("rotateMinimap") ~= "0" ) then
+ minimapRotationEnabled = true;
+ else
+ minimapRotationEnabled = false;
+ end
+
+ local currentZoom = Minimap:GetZoom();
+ lastZoom = currentZoom;
+ local Minimap = Minimap;
+ local mapWidth = Minimap:GetWidth();
+ local mapHeight = Minimap:GetHeight();
+ 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
+ end
+
+ local lastPosition = self.LastPlayerPosition;
+ lastPosition[1] = C;
+ lastPosition[2] = Z;
+ lastPosition[3] = x;
+ lastPosition[4] = y;
+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
+
+
+--------------------------------------------------------------------------------------------------------------
+-- 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();
+ 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
+ self:CalculateMinimapIconPositions();
+ end
+
+ elseif ( event == "ZONE_CHANGED_NEW_AREA" ) then
+ 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
+
+ -- icon position updates
+ local updateTimer = self.UpdateTimer - elapsed;
+ if ( updateTimer > 0 ) then
+ self.UpdateTimer = updateTimer;
+ return;
+ end
+ self.UpdateTimer = self.MinimapUpdateTime;
+ self:UpdateMinimapIconPositions();
+end
+
+function Astrolabe:OnShow( frame )
+ -- set the world map to a zoom with a valid player position
+ local C, Z = Astrolabe:GetCurrentPlayerPosition();
+ if ( C and C >= 0 ) then
+ SetMapZoom(C, Z);
+ else
+ frame:Hide();
+ end
+
+ -- re-calculate minimap icon positions
+ self:CalculateMinimapIconPositions();
+end
+
+-- called by AstrolabMapMonitor when all world maps are hidden
+function Astrolabe:AllWorldMapsHidden()
+ self:CalculateMinimapIconPositions();
+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
+ Astrolabe = oldInstance;
+ else
+ local frame = CreateFrame("Frame");
+ frame:Hide();
+ 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
+
+ local frame = newInstance.processingFrame;
+ 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
+ );
+
+ -- register this library with AstrolabeMapMonitor
+ local AstrolabeMapMonitor = DongleStub("AstrolabeMapMonitor");
+ AstrolabeMapMonitor:RegisterAstrolabeLibrary(Astrolabe, LIBRARY_VERSION_MAJOR);
+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
+ },
+}
+
+-- distances across and offsets of the world maps
+-- in game yards
+WorldMapSize = {
+ -- World Map of Azeroth
+ [0] = {
+ parentContinent = 0,
+ height = 29687.90575403711,
+ width = 44531.82907938571,
+ },
+ -- Kalimdor
+ { --[1]
+ parentContinent = 0,
+ height = 24532.39670836129,
+ width = 36798.56388065484,
+ xOffset = -8310.762035321373,
+ yOffset = 1815.149000954498,
+ zoneData = {
+ Ashenvale = {
+ height = 3843.627450950699,
+ width = 5766.471113365881,
+ xOffset = 15366.08027406009,
+ yOffset = 8126.716152815561,
+ },
+ Aszhara = {
+ height = 3381.153764845262,
+ width = 5070.669448432522,
+ xOffset = 20342.99178351035,
+ yOffset = 7457.974565554941,
+ },
+ AzuremystIsle = {
+ height = 2714.490705490833,
+ width = 4070.691916244019,
+ xOffset = 9966.264785353642,
+ yOffset = 5460.139378090237,
+ },
+ Barrens = {
+ height = 6756.028094350823,
+ width = 10132.98626357964,
+ xOffset = 14443.19633043607,
+ yOffset = 11187.03406016663,
+ },
+ BloodmystIsle = {
+ height = 2174.923922716305,
+ width = 3262.385067990556,
+ xOffset = 9541.280691875327,
+ yOffset = 3424.790637352245,
+ },
+ Darkshore = {
+ height = 4366.52571734943,
+ width = 6549.780280774227,
+ xOffset = 14124.4534386827,
+ yOffset = 4466.419105960455,
+ },
+ Darnassis = {
+ height = 705.7102838625474,
+ width = 1058.300884213672,
+ xOffset = 14127.75729935019,
+ yOffset = 2561.497770365213,
+ },
+ Desolace = {
+ height = 2997.808472061639,
+ width = 4495.726850591814,
+ xOffset = 12832.80723200791,
+ yOffset = 12347.420176847,
+ },
+ Durotar = {
+ height = 3524.884894927208,
+ width = 5287.285801274457,
+ xOffset = 19028.47465485265,
+ yOffset = 10991.20642822035,
+ },
+ Dustwallow = {
+ height = 3499.922239823486,
+ width = 5249.824712249077,
+ xOffset = 18040.98829886713,
+ yOffset = 14832.74650226312,
+ },
+ Felwood = {
+ height = 3833.206376333298,
+ width = 5749.8046476606,
+ xOffset = 15424.4116748014,
+ yOffset = 5666.381311442202,
+ },
+ Feralas = {
+ height = 4633.182754891688,
+ width = 6949.760203962193,
+ xOffset = 11624.54217828119,
+ yOffset = 15166.06954533647,
+ },
+ Moonglade = {
+ height = 1539.548478194226,
+ width = 2308.253559286662,
+ xOffset = 18447.22668103606,
+ yOffset = 4308.084192710569,
+ },
+ Mulgore = {
+ height = 3424.88834791471,
+ width = 5137.32138887616,
+ xOffset = 15018.17633401988,
+ yOffset = 13072.38917227894,
+ },
+ Ogrimmar = {
+ height = 935.3750279485016,
+ width = 1402.563051365538,
+ xOffset = 20746.49533101771,
+ yOffset = 10525.68532631853,
+ },
+ Silithus = {
+ height = 2322.839629859208,
+ width = 3483.224287356748,
+ xOffset = 14528.60591761034,
+ yOffset = 18757.61998086822,
+ },
+ StonetalonMountains = {
+ height = 3256.141917023559,
+ width = 4883.173287670144,
+ xOffset = 13820.29750397374,
+ yOffset = 9882.909063258192,
+ },
+ Tanaris = {
+ height = 4599.847335452488,
+ width = 6899.765399158026,
+ xOffset = 17284.7655865671,
+ yOffset = 18674.28905369955,
+ },
+ Teldrassil = {
+ height = 3393.632169760774,
+ width = 5091.467863261982,
+ xOffset = 13251.58449896318,
+ yOffset = 968.6223632831094,
+ },
+ TheExodar = {
+ height = 704.6641703983866,
+ width = 1056.732317707213,
+ xOffset = 10532.61275516805,
+ yOffset = 6276.045028807911,
+ },
+ ThousandNeedles = {
+ height = 2933.241274801781,
+ width = 4399.86408093722,
+ xOffset = 17499.32929341832,
+ yOffset = 16766.0151133423,
+ },
+ ThunderBluff = {
+ height = 695.8116150081206,
+ width = 1043.762849319158,
+ xOffset = 16549.32009877855,
+ yOffset = 13649.45129927044,
+ },
+ UngoroCrater = {
+ height = 2466.588521980952,
+ width = 3699.872808671186,
+ xOffset = 16532.70803775362,
+ yOffset = 18765.95157787033,
+ },
+ Winterspring = {
+ height = 4733.190938744951,
+ width = 7099.756078049357,
+ xOffset = 17382.67868933954,
+ yOffset = 4266.421320915686,
+ },
+ },
+ },
+ -- Eastern Kingdoms
+ { --[2]
+ parentContinent = 0,
+ height = 25098.84390074281,
+ width = 37649.15159852673,
+ xOffset = 15525.32200715066,
+ yOffset = 672.3934326738229,
+ zoneData = {
+ Alterac = {
+ height = 1866.508741236576,
+ width = 2799.820894040741,
+ xOffset = 16267.51182664554,
+ yOffset = 7693.598754637632,
+ },
+ Arathi = {
+ height = 2399.784956908336,
+ width = 3599.78645678886,
+ xOffset = 17917.40598190062,
+ yOffset = 9326.804744097401,
+ },
+ Badlands = {
+ height = 1658.195027852759,
+ width = 2487.343589680943,
+ xOffset = 19129.83542887301,
+ yOffset = 15082.55526717644,
+ },
+ BlastedLands = {
+ height = 2233.146573433955,
+ width = 3349.808966078055,
+ xOffset = 18292.37876312771,
+ yOffset = 19759.24272564734,
+ },
+ BurningSteppes = {
+ height = 1951.911155356982,
+ width = 2928.988452241535,
+ xOffset = 17317.44291506163,
+ yOffset = 16224.12640057407,
+ },
+ DeadwindPass = {
+ height = 1666.528298197048,
+ width = 2499.848163715574,
+ xOffset = 17884.07519016362,
+ yOffset = 19059.30117481421,
+ },
+ DunMorogh = {
+ height = 3283.064682642022,
+ width = 4924.664537147015,
+ xOffset = 15248.84370721237,
+ yOffset = 13070.22369811241,
+ },
+ Duskwood = {
+ height = 1799.84874595001,
+ width = 2699.837284973949,
+ xOffset = 16217.51007473156,
+ yOffset = 18909.31475362112,
+ },
+ EasternPlaguelands = {
+ height = 2581.024511737268,
+ width = 3870.596078314358,
+ xOffset = 19236.07699848783,
+ yOffset = 5393.799386328108,
+ },
+ Elwynn = {
+ height = 2314.38613060264,
+ width = 3470.62593362794,
+ xOffset = 15515.46777926721,
+ yOffset = 17132.38313881497,
+ },
+ EversongWoods = {
+ height = 3283.057803444214,
+ width = 4924.70470173181,
+ xOffset = 19138.16325760612,
+ yOffset = 552.5351270080572,
+ },
+ Ghostlands = {
+ height = 2199.788221727843,
+ width = 3299.755735439147,
+ xOffset = 19933.969945598,
+ yOffset = 3327.317139912411,
+ },
+ Hilsbrad = {
+ height = 2133.153088717906,
+ width = 3199.802496078764,
+ xOffset = 15984.19170342619,
+ yOffset = 8793.505832296016,
+ },
+ Hinterlands = {
+ height = 2566.448674847725,
+ width = 3849.77134323942,
+ xOffset = 18625.69536724846,
+ yOffset = 7726.929725104341,
+ },
+ Ironforge = {
+ height = 527.5626661642974,
+ width = 790.5745810546713,
+ xOffset = 17764.34206355846,
+ yOffset = 13762.32403658607,
+ },
+ LochModan = {
+ height = 1839.436067817912,
+ width = 2758.158752877019,
+ xOffset = 19044.42466174755,
+ yOffset = 13680.58746225864,
+ },
+ Redridge = {
+ height = 1447.811817383856,
+ width = 2170.704876735185,
+ xOffset = 18621.52904187992,
+ yOffset = 17767.73128664901,
+ },
+ SearingGorge = {
+ height = 1487.371558351205,
+ width = 2231.119799153945,
+ xOffset = 17373.68649889545,
+ yOffset = 15292.9566475719,
+ },
+ SilvermoonCity = {
+ height = 806.6680775210333,
+ width = 1211.384457945605,
+ xOffset = 21051.29911245071,
+ yOffset = 1440.439646345552,
+ },
+ Silverpine = {
+ height = 2799.763349841058,
+ width = 4199.739879721531,
+ xOffset = 13601.00798540562,
+ yOffset = 7526.945768538925,
+ },
+ Stormwind = {
+ height = 896.2784132739149,
+ width = 1344.138055148283,
+ xOffset = 15669.93346231942,
+ yOffset = 17471.62163820253,
+ },
+ Stranglethorn = {
+ height = 4253.796738213571,
+ width = 6380.866711475876,
+ xOffset = 14830.09122763351,
+ yOffset = 20361.27611706414,
+ },
+ SwampOfSorrows = {
+ height = 1529.04028583782,
+ width = 2293.606089974149,
+ xOffset = 19273.57577346738,
+ yOffset = 18813.48829580375,
+ },
+ Tirisfal = {
+ height = 3012.244783356771,
+ width = 4518.469744413802,
+ xOffset = 14017.64852522109,
+ yOffset = 5356.296558943325,
+ },
+ Undercity = {
+ height = 640.0492683780853,
+ width = 959.3140238076666,
+ xOffset = 16177.65630384973,
+ yOffset = 7315.685533181013,
+ },
+ WesternPlaguelands = {
+ height = 2866.410476553068,
+ width = 4299.7374000546,
+ xOffset = 16634.14908983872,
+ yOffset = 5827.092974820261,
+ },
+ Westfall = {
+ height = 2333.132106534445,
+ width = 3499.786489780177,
+ xOffset = 14034.31142029944,
+ yOffset = 18592.67765947875,
+ },
+ Wetlands = {
+ height = 2756.004767589141,
+ width = 4135.166184805389,
+ xOffset = 17440.35277057554,
+ yOffset = 11341.20698670613,
+ },
+ },
+ },
+ -- Outland
+ { --[3]
+ parentContinent = 3,
+ height = 11642.3552270912,
+ width = 17463.5328406368,
+ zoneData = {
+ BladesEdgeMountains = {
+ height = 3616.553353533977,
+ width = 5424.84803598309,
+ xOffset = 4150.068157139826,
+ yOffset = 1412.982266241851,
+ },
+ Hellfire = {
+ height = 3443.642890402687,
+ width = 5164.421615455519,
+ xOffset = 7456.223236253186,
+ yOffset = 4339.973528794677,
+ },
+ Nagrand = {
+ height = 3683.218386203915,
+ width = 5524.827295176373,
+ xOffset = 2700.121400200201,
+ yOffset = 5779.512212073806,
+ },
+ Netherstorm = {
+ height = 3716.547708910237,
+ width = 5574.82788866266,
+ xOffset = 7512.470386633603,
+ yOffset = 365.0992858464317,
+ },
+ ShadowmoonValley = {
+ height = 3666.547917042888,
+ width = 5499.827432644566,
+ xOffset = 8770.765422136874,
+ yOffset = 7769.034259125071,
+ },
+ ShattrathCity = {
+ height = 870.8063021892297,
+ width = 1306.210386847456,
+ xOffset = 6860.565394341991,
+ yOffset = 7295.086145447915,
+ },
+ TerokkarForest = {
+ height = 3599.889712038368,
+ width = 5399.832305361811,
+ xOffset = 5912.521284664757,
+ yOffset = 6821.146112637057,
+ },
+ Zangarmarsh = {
+ height = 3351.978685113859,
+ width = 5026.925554043871,
+ xOffset = 3520.930685571132,
+ yOffset = 3885.821388791224,
+ },
+ },
+ },
+}
+
+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
+
+
+-- do a full update of the Minimap positioning system
+Astrolabe:CalculateMinimapIconPositions();
diff --git a/Astrolabe/AstrolabeMapMonitor.lua b/Astrolabe/AstrolabeMapMonitor.lua
new file mode 100644
index 0000000..c9349c6
--- /dev/null
+++ b/Astrolabe/AstrolabeMapMonitor.lua
@@ -0,0 +1,235 @@
+--[[
+Name: AstrolabeMapMonitor
+Revision: $Rev: 626 $
+$Date: 2007-03-30T18:56:21.734670Z $
+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: 626 $", "(%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/Astrolabe/DongleStub.lua b/Astrolabe/DongleStub.lua
new file mode 100644
index 0000000..2f14410
--- /dev/null
+++ b/Astrolabe/DongleStub.lua
@@ -0,0 +1,90 @@
+--[[-------------------------------------------------------------------------
+ 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-Beta0"
+local minor = tonumber(string.match("$Revision: 221 $", "(%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 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)
+ local major,minor = newInstance:GetVersion()
+ 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
+ activate(newInstance)
+ end
+ return newInstance
+ end
+
+ local oldDeactivate = versionData.deactivate
+ local oldInstance = versionData.instance
+
+ versionData.deactivate = deactivate
+
+ local skipCopy
+ if type(activate) == "function" then
+ skipCopy = activate(newInstance, oldInstance)
+ end
+
+ -- Deactivate the old libary if necessary
+ if type(oldDeactivate) == "function" then
+ 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)
+ if old then
+ new.versions = old.versions
+ end
+ g.DongleStub = new
+ end
+
+ -- Actually trigger libary activation here
+ local stub = g.DongleStub or lib
+ stub:Register(lib, Activate)
+end
diff --git a/Astrolabe/Load.xml b/Astrolabe/Load.xml
new file mode 100644
index 0000000..c63266f
--- /dev/null
+++ b/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/Astrolabe/lgpl.txt b/Astrolabe/lgpl.txt
new file mode 100644
index 0000000..5ab7695
--- /dev/null
+++ b/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!
+
+