internal BlueMarbleBuilder()
: base("Blue Marble", MainForm.WorldWindowSingleton, null)
{
ImageLayer oBaseLayer = new WorldWind.Renderable.ImageLayer(
"Blue Marble ImageLayer",
MainForm.WorldWindowSingleton.CurrentWorld,
0,
String.Format(CultureInfo.InvariantCulture, "{0}\\Data\\Earth\\BmngBathy\\world.topo.bathy.2004{1:D2}.jpg", Path.GetDirectoryName(Application.ExecutablePath), 7),
-90, 90, -180, 180, 1.0f, null);
WorldWind.NltImageStore imageStore = new WorldWind.NltImageStore(String.Format(CultureInfo.InvariantCulture, "bmng.topo.bathy.2004{0:D2}", 7), "http://worldwind25.arc.nasa.gov/tile/tile.aspx");
imageStore.DataDirectory = null;
imageStore.LevelZeroTileSizeDegrees = 36.0;
imageStore.LevelCount = 5;
imageStore.ImageExtension = "jpg";
imageStore.CacheDirectory = MainForm.WorldWindowSingleton.Cache.CacheDirectory + "\\Earth\\BMNG\\";
WorldWind.ImageStore[] ias = new WorldWind.ImageStore[1];
ias[0] = imageStore;
QuadTileSet oTiledBaseLayer = new WorldWind.Renderable.QuadTileSet(
"Blue Marble QuadTileSet",
MainForm.WorldWindowSingleton.CurrentWorld,
0,
90, -90, -180, 180, true, ias);
RenderableObjectList oRenderableList = new RenderableObjectList("This name doesn't matter, it gets rewritten");
oRenderableList.Add(oBaseLayer);
oRenderableList.Add(oTiledBaseLayer);
oRenderableList.RenderPriority = RenderPriority.TerrainMappedImages;
m_hObject = oRenderableList;
}
private void updateNode(TreeNode tn)
{
RenderableObjectInfo roi = (RenderableObjectInfo)tn.Tag;
roi.LastSpotted = System.DateTime.Now;
if (tn.Checked != roi.Renderable.IsOn)
{
tn.Checked = roi.Renderable.IsOn;
//treeView1.BeginInvoke(new UpdateCheckStateNodeDelegate(this.UpdateCheckStateNode), new object[] {tn, roi.Renderable.IsOn});
}
if (roi.Renderable is WorldWind.Renderable.RenderableObjectList)
{
WorldWind.Renderable.RenderableObjectList rol = (WorldWind.Renderable.RenderableObjectList)roi.Renderable;
for (int i = 0; i < rol.Count; i++)
{
WorldWind.Renderable.RenderableObject childRo = (WorldWind.Renderable.RenderableObject)rol.ChildObjects[i];
string absolutePath = GetAbsoluteRenderableObjectPath(childRo);
TreeNode correctNode = (TreeNode)m_NodeHash[absolutePath];
if (correctNode == null)
{
correctNode = new TreeNode(childRo.Name);
RenderableObjectInfo curRoi = new RenderableObjectInfo();
curRoi.Renderable = childRo;
correctNode.Tag = curRoi;
m_NodeHash.Add(absolutePath, correctNode);
treeView1.BeginInvoke(new UpdateChildNodeDelegate(this.UpdateChildNodeTree), new object[] { tn, correctNode });
}
updateNode(correctNode);
}
}
}
private KMLLayerBuilder(KMLLayerBuilder oCopySource)
: base(oCopySource.Title, MainForm.WorldWindowSingleton, oCopySource.Parent)
{
m_oSourceFile = oCopySource.m_oSourceFile;
m_oRenderable = KMLCreation.CreateKMLLayer(m_oSourceFile, MainForm.WorldWindowSingleton.CurrentWorld, out m_oBounds);
m_oRenderable.RenderPriority = RenderPriority.TerrainMappedImages;
}
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Menu.LayerShortcutMenuButton"/> class.
/// </summary>
/// <param name="imageFilePath"></param>
/// <param name="ro"></param>
public LayerShortcutMenuButton(
string imageFilePath, WorldWind.Renderable.RenderableObject ro)
: base(imageFilePath)
{
this.Description = ro.Name;
this._ro = ro;
this._isPushed = ro.IsOn;
}
public SurfaceImage(string imageFilePath, double north, double south, double west, double east, Texture texture, RenderableObject parentRenderable)
{
m_ParentRenderable = parentRenderable;
m_ImageFilePath = imageFilePath;
m_North = north;
m_South = south;
m_West = west;
m_East = east;
m_Texture = texture;
}
private string GetAbsoluteRenderableObjectPath(WorldWind.Renderable.RenderableObject ro)
{
if (ro.ParentList != null)
{
return(GetAbsoluteRenderableObjectPath(ro.ParentList) + "//" + ro.Name);
}
else
{
return(ro.Name);
}
}
internal KMLLayerBuilder(String strFilename, String strLayerName, WorldWindow oWorldWindow, IBuilder oParent, GeographicBoundingBox oBounds)
: base(strLayerName, oWorldWindow, oParent)
{
m_strInitFilename = strFilename;
if (File.Exists(m_strInitFilename))
{
m_oSourceFile = new KMLFile(strFilename);
m_oRenderable = KMLCreation.CreateKMLLayer(m_oSourceFile, oWorldWindow.CurrentWorld, out m_oBounds);
if (oBounds != null)
m_oBounds = oBounds;
m_oRenderable.RenderPriority = RenderPriority.TerrainMappedImages;
}
}
private void UpdateRenderable(RenderableObject oldRenderable, RenderableObject newRenderable)
{
if (oldRenderable is Icon && newRenderable is Icon)
{
Icon oldIcon = (Icon)oldRenderable;
Icon newIcon = (Icon)newRenderable;
oldIcon.SetPosition((float)newIcon.Latitude, (float)newIcon.Longitude, (float)newIcon.Altitude);
}
else if (oldRenderable is RenderableObjectList && newRenderable is RenderableObjectList)
{
RenderableObjectList oldList = (RenderableObjectList)oldRenderable;
RenderableObjectList newList = (RenderableObjectList)newRenderable;
compareRefreshLists(newList, oldList);
}
}
/// <summary>
/// Removes a layer from the child layer list
/// </summary>
/// <param name="objectName">Name of object to remove</param>
public virtual void Remove(string objectName)
{
lock (this.m_children.SyncRoot)
{
for (int i = 0; i < this.m_children.Count; i++)
{
RenderableObject ro = (RenderableObject)this.m_children[i];
if (ro.Name.Equals(objectName))
{
this.m_children.RemoveAt(i);
ro.Dispose();
ro.ParentList = null;
break;
}
}
}
}
/// <summary>
/// if ro is chart, then add it to list.
/// </summary>
/// <param name="ro"></param>
public override void Add(RenderableObject ro)
{
MyChart c = ro as MyChart;
if (c == null)
{
ro.Dispose();
return;
}
c.ParentWorld = this.ParentWorld;
base.m_children.Add(ro);
// the first chart added to this layer
if (base.Count == 1)
{
this.east = c.Longitude;
this.west = c.Longitude;
this.south = c.Latitude;
this.north = c.Latitude;
}
else
{
if (this.east
< c.Longitude)
{
this.east = c.Longitude;
}
if (this.west
> c.Longitude)
{
this.west = c.Longitude;
}
if (this.north
< c.Latitude)
{
this.north = c.Latitude;
}
if (this.south
> c.Latitude)
{
this.south = c.Latitude;
}
}
base.Inited = false;
}
///<summary>
/// Goes to the extent specified by the bounding box for the QTS layer
/// or to the lat/lon for icons
/// </summary>
protected virtual void OnGotoClick(object sender, EventArgs e)
{
lock (this.ParentList.ChildObjects.SyncRoot)
{
for (int i = 0; i < this.ParentList.ChildObjects.Count; i++)
{
RenderableObject ro = (RenderableObject)this.ParentList.ChildObjects[i];
if (ro.Name.Equals(name))
{
if (ro is QuadTileSet)
{
QuadTileSet qts = (QuadTileSet)ro;
DrawArgs.Camera.SetPosition((qts.North + qts.South) / 2, (qts.East + qts.West) / 2);
double perpendicularViewRange = (qts.North - qts.South > qts.East - qts.West ? qts.North - qts.South : qts.East - qts.West);
double altitude = qts.LayerRadius * Math.Sin(MathEngine.DegreesToRadians(perpendicularViewRange * 0.5));
DrawArgs.Camera.Altitude = altitude;
break;
}
if (ro is Icon)
{
Icon ico = (Icon)ro;
DrawArgs.Camera.SetPosition(ico.Latitude, ico.Longitude);
DrawArgs.Camera.Altitude /= 2;
break;
}
if (ro is ShapeFileLayer)
{
ShapeFileLayer slayer = (ShapeFileLayer)ro;
DrawArgs.Camera.SetPosition((slayer.North + slayer.South) / 2, (slayer.East + slayer.West) / 2);
double perpendicularViewRange = (slayer.North - slayer.South > slayer.East - slayer.West ? slayer.North - slayer.South : slayer.East - slayer.West);
double altitude = slayer.MaxAltitude;
DrawArgs.Camera.Altitude = altitude;
break;
}
}
}
}
}
/// <summary>
/// Sorts the children list according to priority
/// TODO: Redesign the render tree to perhaps a list, to enable proper sorting
/// </summary>
public virtual void SortChildren()
{
int index = 0;
while (index + 1 < m_children.Count)
{
RenderableObject a = (RenderableObject)m_children[index];
RenderableObject b = (RenderableObject)m_children[index + 1];
if (a.RenderPriority > b.RenderPriority)
{
// Swap
m_children[index] = b;
m_children[index + 1] = a;
index = 0;
continue;
}
index++;
}
}
/// <summary>
/// Return the first direct child with a given name.
/// </summary>
/// <example>Get the placenames LayerSet.
/// <code>
/// RenderableObject placenames = CurrentWorld.RenderableObjects.GetObject("Placenames"));
/// </code></example>
/// <param name="name">The name to search for</param>
/// <returns>The first <c>RenderableObject</c> that matched the specified name, or <c>nullk</c> if none was found.</returns>
public virtual RenderableObject GetObject(string name)
{
RenderableObject result = null;
m_childrenRWLock.AcquireReaderLock(Timeout.Infinite);
try
{
foreach (RenderableObject ro in this.m_children)
{
if (ro.Name.Equals(name))
{
result = ro;
break;
}
}
}
finally
{
m_childrenRWLock.ReleaseReaderLock();
}
return(result);
}
/// <summary>
/// if ro is chart, then add it to list.
/// </summary>
/// <param name="ro"></param>
public override void Add(RenderableObject ro)
{
MyChart c = ro as MyChart;
if (c == null) {
ro.Dispose();
return;
}
c.ParentWorld = this.ParentWorld;
base.m_children.Add(ro);
// the first chart added to this layer
if (base.Count == 1) {
this.east = c.Longitude;
this.west = c.Longitude;
this.south = c.Latitude;
this.north = c.Latitude;
}
else {
if (this.east
< c.Longitude) {
this.east = c.Longitude;
}
if (this.west
> c.Longitude) {
this.west = c.Longitude;
}
if (this.north
< c.Latitude) {
this.north = c.Latitude;
}
if (this.south
> c.Latitude) {
this.south = c.Latitude;
}
}
base.Inited = false;
}
public void FindMoonLayer()
{
string s = "";
foreach (RenderableObject l in world.RenderableObjects.ChildObjects)
{
s += l.Name + ", ";
if (l.Name.IndexOf("Moon") != -1) MoonLayer = l;
}
CheckMoonLayer = false;
//MessageBox.Show("Names : " + s, "Layer list", MessageBoxButtons.OK, MessageBoxIcon.Error );
}
private void saveRenderableState(RenderableObject ro)
{
string path = getRenderablePathString(ro);
bool found = false;
for (int i = 0; i < World.Settings.loadedLayers.Count; i++)
{
string s = (string)World.Settings.loadedLayers[i];
if (s.Equals(path))
{
if (!ro.IsOn)
{
World.Settings.loadedLayers.RemoveAt(i);
break;
}
else
{
found = true;
}
}
}
if (!found && ro.IsOn)
{
World.Settings.loadedLayers.Add(path);
}
}
public override void ExportProcess(DrawArgs drawArgs, RenderableObject.ExportInfo expInfo)
{
foreach (VeTile oTile in veTiles)
{
double dNorth = (oTile.MaxY - expInfo.dMaxLat) / (expInfo.dMinLat - expInfo.dMaxLat) * expInfo.iPixelsY;
double dSouth = (oTile.MinY - expInfo.dMaxLat) / (expInfo.dMinLat - expInfo.dMaxLat) * expInfo.iPixelsY;
double dEast = (oTile.MaxX - expInfo.dMinLon) / (expInfo.dMaxLon - expInfo.dMinLon) * expInfo.iPixelsX;
double dWest = (oTile.MinX - expInfo.dMinLon) / (expInfo.dMaxLon - expInfo.dMinLon) * expInfo.iPixelsX;
using (Image oMap = oTile.getBitmap(cacheDirectory, datasetName))
{
expInfo.gr.DrawImage(oMap, new Rectangle((int)dWest, (int)dNorth, (int)(dEast - dWest), (int)(dSouth - dNorth)));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Menu.LayerMenuItem"/> class.
/// </summary>
/// <param name="parent"></param>
/// <param name="renderableObject"></param>
public LayerMenuItem(LayerManagerMenu parent, RenderableObject renderableObject)
{
m_renderableObject = renderableObject;
m_parent = parent;
}
/// <summary>
/// Add a child object to this layer.
/// </summary>
/// <param name="ro">The renderable object to add to this layer</param>
public override void Add(RenderableObject ro)
{
ro.ParentList = this;
base.Add(ro);
}
/// <summary>
/// Add a child object to this layer.
/// </summary>
public override void Add(RenderableObject ro)
{
m_children.Add(ro);
isInitialized = false;
}
/// <summary>
/// Removes all deleted ROs. Called only in Update (Worker thread)
/// </summary>
private void Remove()
{
// get the writer lock for the delList because we need to clear at the end.
// if we just do a reader lock and upgrade you can get another
// writer in there which means we'd clear the delList before
// we remove new items for deletion from the child list.
m_delRWLock.AcquireWriterLock(Timeout.Infinite);
try
{
// if we need to clear everyone just do it.
if (m_delAll)
{
if (GetWriterLock(10))
{
try
{
while (m_children.Count > 0)
{
RenderableObject ro = (RenderableObject)m_children[0];
m_children.RemoveAt(0);
ro.Dispose();
}
}
finally
{
m_childrenRWLock.ReleaseWriterLock();
}
m_delAll = false;
// we can safely clear the list
m_delList.Clear();
}
else
{
// try next update cycle
}
}
else
{
// get a writer lock so we can remove from the child list
if (GetWriterLock(10))
{
try
{
foreach (object data in m_delList)
{
RenderableObject rod = data as RenderableObject;
if (rod != null)
{
this.m_children.Remove(rod);
rod.ParentList = null;
rod.Dispose();
}
string objectName = data as String;
if (objectName != null)
{
for (int i = 0; i < this.m_children.Count; i++)
{
RenderableObject ro = (RenderableObject)this.m_children[i];
if (ro.Name.Equals(objectName))
{
this.m_children.RemoveAt(i);
ro.ParentList = null;
ro.Dispose();
break;
}
}
}
}
// we can safely clear the list
m_delList.Clear();
}
finally
{
m_childrenRWLock.ReleaseWriterLock();
}
}
else
{
// try next update cycle
}
}
}
finally
{
m_delRWLock.ReleaseWriterLock();
}
}
private void AddLayerMenuButtons(WorldWindow ww, RenderableObject ro)
{
if(ro.MetaData.Contains("ToolBarImagePath"))
{
string imagePath = Path.Combine(DirectoryPath, (string)ro.MetaData["ToolBarImagePath"]);
if(File.Exists(imagePath))
{
LayerShortcutMenuButton button = new LayerShortcutMenuButton(imagePath, ro);
ww.MenuBar.AddLayersMenuButton( button );
//HACK: Temporary fix
if( ro.Name=="Placenames" )
button.SetPushed( World.Settings.ShowPlacenames );
if( ro.Name=="Boundaries" )
button.SetPushed( World.Settings.ShowBoundaries );
}
}
if(ro.GetType() == typeof(RenderableObjectList))
{
RenderableObjectList rol = (RenderableObjectList)ro;
foreach(RenderableObject child in rol.ChildObjects)
AddLayerMenuButtons(ww, child);
}
}
public static string GetRenderablePathString(RenderableObject renderable)
{
return getRenderablePathString(renderable);
}
/// <summary>
/// Add a child object to this layer. If the new object has the same name as an existing object in this
/// ROL it gets a number appended. If the new object is a ROL and there was already a ROL with the same
/// name then the children of the new ROL gets added to the old ROL.
///
/// Not sure who uses this but the functionality was kept this way.
/// </summary>
public virtual void Add(RenderableObject ro)
{
ro.ParentList = this;
RenderableObjectList dupList = null;
RenderableObject duplicate = null;
// We get a write lock here because if you get a reader lock and then upgrade
// the data can change on us before we get the write lock.
//
// This is somewhat unfortunate since we spend a bit of time going through the
// child list.
//
// if we can't get the writer lock in 2 seconds something is probably borked
if (GetWriterLock(200))
{
try
{
// find duplicate names
foreach (RenderableObject childRo in m_children)
{
if (childRo is RenderableObjectList &&
ro is RenderableObjectList &&
childRo.Name == ro.Name)
{
dupList = (RenderableObjectList)childRo;
break;
}
else if (childRo.Name == ro.Name)
{
duplicate = childRo;
break;
}
}
// if we have two ROLs with the same name, don't rename the new ROL but add the children of the new ROL to the
// existing ROL.
if (dupList != null)
{
RenderableObjectList rol = (RenderableObjectList)ro;
foreach (RenderableObject childRo in rol.ChildObjects)
{
dupList.Add(childRo);
}
}
else
{
// Try to find an unused number for this name
if (duplicate != null)
{
for (int i = 1; i < 1000; i++)
{
ro.Name = string.Format("{0} [{1}]", duplicate.Name, i);
bool found = false;
foreach (RenderableObject childRo in m_children)
{
if (childRo.Name == ro.Name)
{
found = true;
break;
}
}
if (!found)
{
break;
}
}
}
// Add the new child
m_children.Add(ro);
// Resort during the next update
// NeedsSort = true;
}
}
finally
{
m_childrenRWLock.ReleaseWriterLock();
}
}
else
{
MessageBox.Show("Unable to add new object " + ro.Name);
}
}
/// <summary>
/// Add a child object to this layer.
/// </summary>
public override void Add(RenderableObject ro)
{
m_children.Add(ro);
m_childrenToInit.Add(ro);
// force an initialize on all the children
m_needToInitChildren = true;
}
private RenderableObjectList GetActiveBMNG(RenderableObject roBMNG)
{
if (roBMNG is RenderableObjectList)
{
if ((roBMNG as RenderableObjectList).ChildObjects.Count == 2 && roBMNG.isInitialized)
return roBMNG as RenderableObjectList;
for (int i = 0; i < (roBMNG as RenderableObjectList).Count; i++)
{
RenderableObject ro = (RenderableObject)(roBMNG as RenderableObjectList).ChildObjects[i];
if (ro is RenderableObjectList)
{
if ((ro as RenderableObjectList).ChildObjects.Count != 2)
{
for (int j = 0; j < (ro as RenderableObjectList).Count; j++)
{
RenderableObjectList roRet = GetActiveBMNG((RenderableObject)(ro as RenderableObjectList).ChildObjects[j]);
if (roRet != null)
return roRet;
}
}
else if (ro.isInitialized)
return ro as RenderableObjectList;
}
}
}
return null;
}
public override void InitExportInfo(DrawArgs drawArgs, RenderableObject.ExportInfo info)
{
lock (veTiles)
{
int iMinCol = int.MaxValue;
int iMaxCol = int.MinValue;
int iMinRow = int.MaxValue;
int iMaxRow = int.MinValue;
foreach (VeTile oTile in veTiles)
{
iMinRow = Math.Min(oTile.Row, iMinRow);
iMaxRow = Math.Max(oTile.Row, iMaxRow);
iMinCol = Math.Min(oTile.Col, iMinCol);
iMaxCol = Math.Max(oTile.Col, iMaxCol);
info.dMinLat = Math.Min(info.dMinLat, oTile.MinY);
info.dMaxLat = Math.Max(info.dMaxLat, oTile.MaxY);
info.dMinLon = Math.Min(info.dMinLon, oTile.MinX);
info.dMaxLon = Math.Max(info.dMaxLon, oTile.MaxX);
}
info.iPixelsX = (iMaxCol - iMinCol + 1) * pixelsPerTile;
info.iPixelsY = (iMaxRow - iMinRow + 1) * pixelsPerTile;
}
}
private void UpdateRenderable(RenderableObject oldRenderable, RenderableObject newRenderable)
{
if(oldRenderable is Icon && newRenderable is Icon)
{
Icon oldIcon = (Icon)oldRenderable;
Icon newIcon = (Icon)newRenderable;
oldIcon.SetPosition( (float)newIcon.Latitude, (float)newIcon.Longitude, (float)newIcon.Altitude);
}
else if(oldRenderable is RenderableObjectList && newRenderable is RenderableObjectList)
{
RenderableObjectList oldList = (RenderableObjectList)oldRenderable;
RenderableObjectList newList = (RenderableObjectList)newRenderable;
compareRefreshLists(newList, oldList);
}
}
private int getIRenderableIndexFromParent(RenderableObject renderable)
{
if (renderable.ParentList == null) {
return -1;
}
else {
for (int index = 0; index < renderable.ParentList.ChildObjects.Count; index++) {
if (renderable == renderable.ParentList.ChildObjects[index]) {
return index;
}
}
}
return -1;
}
private static void addExtendedInformation(XPathNodeIterator iter, RenderableObject renderable)
{
if (iter.Count > 0)
{
while (iter.MoveNext())
{
string toolBarImage = getInnerTextFromFirstChild(iter.Current.Select("ToolBarImage"));
if (toolBarImage != null)
{
if (toolBarImage.Length > 0 && !Path.IsPathRooted(toolBarImage))
Path.Combine(
Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath),
toolBarImage);
renderable.MetaData.Add("ToolBarImagePath", toolBarImage);
}
}
}
}
public static bool IsLayerOn(RenderableObject ro)
{
string path = getRenderablePathString(ro);
foreach(string s in World.Settings.loadedLayers)
{
if(s.Equals(path))
{
return true;
}
}
return false;
}
private void resetQuadTileSetCache(RenderableObject ro)
{
if(ro.IsOn && ro is QuadTileSet)
{
QuadTileSet qts = (QuadTileSet)ro;
qts.ResetCacheForCurrentView(worldWindow.DrawArgs.WorldCamera);
}
else if(ro is RenderableObjectList)
{
RenderableObjectList rol = (RenderableObjectList)ro;
foreach(RenderableObject curRo in rol.ChildObjects)
{
resetQuadTileSetCache(curRo);
}
}
}
private void CascadeOpacity(RenderableObject oRObject, byte bOpacity)
{
oRObject.Opacity = bOpacity;
if (oRObject is RenderableObjectList)
{
foreach (RenderableObject oChildRObject in ((RenderableObjectList)oRObject).ChildObjects)
{
CascadeOpacity(oChildRObject, bOpacity);
}
}
}
private void refreshTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
if (isUpdating)
{
return;
}
isUpdating = true;
try
{
for (int i = 0; i < this.ChildObjects.Count; i++)
{
RenderableObject ro = (RenderableObject)this.ChildObjects[i];
if (ro != null && ro.IsOn && ro is Icon)
{
Icon icon = (Icon)ro;
if (icon.RefreshInterval == TimeSpan.MaxValue || icon.LastRefresh > System.DateTime.Now - icon.RefreshInterval)
{
continue;
}
object key = null;
IconTexture iconTexture = null;
if (icon.TextureFileName != null && icon.TextureFileName.Length > 0)
{
iconTexture = (IconTexture)DrawArgs.Textures[icon.TextureFileName];
if (iconTexture != null)
{
iconTexture.UpdateTexture(DrawArgs.Device, icon.TextureFileName);
}
else
{
key = icon.TextureFileName;
iconTexture = new IconTexture(DrawArgs.Device, icon.TextureFileName);
iconTexture.ReferenceCount++;
// New texture, cache it
DrawArgs.Textures.Add(key, iconTexture);
// Use default dimensions if not set
if (icon.Width == 0)
{
icon.Width = iconTexture.Width;
}
if (icon.Height == 0)
{
icon.Height = iconTexture.Height;
}
}
}
else
{
// Icon image from bitmap
if (icon.Image != null)
{
iconTexture = (IconTexture)DrawArgs.Textures[icon.Image];
if (iconTexture != null)
{
IconTexture tempTexture = iconTexture;
DrawArgs.Textures[icon.SaveFilePath] = new IconTexture(DrawArgs.Device, icon.Image);
tempTexture.Dispose();
}
else
{
key = icon.SaveFilePath;
iconTexture = new IconTexture(DrawArgs.Device, icon.Image);
// New texture, cache it
DrawArgs.Textures.Add(key, iconTexture);
// Use default dimensions if not set
if (icon.Width == 0)
{
icon.Width = iconTexture.Width;
}
if (icon.Height == 0)
{
icon.Height = iconTexture.Height;
}
}
}
}
icon.LastRefresh = System.DateTime.Now;
}
}
}
catch { }
finally
{
isUpdating = false;
}
}
internal BlueMarbleBuilder(RenderableObject hObject)
: base("Blue Marble", MainForm.WorldWindowSingleton, null)
{
m_hObject = hObject;
}
private void refreshTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
if (isUpdating)
{
return;
}
isUpdating = true;
try
{
for (int i = 0; i < this.ChildObjects.Count; i++)
{
RenderableObject ro = (RenderableObject)this.ChildObjects[i];
if (ro != null && ro.IsOn && ro is Icon)
{
Icon icon = (Icon)ro;
if (icon.RefreshInterval == TimeSpan.MaxValue || icon.LastRefresh > System.DateTime.Now - icon.RefreshInterval)
{
continue;
}
object key = null;
IconTexture iconTexture = null;
if (icon.TextureFileName != null && icon.TextureFileName.Length > 0)
{
if (icon.TextureFileName.ToLower().StartsWith("http://") && icon.SaveFilePath != null)
{
//download it
try
{
WorldWind.Net.WebDownload webDownload = new WorldWind.Net.WebDownload(icon.TextureFileName);
webDownload.DownloadType = WorldWind.Net.DownloadType.Unspecified;
System.IO.FileInfo saveFile = new System.IO.FileInfo(icon.SaveFilePath);
if (!saveFile.Directory.Exists)
{
saveFile.Directory.Create();
}
webDownload.DownloadFile(saveFile.FullName);
}
catch {}
iconTexture = (IconTexture)m_textures[icon.SaveFilePath];
if (iconTexture != null)
{
IconTexture tempTexture = iconTexture;
m_textures[icon.SaveFilePath] = new IconTexture(DrawArgs.Device, icon.SaveFilePath);
tempTexture.Dispose();
}
else
{
key = icon.SaveFilePath;
iconTexture = new IconTexture(DrawArgs.Device, icon.SaveFilePath);
// New texture, cache it
m_textures.Add(key, iconTexture);
// Use default dimensions if not set
if (icon.Width == 0)
{
icon.Width = iconTexture.Width;
}
if (icon.Height == 0)
{
icon.Height = iconTexture.Height;
}
}
}
else
{
// Icon image from file
iconTexture = (IconTexture)m_textures[icon.TextureFileName];
if (iconTexture != null)
{
IconTexture tempTexture = iconTexture;
m_textures[icon.SaveFilePath] = new IconTexture(DrawArgs.Device, icon.TextureFileName);
tempTexture.Dispose();
}
else
{
key = icon.SaveFilePath;
iconTexture = new IconTexture(DrawArgs.Device, icon.TextureFileName);
// New texture, cache it
m_textures.Add(key, iconTexture);
// Use default dimensions if not set
if (icon.Width == 0)
{
icon.Width = iconTexture.Width;
}
if (icon.Height == 0)
{
icon.Height = iconTexture.Height;
}
}
}
}
else
{
// Icon image from bitmap
if (icon.Image != null)
{
iconTexture = (IconTexture)m_textures[icon.Image];
if (iconTexture != null)
{
IconTexture tempTexture = iconTexture;
m_textures[icon.SaveFilePath] = new IconTexture(DrawArgs.Device, icon.Image);
tempTexture.Dispose();
}
else
{
key = icon.SaveFilePath;
iconTexture = new IconTexture(DrawArgs.Device, icon.Image);
// New texture, cache it
m_textures.Add(key, iconTexture);
// Use default dimensions if not set
if (icon.Width == 0)
{
icon.Width = iconTexture.Width;
}
if (icon.Height == 0)
{
icon.Height = iconTexture.Height;
}
}
}
}
icon.LastRefresh = System.DateTime.Now;
}
}
}
catch {}
finally
{
isUpdating = false;
}
}
private static string getRenderablePathString(RenderableObject renderable)
{
if(renderable.ParentList == null)
{
return renderable.Name;
}
else
{
return getRenderablePathString(renderable.ParentList) + Path.DirectorySeparatorChar + renderable.Name;
}
}
private bool CascadeDownloading(RenderableObject oObj, out int iBytesRead, out int iTotalBytes)
{
if (oObj.Initialized && oObj.IsOn)
{
if (oObj is QuadTileSet)
{
return ((QuadTileSet)oObj).bIsDownloading(out iBytesRead, out iTotalBytes);
}
else if (oObj is RenderableObjectList)
{
bool result = false;
int iResultRead = 0;
int iResultTotal = 0;
foreach (RenderableObject oRO in ((RenderableObjectList)oObj).ChildObjects)
{
int iRead, iTotal;
result |= CascadeDownloading(oRO, out iRead, out iTotal);
iResultRead += iRead;
iResultTotal += iTotal;
}
iBytesRead = iResultRead;
iTotalBytes = iResultTotal;
return result;
}
}
iBytesRead = 0;
iTotalBytes = 0;
return false;
}
void m_imgLayer_LoadFailed(RenderableObject oRO, string message)
{
m_blnFailed = true;
m_imgLayer.IsOn = false;
SendBuilderChanged(BuilderChangeType.LoadedASyncFailed);
}
/// <summary>
/// Add a child object to this layer.
/// </summary>
public virtual void Add(RenderableObject ro)
{
try
{
lock (this.m_children.SyncRoot)
{
RenderableObjectList dupList = null;
RenderableObject duplicate = null;
ro.ParentList = this;
foreach (RenderableObject childRo in m_children)
{
if (childRo is RenderableObjectList && childRo.Name == ro.Name)
{
dupList = (RenderableObjectList)childRo;
break;
}
else if (childRo.Name == ro.Name)
{
duplicate = childRo;
break;
}
}
if (dupList != null)
{
RenderableObjectList rol = (RenderableObjectList)ro;
foreach (RenderableObject childRo in rol.ChildObjects)
{
dupList.Add(childRo);
}
}
else
{
if (duplicate != null)
{
for (int i = 1; i < 100; i++)
{
ro.Name = string.Format("{0} [{1}]", duplicate.Name, i);
bool found = false;
foreach (RenderableObject childRo in m_children)
{
if (childRo.Name == ro.Name)
{
found = true;
break;
}
}
if (!found)
{
break;
}
}
}
m_children.Add(ro);
}
SortChildren();
}
}
catch
{
}
}
/// <summary>
/// Add a child object to this layer.
/// </summary>
public override void Add(RenderableObject ro)
{
m_children.Add(ro);
isInitialized = false;
}
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Menu.LayerShortcutMenuButton"/> class.
/// </summary>
/// <param name="imageFilePath"></param>
/// <param name="ro"></param>
public LayerShortcutMenuButton(
string imageFilePath, WorldWind.Renderable.RenderableObject ro)
: base(imageFilePath)
{
this.Description = ro.Name;
this._ro = ro;
this._isPushed = ro.IsOn;
}
/// <summary>
/// Add a child object to this layer.
/// </summary>
public virtual void Add(RenderableObject ro)
{
try
{
lock(this.m_children.SyncRoot)
{
RenderableObjectList dupList = null;
RenderableObject duplicate = null;
ro.ParentList = this;
foreach(RenderableObject childRo in m_children)
{
if(childRo is RenderableObjectList && childRo.Name == ro.Name)
{
dupList = (RenderableObjectList)childRo;
break;
}
else if(childRo.Name == ro.Name)
{
duplicate = childRo;
break;
}
}
if(dupList != null)
{
RenderableObjectList rol = (RenderableObjectList)ro;
foreach(RenderableObject childRo in rol.ChildObjects)
{
dupList.Add(childRo);
}
}
else
{
if(duplicate != null)
{
for(int i = 1; i < 100; i++)
{
ro.Name = string.Format("{0} [{1}]", duplicate.Name, i);
bool found = false;
foreach(RenderableObject childRo in m_children)
{
if(childRo.Name == ro.Name)
{
found = true;
break;
}
}
if(!found)
{
break;
}
}
}
m_children.Add(ro);
}
SortChildren();
}
}
catch
{
}
}
private void m_UpdateTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
try
{
System.DateTime updateStart = System.DateTime.Now;
for (int i = 0; i < m_WorldWindow.CurrentWorld.RenderableObjects.Count; i++)
{
WorldWind.Renderable.RenderableObject curRo = (WorldWind.Renderable.RenderableObject)m_WorldWindow.CurrentWorld.RenderableObjects.ChildObjects[i];
if (i >= this.treeView1.Nodes.Count)
{
// Add a node
TreeNode correctNode = new TreeNode(curRo.Name);
RenderableObjectInfo curRoi = new RenderableObjectInfo();
curRoi.Renderable = curRo;
correctNode.Tag = curRoi;
m_NodeHash.Add(correctNode.Text, correctNode);
this.treeView1.BeginInvoke(new AddTableTreeDelegate(this.AddTableTree), new object[] { correctNode });
updateNode(correctNode);
}
else
{
//compare nodes
TreeNode curTn = this.treeView1.Nodes[i];
RenderableObjectInfo curRoi = (RenderableObjectInfo)curTn.Tag;
if (curRoi.Renderable != null && curRoi.Renderable.Name == curRo.Name)
{
updateNode(curTn);
continue;
}
else
{
if (!m_NodeHash.Contains(curRo.Name))
{
//add it
curRoi = new RenderableObjectInfo();
curRoi.Renderable = curRo;
curTn = new TreeNode(curRo.Name);
curTn.Tag = curRoi;
m_NodeHash.Add(curTn.Text, curTn);
this.treeView1.BeginInvoke(new InsertTableTreeDelegate(this.InsertTableTree), new object[] { i, curTn });
}
else
{
curTn = (TreeNode)m_NodeHash[curRo.Name];
try
{
treeView1.BeginInvoke(new RemoveTableTreeDelegate(this.RemoveTableTree), new object[] { curTn });
}
catch
{}
treeView1.BeginInvoke(new InsertTableTreeDelegate(this.InsertTableTree), new object[] { i, curTn });
}
}
updateNode(curTn);
}
}
for (int i = m_WorldWindow.CurrentWorld.RenderableObjects.Count; i < this.treeView1.Nodes.Count; i++)
{
this.treeView1.BeginInvoke(new RemoveAtTableTreeDelegate(this.RemoveAtTableTree), new object[] { i });
}
System.Collections.ArrayList deletionList = new ArrayList();
foreach (TreeNode tn in m_NodeHash.Values)
{
RenderableObjectInfo roi = (RenderableObjectInfo)tn.Tag;
if (roi == null || roi.Renderable == null || roi.LastSpotted < updateStart)
{
deletionList.Add(GetAbsoluteRenderableObjectPath(roi.Renderable));
}
}
foreach (string key in deletionList)
{
m_NodeHash.Remove(key);
}
}
catch
{}
}
/// <summary>
/// Removes a layer from the child layer list
/// </summary>
/// <param name="layer">Layer to be removed.</param>
public virtual void Remove(RenderableObject layer)
{
lock(this.m_children.SyncRoot)
{
this.m_children.Remove(layer);
layer.Dispose();
layer.ParentList = null;
}
}
private string getZOrderStringFromIRenderable(RenderableObject renderable)
{
if (renderable.ParentList != null) {
return getZOrderStringFromIRenderable(renderable.ParentList) + "." + getIRenderableIndexFromParent(renderable).ToString().PadLeft(5, '0');
}
else {
return "";
}
}
private void setLayerOpacity(RenderableObject ro, string category, string name, float opacity)
{
foreach (string key in ro.MetaData.Keys)
{
if (String.Compare(key, category, true, System.Globalization.CultureInfo.InvariantCulture) == 0)
{
if (ro.MetaData[key].GetType() == typeof(String))
{
string curValue = ro.MetaData[key] as string;
if (String.Compare(curValue, name, true, System.Globalization.CultureInfo.InvariantCulture) == 0)
{
ro.Opacity = (byte)(255 * opacity);
}
}
break;
}
}
RenderableObjectList rol = ro as RenderableObjectList;
if (rol != null)
{
foreach (RenderableObject childRo in rol.ChildObjects)
setLayerOpacity(childRo, category, name, opacity);
}
}
