ide.cs

compiler programming, code something

			m_Toolbars = new ReBar();
			m_Toolbars.Bands.Add(m_Menu);
			m_Toolbars.Bands.Add(m_Tools);
			m_Toolbars.Bands.Add(m_FullScreenTools);

			m_Toolbars.Dock = DockStyle.Top;
			Controls.Add(m_Toolbars);
		}

		private void IDE_Closing(object sender, System.ComponentModel.CancelEventArgs e)
		{
			m_Docker.SaveConfigToFile("Config.dck");
			CloseProject();
		}

		public bool m_bFullScreen = false;
		public Content [] m_VisibleContent = null;
		private void OnFullScreenTool(object sender, EventArgs e)
		{
			if(m_bFullScreen)
			{
				foreach(Content c in m_VisibleContent)
					m_Docker.ShowContent(c);
				m_bFullScreen = false;
			}
			else
			{
				int visible = 0;
				foreach(Content c in m_Docker.Contents)
					visible = c.Visible ? visible + 1: visible;
				m_VisibleContent = new Content [visible];

				int index = 0;
				foreach(Content c in m_Docker.Contents)
				{
					if(c.Visible)
					{
						m_VisibleContent[index] = c;
						index ++;
					}
				}
				m_Docker.HideAllContents();
				m_bFullScreen = true;
			}
		}

		private void OnView(object sender, EventArgs e)
		{
			if(sender == m_ViewObjectExplorer)
			{
				m_Docker.ShowContent(m_ObjectExplorerContent);
			}
			else if(sender == m_ViewProjectExplorer)
			{
				m_Docker.ShowContent(m_ProjectExplorerContent);
			}
			else if(sender == m_ViewOutput)
			{
				m_Docker.ShowContent(m_OutputContent);
			}
		}

		private void OnToolbarDropDown(object sender, EventArgs e)
		{
			ToolBarItem item = (ToolBarItem)sender;
			ContextMenu cm = new ContextMenu(new MenuItemEx[] {m_NewProjectTool,m_NewFileTool});
			Rectangle rc = item.ItemRectangle;
			Point pos = new Point(rc.Left, rc.Bottom);
			cm.Show(m_Tools, pos);
			
		}

		private void WriteAndScroll(RichTextBox textbox, string message)
		{
			textbox.AppendText(message + "\n");
			SendMessage(textbox.Handle,0xB6, 0, 1);
		}

		// ///////////////////////////////
		// ///////////////////////////////

		/// <summary>
		/// Load project.
		/// </summary>
		/// <param name="project"></param>
		private void LoadProject(Project project)
		{
			m_Project = project;

			//
			// Load project in project explorer.
			//

			m_tvProjectExplorer.HideSelection = false;
			m_tvProjectExplorer.Nodes.Clear();
			if(m_Project == null)
				return;

			TreeNode tnProject = new TreeNode(m_Project.Name,(int)IconIndex.Project,(int)IconIndex.Project );
			tnProject.Tag = m_Project;
			m_Project.Node = tnProject;

			foreach(ProjectFile file in m_Project.ProjectFiles)
			{
				TreeNode tnFile = new TreeNode(System.IO.Path.GetFileName(file.Path),(int)IconIndex.File,(int)IconIndex.File);
				tnFile.Tag = file;
				file.Node = tnFile;
				tnProject.Nodes.Add(tnFile);
			}
			
			m_tvProjectExplorer.Nodes.Add(tnProject);
			m_tvProjectExplorer.ExpandAll();

			m_Project.ProjectFiles.Added += new ProjectFileEventHandler(OnProjectFileAdded);
			m_Project.ProjectFiles.Removed += new ProjectFileEventHandler(OnProjectFileRemoved);

			//
			// TODO: Open opened files.
			//

			m_ProjectFiles = new ProjectFileCollection();
			m_ProjectFiles.Added += new ProjectFileEventHandler(OnProjectFileOpened);
			m_ProjectFiles.Removed += new ProjectFileEventHandler(OnProjectFileClosed);
		}


		/// <summary>
		/// Close loaded project.
		/// </summary>
		private void CloseProject()
		{
			if(m_Project == null)
				return;
			//
			// Clear project explorer.
			//

			m_tvProjectExplorer.Nodes.Clear();
			m_Project.Save();
			m_Project = null;

			//
			// TODO: Clear opened files.
			//
		}


		private void UpdateUIState()
		{
			m_AddNewFileTool.Enabled = (m_Project != null);
			m_CloseProject.Enabled = (m_Project != null);
			m_NewFile.Enabled = m_NewFileTool.Enabled = (m_Project != null);


			m_SaveFile.Enabled = m_SaveFileTool.Enabled = (m_ProjectFile != null);
			if(m_ProjectFile != null)
				m_SaveFile.Text = "S&ave " + m_ProjectFile.Name;
			else
				m_SaveFile.Text = "S&ave File";

			if(m_ProjectFile != null)
				m_SaveAllFiles.Enabled = m_SaveAllFilesTool.Enabled = (m_ProjectFiles.Count > 0);
			else
				m_SaveAllFiles.Enabled = m_SaveAllFilesTool.Enabled = false;
		}

		// ///////////////////////////////

		/// <summary>
		/// Currently opened project.
		/// </summary>
		private Project m_Project = null;
		
		/// <summary>
		/// Opened project files.
		/// </summary>
		private ProjectFileCollection m_ProjectFiles = null;

		/// <summary>
		/// Currently opened project file.
		/// </summary>
		private ProjectFile m_ProjectFile = null;

		//
		// UI Commands
		//

		/// <summary>
		///		UI command to build source program.
		/// </summary>
		private void OnBuild(object sender, EventArgs e)
		{
			if(m_ProjectFile == null)
				return;

			m_ProjectFile.Source.SaveFile(m_ProjectFile.Path);
			m_ProjectFile.IsChanged = false;

			try
			{
				m_Output.Clear();

				Scanner scanner = new Scanner(m_ProjectFile.Path,m_Language);
				Parser parser = new Parser(scanner,m_Language);

				parser.Error += new ParserEventHandler(OnParserError);
				Module module = parser.CreateSyntaxTree();

				Generator generator = new Generator(module);

				
				string path = Path.GetDirectoryName(m_Project.Path) + "\\" + module.Name + ".exe";
				
				if(File.Exists(path))
					File.Delete(path);
				
				generator.Compile(path);

				//
				// Use ildasm to decompile executable.
				//

				/*
				if(File.Exists("il.txt"))
					File.Delete("il.txt");

				Process ildasm = new Process();
				ildasm.StartInfo.FileName = "ildasm.exe";
				ildasm.StartInfo.Arguments = "/OUT=il.txt " + path;
				ildasm.Start();
				ildasm.WaitForExit();

				StreamReader il = File.OpenText("il.txt");
				WriteAndScroll(m_Output, il.ReadToEnd());
				il.Close();

				*/

				Process child = new Process();
				child.StartInfo.FileName = path;
				child.Start();
			
			}
			catch(Exception x)
			{
				WriteAndScroll(m_Output,x.Message);
			}
		}

		private void OnParserError(Core.Token token, string message)
		{
			WriteAndScroll(m_Output,message);
		}

		/// <summary>
		///		UI command to exit IDE.
		/// </summary>
		private void OnExit(object sender, EventArgs e)
		{
			Close();
		}
				
		/// <summary>
		///		UI command to create new project.
		/// </summary>
		private void OnNewProject(object sender, EventArgs e)
		{
			NewProjectWizard wizard = new NewProjectWizard();
			if(wizard.ShowDialog() != DialogResult.OK)
				return;
			LoadProject(Project.Create(wizard.ProjectPath + "\\" + wizard.ProjectName + ".shp",wizard.ProjectName));
			UpdateUIState();
		}

		/// <summary>
		///		UI command to open a project.
		/// </summary>
		private void OnOpenProject(object sender, EventArgs e)
		{
			OpenFileDialog browser = new OpenFileDialog();
			browser.Filter = "Sharp Project|*.shp";
			browser.CheckFileExists = true;
			if(browser.ShowDialog() != DialogResult.OK)
				return;
			LoadProject(Project.Open(browser.FileName));
			UpdateUIState();
		}

		/// <summary>
		///  UI command to close opened project.
		/// </summary>
		private void OnCloseProject(object sender, EventArgs e)
		{
			CloseProject();
			UpdateUIState();
		}

		/// <summary>
		///		UI command to add a existing file to the opened project.
		/// </summary>
		private void OnAddFile(object sender, EventArgs e)
		{
			OpenFileDialog browser = new OpenFileDialog();
			browser.Filter = "Sharp Source File|*.sh";
			browser.CheckFileExists = true;
			if(browser.ShowDialog() != DialogResult.OK)
				return;
			foreach(ProjectFile file in m_Project.ProjectFiles)
			{
				if(file.Path == browser.FileName)
				{
					MessageBox.Show("File is already part of the project.");
					return;
				}
			}
			m_Project.ProjectFiles.Add(new ProjectFile(m_Project,browser.FileName));
			UpdateUIState();
		}

		/// <summary>
		///		UI command to create a new file and add it to the opened project.
		/// </summary>
		private void OnNewFile(object sender, EventArgs e)
		{
			NewFileWizard wizard = new NewFileWizard(m_Project);
			if(wizard.ShowDialog() != DialogResult.OK)
				return;
			m_Project.ProjectFiles.Add(wizard.ProjectFile);
			UpdateUIState();
		}

		/// <summary>
		///		UI command to drop down the tools menu.
		/// </summary>
		private void OnToolsMenuDropDown(object sender, EventArgs e)
		{
			m_BuildParseTree.Enabled = m_BuildSyntaxTree.Enabled = (m_ProjectFile != null);
		}

		/// <summary>
		///		UI command to drop down the project menu.
		/// </summary>
		private void OnProjectMenuDropDown(object sender, EventArgs e)
		{
			TreeNode selected = m_tvProjectExplorer.SelectedNode;
			if(selected == null)
				return;
			Debug.Assert(selected.Tag != null,"Tree node has no tag value.");
			if(selected.Tag.GetType() == typeof(ProjectFile))
			{
				ProjectFile file = selected.Tag as ProjectFile;
				
				m_RemoveFile.Enabled = m_DeleteFile.Enabled = true;
				m_RemoveFile.Text = "&Remove " + file.Name;
				m_DeleteFile.Text = "&Delete " + file.Name;
			}
			else
			{
				m_RemoveFile.Enabled = m_DeleteFile.Enabled = false;
				m_RemoveFile.Text = "&Remove File";
				m_DeleteFile.Text = "&Delete File";
			}
		}

		/// <summary>
		///		UI command to remove a file from the opened project.
		/// </summary>
		private void OnRemoveFile(object sender, EventArgs e)
		{
			TreeNode selected = m_tvProjectExplorer.SelectedNode;
			if(selected == null)
				return;
			Debug.Assert(selected.Tag != null,"Tree node has no tag value.");
			if(selected.Tag.GetType() == typeof(ProjectFile))
			{
				ProjectFile file = selected.Tag as ProjectFile;
				m_Project.ProjectFiles.Remove(file);
				if(m_ProjectFiles.Contains(file))
					m_ProjectFiles.Remove(file);
			}
		}

		/// <summary>
		///		UI command to remove and delete a file from the opened project.
		/// </summary>
		private void OnDeleteFile(object sender, EventArgs e)
		{
			TreeNode selected = m_tvProjectExplorer.SelectedNode;
			if(selected == null)
				return;
			Debug.Assert(selected.Tag != null,"Tree node has no tag value.");
			if(selected.Tag.GetType() == typeof(ProjectFile))
			{
				ProjectFile file = selected.Tag as ProjectFile;
				m_Project.ProjectFiles.Remove(file);
				if(m_ProjectFiles.Contains(file))
				{
					m_ProjectFiles.Remove(file);
					File.Delete(file.Path);
					file = null;
				}
			}
		}

		/// <summary>
		///		UI command to save current file.
		/// </summary>
		private void OnSaveFile(object sender, EventArgs e)
		{
			m_ProjectFile.Source.SaveFile(m_ProjectFile.Path);
			m_ProjectFile.IsChanged = false;
		}

		/// <summary>
		///		UI command to save all opened files.
		/// </summary>
		private void OnSaveAllFiles(object sender, EventArgs e)
		{
			foreach(ProjectFile file in m_ProjectFiles)
			{
				file.Source.SaveFile(file.Path);
				file.IsChanged = false;
			}
		}


		/// <summary>
		///		UI command to open a project file for editing.
		/// </summary>
		private void OnProjectExplorerDoubleClick(object sender, EventArgs e)
		{
			TreeNode selected = m_tvProjectExplorer.SelectedNode;
			if(selected == null)
				return;