Exemple #1
0
 public SourceMap(IDocumentFuture documentDescriptor, SourceMap.GetFilenameContext filenameContextDelegate, DirtyEvent parentDirty, DirtyEvent parentReadyToLockEvent)
 {
     this.dirtyEvent = new DirtyEvent(parentDirty);
     this.readyToLockChangedEvent = new DirtyEvent(parentReadyToLockEvent);
     this._documentFuture = new GeneralDocumentFuture(documentDescriptor);
     this._displayName = documentDescriptor.GetDefaultDisplayName();
     this.filenameContextDelegate = filenameContextDelegate;
     this._sourceMapInfo = new SourceMapInfo(this.dirtyEvent);
     this._sourceMapRenderOptions = new SourceMapRenderOptions(this.dirtyEvent);
     this._transparencyOptions = new TransparencyOptions(this.dirtyEvent);
     this.registration = new RegistrationDefinition(this.dirtyEvent);
     this.registration.dirtyEvent.Add(this.readyToLockChangedEvent);
     this.latentRegionHolder = new LatentRegionHolder(this.dirtyEvent, this.readyToLockChangedEvent);
     this.legendList = new LegendList(this, this.dirtyEvent, this.readyToLockChangedEvent);
     this.renderRegion = null;
 }
Exemple #2
0
 public SourceMap(IDocumentFuture documentDescriptor, SourceMap.GetFilenameContext filenameContextDelegate, DirtyEvent parentDirty, DirtyEvent parentReadyToLockEvent)
 {
     this.dirtyEvent = new DirtyEvent(parentDirty);
     this.readyToLockChangedEvent = new DirtyEvent(parentReadyToLockEvent);
     this._documentFuture         = new GeneralDocumentFuture(documentDescriptor);
     this._displayName            = documentDescriptor.GetDefaultDisplayName();
     this.filenameContextDelegate = filenameContextDelegate;
     this._sourceMapInfo          = new SourceMapInfo(this.dirtyEvent);
     this._sourceMapRenderOptions = new SourceMapRenderOptions(this.dirtyEvent);
     this._transparencyOptions    = new TransparencyOptions(this.dirtyEvent);
     this.registration            = new RegistrationDefinition(this.dirtyEvent);
     this.registration.dirtyEvent.Add(this.readyToLockChangedEvent);
     this.latentRegionHolder = new LatentRegionHolder(this.dirtyEvent, this.readyToLockChangedEvent);
     this.legendList         = new LegendList(this, this.dirtyEvent, this.readyToLockChangedEvent);
     this.renderRegion       = null;
 }
