コード例 #1
0
ファイル: BaseDocument.cs プロジェクト: sajmosia/C64Studio
 public void SetProjectElement(ProjectElement Element)
 {
     DocumentInfo = Element.DocumentInfo;
 }
コード例 #2
0
ファイル: Project.cs プロジェクト: RUA71/C64Studio
        public BaseDocument ShowDocument(ProjectElement Element)
        {
            if (Element.DocumentInfo.Type == ProjectElement.ElementType.FOLDER)
            {
                return(null);
            }
            if (Element.Document == null)
            {
                BaseDocument document = Core.MainForm.CreateNewDocument(Element.DocumentInfo.Type, Element.DocumentInfo.Project);
                if (document == null)
                {
                    System.Windows.Forms.MessageBox.Show("Could not create document for " + Element.DocumentInfo.Type.ToString(), "Error creating document");
                    return(null);
                }

                Element.Document          = document;
                Element.Document.ShowHint = DockState.Document;
                Element.Document.Icon     = Core.MainForm.IconFromType(Element.DocumentInfo);
                document.SetProjectElement(Element);
                document.Core = Core;
                document.SetDocumentFilename(Element.Filename);
                if (Element.DocumentInfo.Project == null)
                {
                    // icon for non project documents
                    document.Icon = System.Drawing.SystemIcons.Asterisk;
                }
                document.ToolTipText = "";
                if (document.DocumentFilename == null)
                {
                    // a new file
                    Element.Name = Element.Name;
                    Element.Document.Show(Core.MainForm.panelMain);
                }
                else if (document.Load())
                {
                    document.ToolTipText = document.DocumentInfo.FullPath;
                    Element.Name         = document.Text;
                    //Element.Name;
                    Element.Document.Show(Core.MainForm.panelMain);
                }
                else if (!string.IsNullOrEmpty(Element.Filename))
                {
                    Element.Document = null;
                    return(null);
                }

                if (Element.Document != null)
                {
                    Element.Document.DocumentInfo = Element.DocumentInfo;
                    Element.DocumentInfo.BaseDoc  = Element.Document;
                }

                if ((Element.Document != null) &&
                    (Element.Document is SourceASMEx))
                {
                    Element.Document.DocumentEvent += new BaseDocument.DocumentEventHandler(Core.MainForm.Document_DocumentEvent);
                }

                // set known tokens if we have any
                bool setFromMainDoc = false;
                if (!string.IsNullOrEmpty(Settings.MainDocument))
                {
                    var element = GetElementByFilename(Settings.MainDocument);
                    if ((element != null) &&
                        (element.DocumentInfo.Type == ProjectElement.ElementType.ASM_SOURCE) &&
                        (element.DocumentInfo.ASMFileInfo != null))
                    {
                        if (element.DocumentInfo.ASMFileInfo.ContainsFile(Element.DocumentInfo.FullPath))
                        {
                            if (!Core.Compiling.IsCurrentlyBuilding())
                            {
                                Element.DocumentInfo.SetASMFileInfo(element.DocumentInfo.ASMFileInfo, element.DocumentInfo.KnownKeywords, element.DocumentInfo.KnownTokens);
                            }
                            setFromMainDoc = true;
                        }
                    }
                }
                if ((!setFromMainDoc) &&
                    (Core.Compiling.ParserASM.ASMFileInfo.ContainsFile(Element.DocumentInfo.FullPath)))
                {
                    if (!Core.Compiling.IsCurrentlyBuilding())
                    {
                        Element.DocumentInfo.SetASMFileInfo(Core.Compiling.ParserASM.ASMFileInfo, Core.Compiling.ParserASM.KnownTokens(), Core.Compiling.ParserASM.KnownTokenInfo());
                    }
                }
                //Debug.Log( "m_Outline.RefreshFromDocument after showdoc" );
                Core.MainForm.m_Outline.RefreshFromDocument(Element.DocumentInfo.BaseDoc);
            }
            Element.Document.Select();
            Element.IsShown = true;
            Core.MainForm.RaiseApplicationEvent(new C64Studio.Types.ApplicationEvent(C64Studio.Types.ApplicationEvent.Type.DOCUMENT_OPENED, Element.DocumentInfo));
            Core.MainForm.RaiseApplicationEvent(new C64Studio.Types.ApplicationEvent(C64Studio.Types.ApplicationEvent.Type.ELEMENT_OPENED, Element));
            return(Element.Document);
        }
