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); }
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 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); } }