Exemple #3
0
 public SourceMap(MashupParseContext context, SourceMap.GetFilenameContext filenameContextDelegate, DirtyEvent parentDirty, DirtyEvent parentReadyToLockEvent)
 {
     this.dirtyEvent = new DirtyEvent(parentDirty);
     this.readyToLockChangedEvent = new DirtyEvent(parentReadyToLockEvent);
     this.filenameContextDelegate = filenameContextDelegate;
     this.latentRegionHolder = new LatentRegionHolder(this.dirtyEvent, this.readyToLockChangedEvent);
     XMLTagReader xMLTagReader = context.NewTagReader("SourceMap");
     context.ExpectIdentity(this);
     string attribute = context.reader.GetAttribute("SourceMapFilename");
     if (attribute != null)
     {
         string path = Path.Combine(filenameContextDelegate(), attribute);
         int pageNumber = 0;
         context.GetAttributeInt("PageNumber", ref pageNumber);
         this._documentFuture = new GeneralDocumentFuture(new FutureDocumentFromFilesystem(path, pageNumber));
     }
     context.GetAttributeBoolean("Expanded", ref this._expanded);
     string attribute2 = context.reader.GetAttribute("DisplayName");
     MapPosition mapPosition = null;
     MapPosition mapPosition2 = null;
     while (xMLTagReader.FindNextStartTag())
     {
         if (xMLTagReader.TagIs(RegistrationDefinition.GetXMLTag()))
         {
             context.AssertUnique(this.registration);
             this.registration = new RegistrationDefinition(context, this.dirtyEvent);
         }
         else
         {
             if (xMLTagReader.TagIs(GeneralDocumentFuture.GetXMLTag()))
             {
                 context.AssertUnique(this._documentFuture);
                 this._documentFuture = new GeneralDocumentFuture(context, filenameContextDelegate());
             }
             else
             {
                 if (xMLTagReader.TagIs(LocalDocumentDescriptor.GetXMLTag()))
                 {
                     context.AssertUnique(this._documentFuture);
                     LocalDocumentDescriptor localDocumentDescriptor = new LocalDocumentDescriptor(context, filenameContextDelegate());
                     this._documentFuture = new GeneralDocumentFuture(new FutureDocumentFromFilesystem(localDocumentDescriptor.GetFilesystemAbsolutePath(), localDocumentDescriptor.GetPageNumber()));
                 }
                 else
                 {
                     if (xMLTagReader.TagIs("LastSourceMapPosition"))
                     {
                         XMLTagReader xMLTagReader2 = context.NewTagReader("LastSourceMapPosition");
                         while (xMLTagReader2.FindNextStartTag())
                         {
                             if (xMLTagReader2.TagIs(MapPosition.GetXMLTag(context.version)))
                             {
                                 mapPosition = new MapPosition(context, null, ContinuousCoordinateSystem.theInstance);
                             }
                         }
                     }
                     else
                     {
                         if (xMLTagReader.TagIs("LastVEPosition"))
                         {
                             XMLTagReader xMLTagReader3 = context.NewTagReader("LastVEPosition");
                             while (xMLTagReader3.FindNextStartTag())
                             {
                                 if (xMLTagReader3.TagIs(MapPosition.GetXMLTag(context.version)))
                                 {
                                     mapPosition2 = new MapPosition(context, null, MercatorCoordinateSystem.theInstance);
                                 }
                             }
                         }
                         else
                         {
                             if (xMLTagReader.TagIs(RenderRegion.GetXMLTag()))
                             {
                                 context.AssertUnique(this.renderRegion);
                                 this.renderRegion = new RenderRegion(context, this.dirtyEvent, ContinuousCoordinateSystem.theInstance);
                             }
                             else
                             {
                                 if (xMLTagReader.TagIs(SourceMapInfo.GetXMLTag()))
                                 {
                                     context.AssertUnique(this._sourceMapInfo);
                                     this._sourceMapInfo = new SourceMapInfo(context, this.dirtyEvent);
                                 }
                                 else
                                 {
                                     if (xMLTagReader.TagIs(SourceMapRenderOptions.GetXMLTag()))
                                     {
                                         context.AssertUnique(this._sourceMapRenderOptions);
                                         this._sourceMapRenderOptions = new SourceMapRenderOptions(context, this.dirtyEvent);
                                     }
                                     else
                                     {
                                         if (xMLTagReader.TagIs(TransparencyOptions.GetXMLTag()))
                                         {
                                             this._transparencyOptions = new TransparencyOptions(context, this.dirtyEvent);
                                         }
                                         else
                                         {
                                             if (xMLTagReader.TagIs(SourceMapRegistrationView.GetXMLTag()))
                                             {
                                                 context.AssertUnique(this._lastView);
                                                 this._lastView = new SourceMapRegistrationView(this, context);
                                             }
                                             else
                                             {
                                                 if (xMLTagReader.TagIs(LegendList.GetXMLTag()))
                                                 {
                                                     context.AssertUnique(this.legendList);
                                                     this.legendList = new LegendList(this, context, this.dirtyEvent);
                                                 }
                                                 else
                                                 {
                                                     if (xMLTagReader.TagIs("SnapView"))
                                                     {
                                                         XMLTagReader xMLTagReader4 = context.NewTagReader("SnapView");
                                                         string requiredAttribute = context.GetRequiredAttribute("Context");
                                                         LatLonZoom latLonZoom = default(LatLonZoom);
                                                         bool flag = false;
                                                         bool flag2 = true;
                                                         CoordinateSystemIfc coordSys = null;
                                                         if (requiredAttribute == "Source")
                                                         {
                                                             coordSys = ContinuousCoordinateSystem.theInstance;
                                                         }
                                                         else
                                                         {
                                                             if (!(requiredAttribute == "Reference"))
                                                             {
                                                                 throw new InvalidMashupFile(context, string.Format("Invalid {0} value {1}", "Context", requiredAttribute));
                                                             }
                                                             coordSys = MercatorCoordinateSystem.theInstance;
                                                         }
                                                         while (xMLTagReader4.FindNextStartTag())
                                                         {
                                                             if (xMLTagReader4.TagIs(LatLonZoom.GetXMLTag()))
                                                             {
                                                                 if (flag)
                                                                 {
                                                                     context.ThrowUnique();
                                                                 }
                                                                 try
                                                                 {
                                                                     latLonZoom = new LatLonZoom(context, coordSys);
                                                                 }
                                                                 catch (InvalidLLZ)
                                                                 {
                                                                     flag2 = false;
                                                                 }
                                                                 flag = true;
                                                             }
                                                         }
                                                         if (flag2)
                                                         {
                                                             if (!flag)
                                                             {
                                                                 context.AssertPresent(null, LatLonZoom.GetXMLTag());
                                                             }
                                                             if (requiredAttribute == "Source")
                                                             {
                                                                 this.sourceSnap = latLonZoom;
                                                             }
                                                             else
                                                             {
                                                                 if (requiredAttribute == "Reference")
                                                                 {
                                                                     this.referenceSnap = latLonZoom;
                                                                 }
                                                                 else
                                                                 {
                                                                     D.Assert(false, "handled above.");
                                                                 }
                                                             }
                                                         }
                                                     }
                                                     else
                                                     {
                                                         if (xMLTagReader.TagIs("SnapZoom"))
                                                         {
                                                             context.NewTagReader("SnapZoom");
                                                             string requiredAttribute2 = context.GetRequiredAttribute("Context");
                                                             bool flag3 = false;
                                                             CoordinateSystemIfc theInstance;
                                                             if (requiredAttribute2 == "Source")
                                                             {
                                                                 theInstance = ContinuousCoordinateSystem.theInstance;
                                                             }
                                                             else
                                                             {
                                                                 if (!(requiredAttribute2 == "Reference"))
                                                                 {
                                                                     throw new InvalidMashupFile(context, string.Format("Invalid {0} value {1}", "Context", requiredAttribute2));
                                                                 }
                                                                 theInstance = MercatorCoordinateSystem.theInstance;
                                                             }
                                                             int num = 0;
                                                             try
                                                             {
                                                                 theInstance.GetZoomRange().Parse(context, "Zoom");
                                                                 flag3 = true;
                                                             }
                                                             catch (InvalidMashupFile)
                                                             {
                                                             }
                                                             if (flag3)
                                                             {
                                                                 if (requiredAttribute2 == "Source")
                                                                 {
                                                                     this.sourceSnapZoom = num;
                                                                 }
                                                                 else
                                                                 {
                                                                     if (requiredAttribute2 == "Reference")
                                                                     {
                                                                         this.referenceSnapZoom = num;
                                                                     }
                                                                 }
                                                             }
                                                         }
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
         if (context.version == InlineSourceMapInfoSchema.schema)
         {
             if (xMLTagReader.TagIs("MapFileURL"))
             {
                 this._sourceMapInfo.mapFileURL = XMLUtils.ReadStringXml(context, "MapFileURL");
             }
             else
             {
                 if (xMLTagReader.TagIs("MapHomePage"))
                 {
                     this._sourceMapInfo.mapHomePage = XMLUtils.ReadStringXml(context, "MapHomePage");
                 }
                 else
                 {
                     if (xMLTagReader.TagIs("MapDescription"))
                     {
                         this._sourceMapInfo.mapDescription = XMLUtils.ReadStringXml(context, "MapDescription");
                     }
                 }
             }
         }
     }
     if (attribute2 != null)
     {
         this._displayName = attribute2;
     }
     else
     {
         this._displayName = this._documentFuture.documentFuture.GetDefaultDisplayName();
     }
     if (this._lastView == null && mapPosition != null && mapPosition2 != null)
     {
         this._lastView = new SourceMapRegistrationView(this, mapPosition.llz, mapPosition2);
     }
     if (this._documentFuture == null)
     {
         throw new Exception("Source Map element missing document descriptor tag");
     }
     if (this.registration == null)
     {
         this.registration = new RegistrationDefinition(this.dirtyEvent);
     }
     this.registration.dirtyEvent.Add(this.readyToLockChangedEvent);
     if (this.legendList == null)
     {
         this.legendList = new LegendList(this, this.dirtyEvent, this.readyToLockChangedEvent);
     }
     if (this._sourceMapInfo == null)
     {
         this._sourceMapInfo = new SourceMapInfo(this.dirtyEvent);
     }
     if (this._sourceMapRenderOptions == null)
     {
         this._sourceMapRenderOptions = new SourceMapRenderOptions(this.dirtyEvent);
     }
     if (this._transparencyOptions == null)
     {
         this._transparencyOptions = new TransparencyOptions(this.dirtyEvent);
     }
 }
Exemple #4
0
        public SourceMap(MashupParseContext context, GetFilenameContext filenameContextDelegate, DirtyEvent parentDirty,
                         DirtyEvent parentReadyToLockEvent)
        {
            dirtyEvent = new DirtyEvent(parentDirty);
            readyToLockChangedEvent      = new DirtyEvent(parentReadyToLockEvent);
            this.filenameContextDelegate = filenameContextDelegate;
            latentRegionHolder           = new LatentRegionHolder(dirtyEvent, readyToLockChangedEvent);
            var xMLTagReader = context.NewTagReader("SourceMap");

            context.ExpectIdentity(this);
            string attribute = context.reader.GetAttribute("SourceMapFilename");

            if (attribute != null)
            {
                string path       = Path.Combine(filenameContextDelegate(), attribute);
                int    pageNumber = 0;
                context.GetAttributeInt("PageNumber", ref pageNumber);
                documentFuture = new GeneralDocumentFuture(new FutureDocumentFromFilesystem(path, pageNumber));
            }

            context.GetAttributeBoolean("Expanded", ref _expanded);
            string      attribute2   = context.reader.GetAttribute("DisplayName");
            MapPosition mapPosition  = null;
            MapPosition mapPosition2 = null;

            while (xMLTagReader.FindNextStartTag())
            {
                if (xMLTagReader.TagIs(RegistrationDefinition.GetXMLTag()))
                {
                    context.AssertUnique(registration);
                    registration = new RegistrationDefinition(context, dirtyEvent);
                }
                else
                {
                    if (xMLTagReader.TagIs(GeneralDocumentFuture.GetXMLTag()))
                    {
                        context.AssertUnique(documentFuture);
                        documentFuture = new GeneralDocumentFuture(context, filenameContextDelegate());
                    }
                    else
                    {
                        if (xMLTagReader.TagIs(LocalDocumentDescriptor.GetXMLTag()))
                        {
                            context.AssertUnique(documentFuture);
                            var localDocumentDescriptor =
                                new LocalDocumentDescriptor(context, filenameContextDelegate());
                            documentFuture = new GeneralDocumentFuture(
                                new FutureDocumentFromFilesystem(localDocumentDescriptor.GetFilesystemAbsolutePath(),
                                                                 localDocumentDescriptor.GetPageNumber()));
                        }
                        else
                        {
                            if (xMLTagReader.TagIs("LastSourceMapPosition"))
                            {
                                var xMLTagReader2 = context.NewTagReader("LastSourceMapPosition");
                                while (xMLTagReader2.FindNextStartTag())
                                {
                                    if (xMLTagReader2.TagIs(MapPosition.GetXMLTag(context.version)))
                                    {
                                        mapPosition = new MapPosition(context,
                                                                      null,
                                                                      ContinuousCoordinateSystem.theInstance);
                                    }
                                }
                            }
                            else
                            {
                                if (xMLTagReader.TagIs("LastVEPosition"))
                                {
                                    var xMLTagReader3 = context.NewTagReader("LastVEPosition");
                                    while (xMLTagReader3.FindNextStartTag())
                                    {
                                        if (xMLTagReader3.TagIs(MapPosition.GetXMLTag(context.version)))
                                        {
                                            mapPosition2 = new MapPosition(context,
                                                                           null,
                                                                           MercatorCoordinateSystem.theInstance);
                                        }
                                    }
                                }
                                else
                                {
                                    if (xMLTagReader.TagIs(RenderRegion.GetXMLTag()))
                                    {
                                        context.AssertUnique(renderRegion);
                                        renderRegion = new RenderRegion(context,
                                                                        dirtyEvent,
                                                                        ContinuousCoordinateSystem.theInstance);
                                    }
                                    else
                                    {
                                        if (xMLTagReader.TagIs(SourceMapInfo.GetXMLTag()))
                                        {
                                            context.AssertUnique(sourceMapInfo);
                                            sourceMapInfo = new SourceMapInfo(context, dirtyEvent);
                                        }
                                        else
                                        {
                                            if (xMLTagReader.TagIs(SourceMapRenderOptions.GetXMLTag()))
                                            {
                                                context.AssertUnique(sourceMapRenderOptions);
                                                sourceMapRenderOptions =
                                                    new SourceMapRenderOptions(context, dirtyEvent);
                                            }
                                            else
                                            {
                                                if (xMLTagReader.TagIs(TransparencyOptions.GetXMLTag()))
                                                {
                                                    transparencyOptions =
                                                        new TransparencyOptions(context, dirtyEvent);
                                                }
                                                else
                                                {
                                                    if (xMLTagReader.TagIs(SourceMapRegistrationView.GetXMLTag()))
                                                    {
                                                        context.AssertUnique(_lastView);
                                                        _lastView = new SourceMapRegistrationView(this, context);
                                                    }
                                                    else
                                                    {
                                                        if (xMLTagReader.TagIs(LegendList.GetXMLTag()))
                                                        {
                                                            context.AssertUnique(legendList);
                                                            legendList = new LegendList(this,
                                                                                        context,
                                                                                        dirtyEvent);
                                                        }
                                                        else
                                                        {
                                                            if (xMLTagReader.TagIs("SnapView"))
                                                            {
                                                                var xMLTagReader4 =
                                                                    context.NewTagReader("SnapView");
                                                                string requiredAttribute =
                                                                    context.GetRequiredAttribute("Context");
                                                                var  latLonZoom = default(LatLonZoom);
                                                                bool flag       = false;
                                                                bool flag2      = true;
                                                                CoordinateSystemIfc coordSys;
                                                                if (requiredAttribute == "Source")
                                                                {
                                                                    coordSys = ContinuousCoordinateSystem.theInstance;
                                                                }
                                                                else
                                                                {
                                                                    if (!(requiredAttribute == "Reference"))
                                                                    {
                                                                        throw new InvalidMashupFile(context,
                                                                                                    string.Format("Invalid {0} value {1}",
                                                                                                                  "Context",
                                                                                                                  requiredAttribute));
                                                                    }

                                                                    coordSys = MercatorCoordinateSystem.theInstance;
                                                                }

                                                                while (xMLTagReader4.FindNextStartTag())
                                                                {
                                                                    if (xMLTagReader4.TagIs(LatLonZoom.GetXMLTag()))
                                                                    {
                                                                        if (flag)
                                                                        {
                                                                            context.ThrowUnique();
                                                                        }

                                                                        try
                                                                        {
                                                                            latLonZoom = new LatLonZoom(context,
                                                                                                        coordSys);
                                                                        }
                                                                        catch (InvalidLLZ)
                                                                        {
                                                                            flag2 = false;
                                                                        }

                                                                        flag = true;
                                                                    }
                                                                }

                                                                if (flag2)
                                                                {
                                                                    if (!flag)
                                                                    {
                                                                        context.AssertPresent(null,
                                                                                              LatLonZoom.GetXMLTag());
                                                                    }

                                                                    if (requiredAttribute == "Source")
                                                                    {
                                                                        sourceSnap = latLonZoom;
                                                                    }
                                                                    else
                                                                    {
                                                                        if (requiredAttribute == "Reference")
                                                                        {
                                                                            referenceSnap = latLonZoom;
                                                                        }
                                                                        else
                                                                        {
                                                                            D.Assert(false, "handled above.");
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                            else
                                                            {
                                                                if (xMLTagReader.TagIs("SnapZoom"))
                                                                {
                                                                    context.NewTagReader("SnapZoom");
                                                                    string requiredAttribute2 =
                                                                        context.GetRequiredAttribute("Context");
                                                                    bool flag3 = false;
                                                                    CoordinateSystemIfc theInstance;
                                                                    if (requiredAttribute2 == "Source")
                                                                    {
                                                                        theInstance = ContinuousCoordinateSystem
                                                                                      .theInstance;
                                                                    }
                                                                    else
                                                                    {
                                                                        if (!(requiredAttribute2 == "Reference"))
                                                                        {
                                                                            throw new InvalidMashupFile(context,
                                                                                                        string.Format("Invalid {0} value {1}",
                                                                                                                      "Context",
                                                                                                                      requiredAttribute2));
                                                                        }

                                                                        theInstance = MercatorCoordinateSystem
                                                                                      .theInstance;
                                                                    }

                                                                    int num = 0;
                                                                    try
                                                                    {
                                                                        theInstance.GetZoomRange()
                                                                        .Parse(context, "Zoom");
                                                                        flag3 = true;
                                                                    }
                                                                    catch (InvalidMashupFile)
                                                                    {
                                                                    }

                                                                    if (flag3)
                                                                    {
                                                                        if (requiredAttribute2 == "Source")
                                                                        {
                                                                            sourceSnapZoom = num;
                                                                        }
                                                                        else
                                                                        {
                                                                            if (requiredAttribute2 == "Reference")
                                                                            {
                                                                                referenceSnapZoom = num;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                if (context.version == InlineSourceMapInfoSchema.schema)
                {
                    if (xMLTagReader.TagIs("MapFileURL"))
                    {
                        sourceMapInfo.mapFileURL = XMLUtils.ReadStringXml(context, "MapFileURL");
                    }
                    else
                    {
                        if (xMLTagReader.TagIs("MapHomePage"))
                        {
                            sourceMapInfo.mapHomePage = XMLUtils.ReadStringXml(context, "MapHomePage");
                        }
                        else
                        {
                            if (xMLTagReader.TagIs("MapDescription"))
                            {
                                sourceMapInfo.mapDescription = XMLUtils.ReadStringXml(context, "MapDescription");
                            }
                        }
                    }
                }
            }

            if (attribute2 != null)
            {
                _displayName = attribute2;
            }
            else
            {
                _displayName = documentFuture.documentFuture.GetDefaultDisplayName();
            }

            if (_lastView == null && mapPosition != null && mapPosition2 != null)
            {
                _lastView = new SourceMapRegistrationView(this, mapPosition.llz, mapPosition2);
            }

            if (documentFuture == null)
            {
                throw new Exception("Source Map element missing document descriptor tag");
            }

            if (registration == null)
            {
                registration = new RegistrationDefinition(dirtyEvent);
            }

            registration.dirtyEvent.Add(readyToLockChangedEvent);
            if (legendList == null)
            {
                legendList = new LegendList(this, dirtyEvent, readyToLockChangedEvent);
            }

            if (sourceMapInfo == null)
            {
                sourceMapInfo = new SourceMapInfo(dirtyEvent);
            }

            if (sourceMapRenderOptions == null)
            {
                sourceMapRenderOptions = new SourceMapRenderOptions(dirtyEvent);
            }

            if (transparencyOptions == null)
            {
                transparencyOptions = new TransparencyOptions(dirtyEvent);
            }
        }