コード例 #3
0
        public bool NeedsRebuild(DocumentInfo DocInfo, string ConfigSetting)
        {
            if (DocInfo == null)
            {
                return(false);
            }
            // actual parsing and deducing dependencies if a rebuild is necessary!
            foreach (IDockContent dockContent in Core.MainForm.panelMain.Documents)
            {
                BaseDocument baseDoc = (BaseDocument)dockContent;

                if (baseDoc.Modified)
                {
                    return(true);
                }
            }

            if (DocInfo.Element != null)
            {
                foreach (var dependency in DocInfo.Element.ForcedDependency.DependentOnFile)
                {
                    ProjectElement elementDependency = DocInfo.Project.GetElementByFilename(dependency.Filename);
                    if (elementDependency == null)
                    {
                        Core.AddToOutput("Could not find dependency for " + dependency + System.Environment.NewLine);
                        return(true);
                    }
                    if (NeedsRebuild(elementDependency.DocumentInfo, ConfigSetting))
                    {
                        return(true);
                    }
                    foreach (var rebuildFile in m_RebuiltFiles)
                    {
                        if (GR.Path.IsPathEqual(elementDependency.DocumentInfo.DocumentFilename, rebuildFile))
                        {
                            Core.AddToOutput("Dependency " + elementDependency.DocumentInfo.DocumentFilename + " was rebuilt in this cycle, need to rebuild dependent element " + DocInfo.DocumentFilename + System.Environment.NewLine);
                            return(true);
                        }
                    }
                }
                if (DocInfo.DeducedDependency[ConfigSetting] != null)
                {
                    // custom build overrides output file -> always rebuild
                    if ((!string.IsNullOrEmpty(DocInfo.Element.Settings[ConfigSetting].CustomBuild)) &&
                        (!string.IsNullOrEmpty(DocInfo.Element.TargetFilename)))
                    {
                        Core.AddToOutput("Custom build always requires a rebuild" + System.Environment.NewLine);
                        return(true);
                    }

                    foreach (var dependency in DocInfo.Element.ExternalDependencies.DependentOnFile)
                    {
                        string fullPath = BuildFullPath(DocInfo.Project.Settings.BasePath, dependency.Filename);

                        DateTime fileTime = new DateTime();

                        try
                        {
                            if (System.IO.File.Exists(fullPath))
                            {
                                fileTime = System.IO.File.GetLastWriteTime(fullPath);
                            }
                        }
                        catch
                        {
                        }

                        if (fileTime != DocInfo.DeducedDependency[ConfigSetting].BuildState[fullPath])
                        {
                            Core.AddToOutput("External Dependency " + fullPath + " was modified, need to rebuild dependent element " + DocInfo.DocumentFilename + System.Environment.NewLine);

                            DocInfo.DeducedDependency[ConfigSetting].BuildState.Add(fullPath, fileTime);
                            return(true);
                        }
                    }
                }
                else
                {
                    // no build time stored yet, needs rebuild
                    DocInfo.DeducedDependency[ConfigSetting] = new DependencyBuildState();
                    return(true);
                }
            }
            if (DocInfo.Compilable)
            {
                if (!DocInfo.HasBeenSuccessfullyBuilt)
                {
                    return(true);
                }
            }
            if (DocInfo.Project == null)
            {
                return(true);
            }
            if (DocInfo.DeducedDependency[ConfigSetting] == null)
            {
                // no build time stored yet, needs rebuild
                DocInfo.DeducedDependency[ConfigSetting] = new DependencyBuildState();
                return(true);
            }
            foreach (KeyValuePair <string, DateTime> dependency in DocInfo.DeducedDependency[ConfigSetting].BuildState)
            {
                DateTime fileTime = new DateTime();

                try
                {
                    fileTime = System.IO.File.GetLastWriteTime(dependency.Key);
                }
                catch
                {
                }
                if (fileTime != dependency.Value)
                {
                    //Debug.Log( "File time differs for " + dependency.Key );
                    return(true);
                }
            }
            return(false);
        }
