diff --git a/Astrolabe/Astrolabe.lua b/Astrolabe/Astrolabe.lua
deleted file mode 100644
index 01fb5fe..0000000
--- a/Astrolabe/Astrolabe.lua
+++ /dev/null
@@ -1,1377 +0,0 @@
---[[
-Name: Astrolabe
-Revision: $Rev: 58 $
-$Date: 2008-02-07 17:16:11 +0000 (Thu, 07 Feb 2008) $
-Author(s): Esamynn (esamynn@wowinterface.com)
-Inspired By: Gatherer by Norganna
- MapLibrary by Kristofer Karlsson (krka@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 the Worldmaps accurately
- and maintain the accuracy of those positions.
-
-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: 58 $", "(%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 }
-
---------------------------------------------------------------------------------------------------------------
--- 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;
-local MinimapCompassRing = MiniMapCompassRing;
-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
-
-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);
- iconData = GetWorkingTable(icon);
- self.MinimapIcons[icon] = nil;
- AddedOrUpdatedIcons[icon] = iconData
-
- 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
-
- -- 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 variables to track the incremental update coroutine
-local incrementalUpdateCrashed = true
-local incrementalUpdateThread
-
-local function UpdateMinimapIconPositions( self )
- yield()
-
- while ( true ) do
- 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);
-
- if ( GetCVar("rotateMinimap") ~= "0" ) then
- minimapRotationEnabled = true;
- else
- minimapRotationEnabled = false;
- end
-
- -- check current frame rate
- local numPerCycle = min(50, GetFramerate() * (self.MinimapUpdateMultiplier or 1))
-
- -- check Minimap Shape
- minimapShape = GetMinimapShape and ValidMinimapShapes[GetMinimapShape()];
-
- if ( lC == C and lZ == Z and lx == x and ly == y ) then
- -- player has not moved since the last update
- if ( lastZoom ~= Minimap:GetZoom() or self.ForceNextUpdate or minimapRotationEnabled ) then
- local currentZoom = Minimap:GetZoom();
- lastZoom = currentZoom;
- local mapWidth = Minimap:GetWidth();
- local mapHeight = Minimap:GetHeight();
- numPerCycle = numPerCycle * 2
- local count = 0
- for icon, data in pairs(self.MinimapIcons) do
- placeIconOnMinimap(Minimap, currentZoom, mapWidth, mapHeight, icon, data.dist, data.xDist, data.yDist);
-
- count = count + 1
- if ( count > numPerCycle ) then
- count = 0
- yield()
- -- check if the incremental update cycle needs to be reset
- -- because a full update has been run
- if ( resetIncrementalUpdate ) then
- break;
- end
- end
- end
- self.ForceNextUpdate = false;
- end
- else
- local dist, xDelta, yDelta = self:ComputeDistance(lC, lZ, lx, ly, C, Z, x, y);
- if ( dist ) then
- local currentZoom = Minimap:GetZoom();
- lastZoom = currentZoom;
- local mapWidth = Minimap:GetWidth();
- local mapHeight = Minimap:GetHeight();
- local count = 0
- for icon, data in pairs(self.MinimapIcons) do
- local xDist = data.xDist - xDelta;
- local yDist = data.yDist - yDelta;
- local dist = sqrt(xDist*xDist + yDist*yDist);
- placeIconOnMinimap(Minimap, currentZoom, mapWidth, mapHeight, icon, dist, xDist, yDist);
-
- data.dist = dist;
- data.xDist = xDist;
- data.yDist = yDist;
-
- count = count + 1
- if ( count >= numPerCycle ) then
- count = 0
- yield()
- -- check if the incremental update cycle needs to be reset
- -- because a full update has been run
- if ( resetIncrementalUpdate ) then
- break;
- end
- end
- end
- else
- self:RemoveAllMinimapIcons()
- end
-
- if not ( resetIncrementalUpdate ) then
- 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
-
- -- put new/updated icons into the main datacache
- self:DumpNewIconsCache()
-
- -- if we've been reset, then we want to start the new incremental update 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
-
--- local variables to track the full update coroutine
-local fullUpdateCrashed = true
-local fullUpdateThread
-
-local function CalculateMinimapIconPositions( self )
- yield()
-
- while ( true ) do
- 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
- -- put new/updated icons into the main datacache
- self:DumpNewIconsCache()
-
- if ( GetCVar("rotateMinimap") ~= "0" ) then
- minimapRotationEnabled = true;
- else
- minimapRotationEnabled = false;
- end
-
- -- check current frame rate
- local numPerCycle = GetFramerate() * (self.MinimapUpdateMultiplier or 1) * 2
-
- -- check Minimap Shape
- minimapShape = GetMinimapShape and ValidMinimapShapes[GetMinimapShape()];
-
- local currentZoom = Minimap:GetZoom();
- lastZoom = currentZoom;
- local 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()
- end
- end
-
- local lastPosition = self.LastPlayerPosition;
- lastPosition[1] = C;
- lastPosition[2] = Z;
- lastPosition[3] = x;
- lastPosition[4] = y;
-
- resetIncrementalUpdate = true
- else
- if not ( self.WorldMapVisible ) then
- self.processingFrame:Hide();
- end
- end
-
- fullUpdateInProgress = false
- yield()
- end
-end
-
-function Astrolabe:CalculateMinimapIconPositions()
- if ( fullUpdateCrashed ) then
- fullUpdateThread = coroutine.wrap(CalculateMinimapIconPositions)
- fullUpdateThread(self) --initialize the thread
- 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
-
-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
-
--- for use ONLY by the activate function
-function Astrolabe:DumpNewIconsCache()
- local MinimapIcons = self.MinimapIcons
- for icon, data in pairs(AddedOrUpdatedIcons) do
- MinimapIcons[icon] = data
- AddedOrUpdatedIcons[icon] = nil
- end
-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: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();
- end
-
- -- re-calculate minimap icon positions
- self:CalculateMinimapIconPositions();
-end
-
--- called by AstrolabMapMonitor when all world maps are hidden
-function Astrolabe:AllWorldMapsHidden()
- self.processingFrame:Hide();
- self.processingFrame:Show();
-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");
- 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
- configConstants = nil -- we don't need this anymore
-
- 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
- );
-
- setmetatable(Astrolabe.MinimapIcons, MinimapIconsMetatable)
-
- -- 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
- },
-}
-
-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 = 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
deleted file mode 100644
index 58b83cc..0000000
--- a/Astrolabe/AstrolabeMapMonitor.lua
+++ /dev/null
@@ -1,235 +0,0 @@
---[[
-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/Astrolabe/DongleStub.lua b/Astrolabe/DongleStub.lua
deleted file mode 100644
index b5211a9..0000000
--- a/Astrolabe/DongleStub.lua
+++ /dev/null
@@ -1,126 +0,0 @@
---[[-------------------------------------------------------------------------
- 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/Astrolabe/Load.xml b/Astrolabe/Load.xml
deleted file mode 100644
index c63266f..0000000
--- a/Astrolabe/Load.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<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
deleted file mode 100644
index 5ab7695..0000000
--- a/Astrolabe/lgpl.txt
+++ /dev/null
@@ -1,504 +0,0 @@
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL. It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
- This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it. You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
- When we speak of free software, we are referring to freedom of use,
-not price. Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
- To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights. These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
- For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you. You must make sure that they, too, receive or can get the source
-code. If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it. And you must show them these terms so they know their rights.
-
- We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
- To protect each distributor, we want to make it very clear that
-there is no warranty for the free library. Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
- Finally, software patents pose a constant threat to the existence of
-any free program. We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder. Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
- Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License. This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License. We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
- When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library. The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom. The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
- We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License. It also provides other free software developers Less
-of an advantage over competing non-free programs. These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries. However, the Lesser license provides advantages in certain
-special circumstances.
-
- For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard. To achieve this, non-free programs must be
-allowed to use the library. A more frequent case is that a free
-library does the same job as widely used non-free libraries. In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
- In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software. For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
- Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
- The precise terms and conditions for copying, distribution and
-modification follow. Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library". The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
- GNU LESSER GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
- A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
- The "Library", below, refers to any such software library or work
-which has been distributed under these terms. A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language. (Hereinafter, translation is
-included without limitation in the term "modification".)
-
- "Source code" for a work means the preferred form of the work for
-making modifications to it. For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
- Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it). Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
- 1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
- You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
- 2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) The modified work must itself be a software library.
-
- b) You must cause the files modified to carry prominent notices
- stating that you changed the files and the date of any change.
-
- c) You must cause the whole of the work to be licensed at no
- charge to all third parties under the terms of this License.
-
- d) If a facility in the modified Library refers to a function or a
- table of data to be supplied by an application program that uses
- the facility, other than as an argument passed when the facility
- is invoked, then you must make a good faith effort to ensure that,
- in the event an application does not supply such function or
- table, the facility still operates, and performs whatever part of
- its purpose remains meaningful.
-
- (For example, a function in a library to compute square roots has
- a purpose that is entirely well-defined independent of the
- application. Therefore, Subsection 2d requires that any
- application-supplied function or table used by this function must
- be optional: if the application does not supply it, the square
- root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library. To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License. (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.) Do not make any other change in
-these notices.
-
- Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
- This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
- 4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
- If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
- 5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library". Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
- However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library". The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
- When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library. The
-threshold for this to be true is not precisely defined by law.
-
- If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work. (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
- Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
- 6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
- You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License. You must supply a copy of this License. If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License. Also, you must do one
-of these things:
-
- a) Accompany the work with the complete corresponding
- machine-readable source code for the Library including whatever
- changes were used in the work (which must be distributed under
- Sections 1 and 2 above); and, if the work is an executable linked
- with the Library, with the complete machine-readable "work that
- uses the Library", as object code and/or source code, so that the
- user can modify the Library and then relink to produce a modified
- executable containing the modified Library. (It is understood
- that the user who changes the contents of definitions files in the
- Library will not necessarily be able to recompile the application
- to use the modified definitions.)
-
- b) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (1) uses at run time a
- copy of the library already present on the user's computer system,
- rather than copying library functions into the executable, and (2)
- will operate properly with a modified version of the library, if
- the user installs one, as long as the modified version is
- interface-compatible with the version that the work was made with.
-
- c) Accompany the work with a written offer, valid for at
- least three years, to give the same user the materials
- specified in Subsection 6a, above, for a charge no more
- than the cost of performing this distribution.
-
- d) If distribution of the work is made by offering access to copy
- from a designated place, offer equivalent access to copy the above
- specified materials from the same place.
-
- e) Verify that the user has already received a copy of these
- materials or that you have already sent this user a copy.
-
- For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it. However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
- It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system. Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
- 7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
- a) Accompany the combined library with a copy of the same work
- based on the Library, uncombined with any other library
- facilities. This must be distributed under the terms of the
- Sections above.
-
- b) Give prominent notice with the combined library of the fact
- that part of it is a work based on the Library, and explaining
- where to find the accompanying uncombined form of the same work.
-
- 8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License. Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License. However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
- 9. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Library or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
- 10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
- 11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all. For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded. In such case, this License incorporates the limitation as if
-written in the body of this License.
-
- 13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation. If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
- 14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission. For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this. Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
- NO WARRANTY
-
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Libraries
-
- If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change. You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
- To apply these terms, attach the following notices to the library. It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
- <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!
-
-
diff --git a/TomTom.toc b/TomTom.toc
index ed2423a..7958a0a 100755
--- a/TomTom.toc
+++ b/TomTom.toc
@@ -5,8 +5,16 @@
## OptionalDeps: Dongle
Dongle.lua
-Astrolabe\Load.xml
+
+libs\Astrolabe\Load.xml
+libs\LibStub\LibStub.lua
+libs\CallbackHandler-1.0\CallbackHandler-1.0.xml
+libs\AceGUI-3.0\AceGUI-3.0.xml
+libs\AceConfig-3.0\AceConfig-3.0.xml
+
TomTom.lua
TomTom_Waypoints.lua
TomTom_Zones.lua
TomTom_CrazyArrow.lua
+
+Config.lua
diff --git a/TomTom_Waypoints.lua b/TomTom_Waypoints.lua
index 14b11aa..bb87267 100644
--- a/TomTom_Waypoints.lua
+++ b/TomTom_Waypoints.lua
@@ -287,6 +287,14 @@ do
function World_OnEvent(self, event, ...)
if event == "WORLD_MAP_UPDATE" then
local data = self.data
+ -- It seems that data.x and data.y are occasionally not valid
+ -- perhaps when the waypoint is removed. Guard this for now
+ -- TODO: Fix permanently
+ if not data.x or not data.y then
+ self:Hide()
+ return
+ end
+
local x,y = Astrolabe:PlaceIconOnWorldMap(WorldMapDetailFrame, self, data.c, data.z, data.x/100, data.y/100)
if (x and y and (0 < x and x <= 1) and (0 < y and y <= 1)) then
self:Show()