コード例 #4
0
ファイル: Project.cs プロジェクト: RUA71/C64Studio
        public bool Load(byte[] ProjectData)
        {
            string currentConfig = "Default";
            string activeElement = "";

            Node     = new System.Windows.Forms.TreeNode();
            Node.Tag = this;

            GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(ProjectData);

            GR.IO.FileChunk chunk = new GR.IO.FileChunk();
            ushort          origDebugStartAddress = 2049;

            while (chunk.ReadFromStream(memIn))
            {
                GR.IO.MemoryReader memChunk = chunk.MemoryReader();
                switch (chunk.Type)
                {
                case Types.FileChunk.PROJECT:
                    // Project Info

                    // Version
                    memChunk.ReadUInt32();
                    Settings.Name         = memChunk.ReadString();
                    Settings.Filename     = memChunk.ReadString();
                    Settings.DebugPort    = memChunk.ReadUInt16();
                    origDebugStartAddress = memChunk.ReadUInt16();
                    Settings.BuildTool    = memChunk.ReadString();
                    Settings.RunTool      = memChunk.ReadString();
                    Settings.MainDocument = memChunk.ReadString();
                    currentConfig         = memChunk.ReadString();
                    activeElement         = memChunk.ReadString();
                    Node.Text             = Settings.Name;
                    break;

                case Types.FileChunk.PROJECT_ELEMENT:
                    // Element Info
                {
                    // Version
                    int version = (int)memChunk.ReadUInt32();

                    ProjectElement.ElementType type = (ProjectElement.ElementType)memChunk.ReadUInt32();

                    //System.Windows.Forms.TreeNode nodeParent = NodeFromHierarchy(

                    ProjectElement element = CreateElement(type, Node);
                    element.Name = memChunk.ReadString();
                    //element.Filename = System.IO.Path.GetFileName( memChunk.ReadString() );
                    element.Filename = memChunk.ReadString();
                    if (element.DocumentInfo.Type == ProjectElement.ElementType.FOLDER)
                    {
                        element.Node.Text = element.Name;
                    }
                    else
                    {
                        element.Node.Text = System.IO.Path.GetFileName(element.Filename);
                    }

                    GR.IO.FileChunk subChunk = new GR.IO.FileChunk();

                    if (!subChunk.ReadFromStream(memChunk))
                    {
                        return(false);
                    }
                    if (subChunk.Type != Types.FileChunk.PROJECT_ELEMENT_DATA)
                    {
                        return(false);
                    }
                    // Element Data
                    element.DocumentInfo.DocumentFilename = element.Filename;
                    if (element.Document != null)
                    {
                        if (!element.Document.ReadFromReader(subChunk.MemoryReader()))
                        {
                            Elements.Remove(element);
                            element.Document.Dispose();
                            element = null;
                        }
                        else
                        {
                            element.Document.SetDocumentFilename(element.Filename);
                        }
                    }
                    element.TargetFilename = memChunk.ReadString();
                    element.TargetType     = (Types.CompileTargetType)memChunk.ReadUInt32();
                    int dependencyCount = memChunk.ReadInt32();
                    for (int i = 0; i < dependencyCount; ++i)
                    {
                        string dependency = memChunk.ReadString();
                        element.ForcedDependency.DependentOnFile.Add(new FileDependency.DependencyInfo(dependency, true, false));
                    }
                    element.StartAddress = memChunk.ReadString();
                    // 2 free strings
                    memChunk.ReadString();
                    memChunk.ReadString();

                    int perConfigSettingCount = memChunk.ReadInt32();
                    for (int i = 0; i < perConfigSettingCount; ++i)
                    {
                        GR.IO.FileChunk chunkElementPerConfigSetting = new GR.IO.FileChunk();
                        chunkElementPerConfigSetting.ReadFromStream(memChunk);
                        if (chunkElementPerConfigSetting.Type == Types.FileChunk.PROJECT_ELEMENT_PER_CONFIG_SETTING)
                        {
                            ProjectElement.PerConfigSettings perConfigSetting = new ProjectElement.PerConfigSettings();
                            GR.IO.MemoryReader memSubChunk = chunkElementPerConfigSetting.MemoryReader();
                            string             config      = memSubChunk.ReadString();

                            perConfigSetting.PreBuild      = memSubChunk.ReadString();
                            perConfigSetting.CustomBuild   = memSubChunk.ReadString();
                            perConfigSetting.PostBuild     = memSubChunk.ReadString();
                            perConfigSetting.DebugFile     = memSubChunk.ReadString();
                            perConfigSetting.DebugFileType = (C64Studio.Types.CompileTargetType)memSubChunk.ReadInt32();

                            perConfigSetting.PreBuildChain.Active = (memSubChunk.ReadInt32() == 1);
                            int numEntries = memSubChunk.ReadInt32();
                            for (int j = 0; j < numEntries; ++j)
                            {
                                var entry = new BuildChainEntry();

                                entry.ProjectName      = memSubChunk.ReadString();
                                entry.Config           = memSubChunk.ReadString();
                                entry.DocumentFilename = memSubChunk.ReadString();
                                entry.PreDefines       = memSubChunk.ReadString();

                                perConfigSetting.PreBuildChain.Entries.Add(entry);
                            }

                            perConfigSetting.PostBuildChain.Active = (memSubChunk.ReadInt32() == 1);
                            numEntries = memSubChunk.ReadInt32();
                            for (int j = 0; j < numEntries; ++j)
                            {
                                var entry = new BuildChainEntry();

                                entry.ProjectName      = memSubChunk.ReadString();
                                entry.Config           = memSubChunk.ReadString();
                                entry.DocumentFilename = memSubChunk.ReadString();
                                entry.PreDefines       = memSubChunk.ReadString();

                                perConfigSetting.PostBuildChain.Entries.Add(entry);
                            }
                            element.Settings[config] = perConfigSetting;
                        }
                    }

                    element.IsShown       = (memChunk.ReadInt32() != 0);
                    element.AssemblerType = (C64Studio.Types.AssemblerType)memChunk.ReadUInt32();

                    int hierarchyPartCount = memChunk.ReadInt32();
                    for (int i = 0; i < hierarchyPartCount; ++i)
                    {
                        string part = memChunk.ReadString();

                        element.ProjectHierarchy.Add(part);
                    }

                    if (element.ProjectHierarchy.Count > 0)
                    {
                        // node is sub-node, move accordingly
                        System.Windows.Forms.TreeNode parentNode = NodeFromHierarchy(element.ProjectHierarchy);
                        if ((parentNode != null) &&
                            (parentNode != element.Node.Parent))
                        {
                            element.Node.Remove();
                            parentNode.Nodes.Add(element.Node);
                        }
                    }

                    // dependency - include symbols
                    dependencyCount = memChunk.ReadInt32();
                    for (int i = 0; i < dependencyCount; ++i)
                    {
                        element.ForcedDependency.DependentOnFile[i].IncludeSymbols = (memChunk.ReadInt32() != 0);
                    }

                    // code folding entries
                    int numFoldingEntries = memChunk.ReadInt32();
                    element.DocumentInfo.CollapsedFoldingBlocks = new GR.Collections.Set <int>();
                    for (int i = 0; i < numFoldingEntries; ++i)
                    {
                        int collapsedBlockLine = memChunk.ReadInt32();
                        element.DocumentInfo.CollapsedFoldingBlocks.Add(collapsedBlockLine);
                        //Debug.Log( "Get collapsed blocked for " + element.DocumentInfo.FullPath + ", line " + collapsedBlockLine );
                    }

                    // external dependencies
                    int externalDependencyCount = memChunk.ReadInt32();
                    for (int i = 0; i < externalDependencyCount; ++i)
                    {
                        string dependency = memChunk.ReadString();
                        element.ExternalDependencies.DependentOnFile.Add(new FileDependency.DependencyInfo(dependency, true, false));
                    }

                    element.BasicVersion = (BasicVersion)memChunk.ReadUInt32();

                    // TODO - load other stuff
                    if ((element != null) &&
                        (element.IsShown))
                    {
                        ShowDocument(element);
                        if (element.Document != null)
                        {
                            element.Document.ShowHint = DockState.Document;
                            //element.Document.Show( MainForm.panelMain );
                        }
                    }
                }
                break;

                case Types.FileChunk.PROJECT_ELEMENT_DISPLAY_DATA:
                {
                    string elementFilename = memChunk.ReadString();

                    ProjectElement element = GetElementByFilename(elementFilename);
                    if (element != null)
                    {
                        UInt32 numBytes = memChunk.ReadUInt32();
                        GR.Memory.ByteBuffer displayData = new GR.Memory.ByteBuffer();
                        memChunk.ReadBlock(displayData, numBytes);

                        if (element.Document != null)
                        {
                            element.Document.ApplyDisplayDetails(displayData);
                        }
                    }
                }
                break;

                case Types.FileChunk.PROJECT_CONFIG:
                {
                    ProjectConfig config = new ProjectConfig();

                    config.Load(memChunk);

                    if (string.IsNullOrEmpty(config.DebugStartAddressLabel))
                    {
                        config.DebugStartAddressLabel = origDebugStartAddress.ToString();
                    }

                    Settings.Configuration(config.Name, config);
                }
                break;

                case Types.FileChunk.PROJECT_WATCH_ENTRY:
                {
                    WatchEntry watch = new WatchEntry();

                    watch.Load(memChunk);
                    Core.MainForm.AddWatchEntry(watch);
                    //Debug.Log( "loaded watch entry for " + watch.Name );
                }
                break;
                }
            }
            if (Settings.GetConfigurationCount() == 0)
            {
                // there must be one config
                ProjectConfig config = new ProjectConfig();

                config.Name = "Default";
                Settings.Configuration(config.Name, config);
                Settings.CurrentConfig = config;
            }
            else
            {
                Settings.CurrentConfig = Settings.Configuration(currentConfig);
                if (Settings.CurrentConfig == null)
                {
                    Settings.CurrentConfig = Settings.GetConfigurations().First();
                }
            }
            foreach (ProjectElement element in Elements)
            {
                if (element.Settings.Count == 0)
                {
                    foreach (var configName in Settings.GetConfigurationNames())
                    {
                        // needs a default setting!
                        element.Settings[configName] = new ProjectElement.PerConfigSettings();
                    }
                }
                if ((!string.IsNullOrEmpty(element.Filename)) &&
                    (GR.Path.IsPathEqual(element.Filename, Settings.MainDocument)))
                {
                    Core.MainForm.m_SolutionExplorer.HighlightNode(element.Node);
                }

                Core.MainForm.RaiseApplicationEvent(new C64Studio.Types.ApplicationEvent(C64Studio.Types.ApplicationEvent.Type.DOCUMENT_INFO_CREATED, element.DocumentInfo));
                Core.MainForm.RaiseApplicationEvent(new C64Studio.Types.ApplicationEvent(C64Studio.Types.ApplicationEvent.Type.ELEMENT_CREATED, element));
            }



            if (!String.IsNullOrEmpty(activeElement))
            {
                ProjectElement element = GetElementByFilename(activeElement);
                if ((element != null) &&
                    (element.Document != null))
                {
                    element.Document.Show();
                }
            }
            m_Modified = false;
            return(true);
        }
コード例 #5
0
ファイル: Project.cs プロジェクト: RUA71/C64Studio
        GR.Memory.ByteBuffer ElementToBuffer(ProjectElement Element)
        {
            GR.Memory.ByteBuffer buffer = new GR.Memory.ByteBuffer();

            GR.IO.FileChunk chunkElement = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT);

            chunkElement.AppendU32(1);
            chunkElement.AppendU32((uint)Element.DocumentInfo.Type);
            chunkElement.AppendString(Element.Name);
            chunkElement.AppendString(Element.Filename);

            GR.IO.FileChunk chunkElementData = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_DATA);
            if (Element.Document != null)
            {
                Element.Document.SaveToChunk(chunkElementData);
            }
            chunkElement.Append(chunkElementData.ToBuffer());
            chunkElement.AppendString(Element.TargetFilename);
            chunkElement.AppendU32((uint)Element.TargetType);
            chunkElement.AppendI32(Element.ForcedDependency.DependentOnFile.Count);
            foreach (var dependency in Element.ForcedDependency.DependentOnFile)
            {
                chunkElement.AppendString(dependency.Filename);
            }

            chunkElement.AppendString(Element.StartAddress);
            // 2 free strings
            chunkElement.AppendString("");
            chunkElement.AppendString("");

            chunkElement.AppendI32(Element.Settings.Count);
            foreach (KeyValuePair <string, ProjectElement.PerConfigSettings> configSetting in Element.Settings)
            {
                GR.IO.FileChunk chunkElementPerConfigSetting = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_PER_CONFIG_SETTING);

                chunkElementPerConfigSetting.AppendString(configSetting.Key);
                chunkElementPerConfigSetting.AppendString(configSetting.Value.PreBuild);
                chunkElementPerConfigSetting.AppendString(configSetting.Value.CustomBuild);
                chunkElementPerConfigSetting.AppendString(configSetting.Value.PostBuild);
                chunkElementPerConfigSetting.AppendString(configSetting.Value.DebugFile);
                chunkElementPerConfigSetting.AppendI32((int)configSetting.Value.DebugFileType);

                chunkElementPerConfigSetting.AppendI32(configSetting.Value.PreBuildChain.Active ? 1 : 0);
                chunkElementPerConfigSetting.AppendI32(configSetting.Value.PreBuildChain.Entries.Count);
                foreach (var buildChainEntry in configSetting.Value.PreBuildChain.Entries)
                {
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.ProjectName);
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.Config);
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.DocumentFilename);
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.PreDefines);
                }

                chunkElementPerConfigSetting.AppendI32(configSetting.Value.PostBuildChain.Active ? 1 : 0);
                chunkElementPerConfigSetting.AppendI32(configSetting.Value.PostBuildChain.Entries.Count);
                foreach (var buildChainEntry in configSetting.Value.PostBuildChain.Entries)
                {
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.ProjectName);
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.Config);
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.DocumentFilename);
                    chunkElementPerConfigSetting.AppendString(buildChainEntry.PreDefines);
                }

                chunkElement.Append(chunkElementPerConfigSetting.ToBuffer());
            }
            chunkElement.AppendI32(Element.IsShown ? 1 : 0);
            chunkElement.AppendU32((uint)Element.AssemblerType);

            chunkElement.AppendI32(Element.ProjectHierarchy.Count);
            foreach (string hierarchyPart in Element.ProjectHierarchy)
            {
                chunkElement.AppendString(hierarchyPart);
            }
            // dependency - include symbols
            chunkElement.AppendI32(Element.ForcedDependency.DependentOnFile.Count);
            foreach (var dependency in Element.ForcedDependency.DependentOnFile)
            {
                chunkElement.AppendI32(dependency.IncludeSymbols ? 1 : 0);
            }
            // collapsed folding blocks
            chunkElement.AppendI32(Element.DocumentInfo.CollapsedFoldingBlocks.Count);
            foreach (int foldStartLine in Element.DocumentInfo.CollapsedFoldingBlocks)
            {
                chunkElement.AppendI32(foldStartLine);
                //Debug.Log( "Save folded block for line " + foldStartLine );
            }

            // external dependencies
            chunkElement.AppendI32(Element.ExternalDependencies.DependentOnFile.Count);
            foreach (var dependency in Element.ExternalDependencies.DependentOnFile)
            {
                chunkElement.AppendString(dependency.Filename);
            }

            // BASIC (that is sooo ugly)
            chunkElement.AppendU32((uint)Element.BasicVersion);

            buffer.Append(chunkElement.ToBuffer());

            if (Element.Document != null)
            {
                GR.Memory.ByteBuffer displayDetails = Element.Document.DisplayDetails();
                if (displayDetails != null)
                {
                    GR.IO.FileChunk chunkElementDisplayData = new GR.IO.FileChunk(Types.FileChunk.PROJECT_ELEMENT_DISPLAY_DATA);
                    chunkElementDisplayData.AppendString(Element.Filename);
                    chunkElementDisplayData.AppendU32(displayDetails.Length);
                    chunkElementDisplayData.Append(displayDetails);

                    buffer.Append(chunkElementDisplayData.ToBuffer());
                }
            }
            // child elements
            foreach (System.Windows.Forms.TreeNode node in Element.Node.Nodes)
            {
                ProjectElement subElement = (ProjectElement)node.Tag;

                buffer.Append(ElementToBuffer(subElement));
            }

            return(buffer);
        }
コード例 #6
0
ファイル: Compiling.cs プロジェクト: jeason0813/C64Studio
        public bool NeedsRebuild(DocumentInfo DocInfo, string ConfigSetting)
        {
            if (DocInfo == null)
            {
                return(false);
            }
            // actual parsing and deducing dependencies if a rebuild is necessary!
            foreach (IDockContent dockContent in Core.MainForm.panelMain.Documents)
            {
                BaseDocument baseDoc = (BaseDocument)dockContent;

                if (baseDoc.Modified)
                {
                    return(true);
                }
            }

            if (DocInfo.Element != null)
            {
                foreach (var dependency in DocInfo.Element.ForcedDependency.DependentOnFile)
                {
                    ProjectElement elementDependency = DocInfo.Project.GetElementByFilename(dependency.Filename);
                    if (elementDependency == null)
                    {
                        Core.AddToOutput("Could not find dependency for " + dependency + System.Environment.NewLine);
                        return(true);
                    }
                    if (NeedsRebuild(elementDependency.DocumentInfo, ConfigSetting))
                    {
                        return(true);
                    }
                    foreach (var rebuildFile in m_RebuiltFiles)
                    {
                        if (GR.Path.IsPathEqual(elementDependency.DocumentInfo.DocumentFilename, rebuildFile))
                        {
                            Core.AddToOutput("Dependency " + elementDependency.DocumentInfo.DocumentFilename + " was rebuilt in this cycle, need to rebuild dependent element " + DocInfo.DocumentFilename + System.Environment.NewLine);
                            return(true);
                        }
                    }
                }
            }
            if (DocInfo.Compilable)
            {
                if (!DocInfo.HasBeenSuccessfullyBuilt)
                {
                    return(true);
                }
            }
            if (DocInfo.Project == null)
            {
                return(true);
            }
            if (DocInfo.DeducedDependency[ConfigSetting] == null)
            {
                // no build time stored yet, needs rebuild
                DocInfo.DeducedDependency[ConfigSetting] = new DependencyBuildState();
                return(true);
            }
            foreach (KeyValuePair <string, DateTime> dependency in DocInfo.DeducedDependency[ConfigSetting].BuildState)
            {
                DateTime fileTime = new DateTime();

                try
                {
                    fileTime = System.IO.File.GetLastWriteTime(dependency.Key);
                }
                catch
                {
                }
                if (fileTime != dependency.Value)
                {
                    //Debug.Log( "File time differs for " + dependency.Key );
                    return(true);
                }
            }
            return(false);
        }
コード例 #7
0
        public PropCompileTarget(ProjectElement Element, StudioCore Core)
        {
            this.Element = Element;
            this.Core    = Core;
            TopLevel     = false;
            Text         = "Compile Target";
            InitializeComponent();

            comboTargetType.Items.Add("None");
            comboTargetType.Items.Add("Plain");
            comboTargetType.Items.Add("PRG (cbm)");
            comboTargetType.Items.Add("T64");
            comboTargetType.Items.Add("8 KB Cartridge (bin)");
            comboTargetType.Items.Add("8 KB Cartridge (crt)");
            comboTargetType.Items.Add("16 KB Cartridge (bin)");
            comboTargetType.Items.Add("16 KB Cartridge (crt)");
            comboTargetType.Items.Add("D64");
            comboTargetType.Items.Add("Magic Desk 64 KB Cartridge (bin)");
            comboTargetType.Items.Add("Magic Desk 64 KB Cartridge (crt)");
            comboTargetType.Items.Add("TAP");
            comboTargetType.Items.Add("Easyflash Cartridge (bin)");
            comboTargetType.Items.Add("Easyflash Cartridge (crt)");
            comboTargetType.Items.Add("RGCD 64 KB Cartridge (bin)");
            comboTargetType.Items.Add("RGCD 64 KB Cartridge (crt)");
            comboTargetType.Items.Add("GMOD2 Cartridge (bin)");
            comboTargetType.Items.Add("GMOD2 Cartridge (crt)");
            comboTargetType.Items.Add("D81");

            comboTargetType.SelectedIndex = (int)Element.TargetType;

            editTargetFilename.Text = Element.TargetFilename;

            foreach (ProjectElement element in Element.DocumentInfo.Project.Elements)
            {
                if ((element != Element) &&
                    (element.DocumentInfo.Type != ProjectElement.ElementType.FOLDER))
                {
                    var dependencies = Element.DocumentInfo.Project.GetDependencies(element);

                    FileDependency.DependencyInfo depInfo = Element.ForcedDependency.FindDependency(element.Filename);
                    if (depInfo == null)
                    {
                        depInfo = new FileDependency.DependencyInfo(element.Filename, false, false);
                    }

                    bool isDependent = false;
                    foreach (var dependency in dependencies)
                    {
                        if (dependency.Filename == Element.Filename)
                        {
                            isDependent = true;
                            break;
                        }
                    }
                    if (!isDependent)
                    {
                        // not itself!
                        DependencyItem depItem = new DependencyItem(depInfo, element.DocumentInfo.Type == ProjectElement.ElementType.ASM_SOURCE);


                        ListViewItem item = new ListViewItem(element.Filename);

                        if (Element.ForcedDependency.DependsOn(element.Filename))
                        {
                            item.SubItems.Add("1");
                        }
                        else
                        {
                            item.SubItems.Add("0");
                        }
                        if (depInfo.IncludeSymbols)
                        {
                            item.SubItems.Add("1");
                        }
                        else
                        {
                            item.SubItems.Add("0");
                        }
                        item.Tag = depItem;
                        listDependencies.Items.Add(item);
                    }
                }
            }

            foreach (var entry in Element.ExternalDependencies.DependentOnFile)
            {
                listExternalDependencies.Items.Add(entry.Filename);
            }
        }
コード例 #8
0
ファイル: Project.cs プロジェクト: wowjinxy/C64Studio
        public bool Load(string Filename)
        {
            byte[] projectData = null;
            try
            {
                projectData = System.IO.File.ReadAllBytes(Filename);
            }
            catch (System.IO.IOException)
            {
                return(false);
            }

            Settings.Filename = Filename;
            Settings.BasePath = System.IO.Path.GetDirectoryName(Settings.Filename);

            GR.IO.MemoryReader memIn = new GR.IO.MemoryReader(projectData);

            GR.IO.FileChunk chunk = new GR.IO.FileChunk();

            while (chunk.ReadFromStream(memIn))
            {
                GR.IO.MemoryReader memChunk = chunk.MemoryReader();
                switch (chunk.Type)
                {
                case Types.FileChunk.PROJECT:
                    // Project Info

                    // Version
                    memChunk.ReadUInt32();
                    Settings.Name              = memChunk.ReadString();
                    Settings.Filename          = memChunk.ReadString();
                    Settings.DebugPort         = memChunk.ReadUInt16();
                    Settings.DebugStartAddress = memChunk.ReadUInt16();
                    Settings.BuildTool         = memChunk.ReadString();
                    Settings.RunTool           = memChunk.ReadString();
                    Settings.MainDocument      = memChunk.ReadString();
                    break;

                case Types.FileChunk.PROJECT_ELEMENT:
                    // Element Info
                {
                    // Version
                    int version = (int)memChunk.ReadUInt32();

                    ProjectElement.ElementType type = (ProjectElement.ElementType)memChunk.ReadUInt32();

                    ProjectElement element = CreateElement(type);
                    element.Name     = memChunk.ReadString();
                    element.Filename = memChunk.ReadString();
                    ShowDocument(element);

                    GR.IO.FileChunk subChunk = new GR.IO.FileChunk();

                    if (!subChunk.ReadFromStream(memChunk))
                    {
                        return(false);
                    }
                    if (subChunk.Type != Types.FileChunk.PROJECT_ELEMENT_DATA)
                    {
                        return(false);
                    }
                    // Element Data
                    if (element.Document != null)
                    {
                        if (!element.Document.ReadFromReader(subChunk.MemoryReader()))
                        {
                            Elements.Remove(element);
                            element.Document.Dispose();
                            element = null;
                        }
                    }
                    element.TargetFilename = memChunk.ReadString();
                    element.TargetType     = (FileParser.CompileTargetType)memChunk.ReadUInt32();

                    if ((element != null) &&
                        (element.Document != null))
                    {
                        element.Document.ShowHint = DockState.Document;
                        element.Document.Show(MainForm.panelMain);
                    }
                }
                break;
                }
            }
            Settings.Filename = Filename;
            m_Modified        = false;
            return(true);
        }
コード例 #9
0
ファイル: Project.cs プロジェクト: wowjinxy/C64Studio
 public void RemoveElement(ProjectElement Element)
 {
     Elements.Remove(Element);
     m_Modified = true;
 }
コード例 #10
0
        internal bool IsNodeExpanded(ProjectElement Element)
        {
            string key = "Element*" + Element.DocumentInfo.Project.Settings.Name + "*" + Element.Name;

            return(ExpandedNodes.Contains(key));
        }