//Using static bool IsJoinSimpleOperand(TreeChart arg) { if (arg.element == "Star" || arg.element == "Concat" || arg.element == "Join") { return(false); } return(true); }
static void Draw_Diagram(ExprNameArray expression, bool bDrawPolish) { FormDiagramm formDiagramm = new FormDiagramm(); formDiagramm.TopMost = true; string[] arrPolish = expression.arrPolish; string RegExpName = expression.name; List <string> polish = new List <string>(arrPolish); //=======Change "" for EMPTY STRING======== for (int i = 0; i < polish.Count; i++) { if (polish[i] != "\"\"") { continue; } else { polish[i] = ""; } } //======================================== #if NoTest Console.WriteLine("Source Polish Expression."); Console.WriteLine("PolishToTree: Do reduction for strings and Do join 1-strings-symbols!!!"); foreach (string s in polish) { Console.WriteLine(s); } Console.WriteLine(); //Console.WriteLine("Press the Key Enter to Exit:"); //Console.ReadKey(); //return; //now USING Console.WriteLine("\n Now USING\nTree Chart attributed with size-RECTANGLES"); //1) List<string> polish --(PolishToTree)--> TreeChart treeChart Console.WriteLine("Getting Reduced Polish Expression with Simple Operands untill Joined"); Console.WriteLine("and With no Size"); #endif TreeChart treeChart = TreeChart.PolishToTree(polish);//No Size, No Numbers,ENUMERATION IMPOSSIBLE List <string> postfix = treeChart.GetPostfixForm(); #if NoTest Console.WriteLine("\nPostfix = treeChart.GetPostfixForm();"); foreach (string sp in postfix) { Console.WriteLine(sp); } Console.WriteLine(); Console.ReadKey(); //treeChart.PrintTree(); //With No Size No Numbers//Working #endif //2) TreeChart treeChart --(AssignSizeToTree)--> TreeChart treeChart treeChart = treeChart.AssignSizeToTree(); //Get Size, But No Changing Numbers, ENUMERATION IMPOSSIBLE #if NoTest //TODO:treeChart.AssignNumbersToTree(); Console.WriteLine("\nTree Chart With Size"); treeChart.PrintTree(); //With Size ~ //PrintTree(treeChart); No Numbers;ENUMERATION POSSIBLE #endif //2) TreeChart treeChart --> string treeChart.RegExp //Back to Expression from TreeChart treeChart. treeChart.RegExp = treeChart.GetExpression().RegExp; // ~ PrintExpression(treeChart); if (bDrawPolish) { treeChart.namedPostfixExp = expression; } //TreeChart.PrintExpression(treeChart); //Working #if NoTest Console.WriteLine("\ntreeChart.element:{0}", treeChart.element); Console.WriteLine("treeChart.RegExp:={0}", treeChart.RegExp); #endif treeChart.DiagramName = "Diagram of Regular Expression:" + RegExpName; #if NoTest Console.WriteLine("TreeChart.DiagramName:={0}", treeChart.DiagramName); #endif // FormDiagramm formDiagramm = new FormDiagramm(); //a) Add <<new TabPage>> for new <<expression>> in <<arrExpr>> TabPage currTabPage = new TabPage(expression.shortName); formDiagramm.tabControlDiagram.TabPages.Add(currTabPage); //currTabPage.Tab //b) Add <<treeChart>> of <<expression>> to <<listTreeChart>> formDiagramm.listTreeChart.Add(treeChart); formDiagramm.Width = treeChart.rectSize.Width + 20 + (int)(4 * TreeChart.emSizeChar); if (treeChart.DiagramName.Length * 14 > formDiagramm.Width) { formDiagramm.Width = treeChart.DiagramName.Length * 14; } //formDiagramm.TopMost = true; //c)Set <<currTabPage>> //int indexCurrTabPage = formDiagramm.tabControlDiagram.TabPages.Count - 1; formDiagramm.tabControlDiagram.SelectedTab = currTabPage; currTabPage.Paint += new PaintEventHandler(formDiagramm.currTabPage_Paint); formDiagramm.ShowDialog(); //Console.WriteLine("Press the Key Enter to Exit:"); //Console.ReadKey(); }
public TreeChart GetExpression() //TreeChart this ~ this { // Evaluate the attribute TreeChart.RegExp as the infix form //There is possible to evaluate a new attribute in the postfix form or in the prefix form //this!=null whenever TreeChart res = null; if (!(this.element == "Star" || this.element == "Concat" || this.element == "Join")) { res = new TreeChart(this.element, Size.Empty, null); if (this.element.Length == 0) { //Console.Write("\"\""); res.RegExp = "\"\""; } else //Console.Write("{0}", this.element); if (this.element.Length > 1) { res.RegExp = this.element; } else //(this.element.Length ==1) { res.RegExp = this.element; } return(res); } else { switch (this.element) { case "Star": //DONE TreeChart res0 = this.subTrees[0].GetExpression(); //Apply Equivalence Transformations res = new TreeChart("Star", Size.Empty, null); res.RegExp = "{" + res0.RegExp + "}"; break; case "Concat": //???TODO: All to do is not to get redundant brackets //1)GET Sources res0 = this.subTrees[0].GetExpression(); TreeChart res1 = this.subTrees[1].GetExpression(); res = new TreeChart("Concat", Size.Empty, null); bool bOpExp0 = (res0.element == "Star" || res0.element == "Concat" || res0.element == "Join"); ////!bOpExp0 - Simple bool bOpExp1 = (res1.element == "Star" || res1.element == "Concat" || res1.element == "Join"); //!bOpExp1 - Simple //Simple * Simple -> Simple+Simple if (!bOpExp0 && !bOpExp1) { res.RegExp = res0.RegExp + res1.RegExp; res.element = res.RegExp; break; } ; //Simple * (Concat or Star) -> Simple+*+(Concat or Star) if (!bOpExp0 && (res1.element == "Star" || res1.element == "Concat")) { res.RegExp = res0.RegExp + "*" + res1.RegExp; break; } ; //(Concat or Star) * Simple -> (Concat or Star)+*+Simple if (!bOpExp1 && (res0.element == "Star" || res0.element == "Concat")) { res.RegExp = res0.RegExp + "*" + res1.RegExp; break; } ; //(Concat or Star) * (Concat or Star) -> (Concat or Star)+*+(Concat or Star) if ((res0.element == "Star" || res0.element == "Concat") && (res1.element == "Star" || res1.element == "Concat")) { res.RegExp = res0.RegExp + "*" + res1.RegExp; break; } ; //Join * (Simple or Concat or Star) -> (+Join+) +*+(Simple or Concat or Star) if (res0.element == "Join" && res1.element != "Join") { res.RegExp = "(" + res0.RegExp + ")" + "*" + res1.RegExp; break; } ; //(Simple or Concat or Star) * Join -> (Simple or Concat or Star)+*+(+Join+) if (res0.element != "Join" && res1.element == "Join") { res.RegExp = res0.RegExp + "*" + "(" + res1.RegExp + ")"; break; } ; //Join * Join ->(+Join+) +*+ (+Join+) if (res0.element == "Join" && res1.element == "Join") { res.RegExp = "(" + res0.RegExp + ")" + "*" + "(" + res1.RegExp + ")"; break; } ; break; case "Join": //1)GET Sources res0 = this.subTrees[0].GetExpression(); res1 = this.subTrees[1].GetExpression(); //Apply Equivalence Transformations //(Simple or Join or Star or Concat) | (Simple or Join or Star or Concat)-> (All)+|+(All) res = new TreeChart("Join", Size.Empty, null); res.RegExp = res0.RegExp + "|" + res1.RegExp; break; default: break; } } return(res); }
//Using //ATTRIBUTES: necessary to study (See Troelsen) //a)<Size elementSize> - Sinthesize(only) + Local + Assignable //because it is necessary for next phase Drawing at the Point point //==> Each phase of Processing with some Attributes can be realized as a separate Thread!!!! //==> General Approach: //any transformation is a special Proceccing with Attributes //There is a need in DEFINING initial kernel data structure that is invariant by all attribute transformation //or it is easy to be inflected!!! //Formal approach is based on a theory of multityped algebra and rewriting system!!! //XML-forms are more suitable as input and output for attribute trancformations, but //intermidiate working data structure for them as more suitable is a object document model: //Model-View-Controller or {Model-Attribute Transformation-Model}- View-Controller. //Such a model corresponds the classic scheme (graphic outline)of processing //(Controller==({Model==(input(x[,y])-{process(x,y)})-View==(output([x,]y))})) //==>>>>> //Follow this sheme for the Algebra of Regular Expressions!!! //<<<<<== //Attribute Size Calculation public TreeChart AssignSizeToTree() { Size elementSize = Size.Empty; TreeChart arg1Tree = null; TreeChart arg2Tree = null; if (this == null) { return(null); } //tree!=null if (!(this.element == "Star" || this.element == "Concat" || this.element == "Join")) { //tree.element.Length > 0 //res = new TreeChart(s, new Size(3 * widthChar, 2+widthChar+2), null); this.rectSize = new Size((kCHAR - 1) * (int)emSizeChar + this.element.Length * (int)emSizeChar + (kCHAR + 1) * (int)emSizeChar, 2 * (4 + (int)emSizeChar + baseElement));//+ 4 return(this); } ; switch (this.element) { case "Star": arg1Tree = this.subTrees[0].AssignSizeToTree(); //Size starSize this.rectSize = new Size(kCHAR * (int)emSizeChar + arg1Tree.rectSize.Width + kCHAR * (int)emSizeChar, up_down_Star + arg1Tree.rectSize.Height + up_down_Star); break; case "Concat": arg1Tree = this.subTrees[0].AssignSizeToTree(); arg2Tree = this.subTrees[1].AssignSizeToTree(); //Size concatSize this.rectSize = new Size(arg1Tree.rectSize.Width + arg2Tree.rectSize.Width, (arg1Tree.rectSize.Height > arg2Tree.rectSize.Height) ? arg1Tree.rectSize.Height : arg2Tree.rectSize.Height); break; case "Join": arg1Tree = this.subTrees[0].AssignSizeToTree(); arg2Tree = this.subTrees[1].AssignSizeToTree(); //Size joinSize int maxWidth = (arg1Tree.rectSize.Width > arg2Tree.rectSize.Width) ? arg1Tree.rectSize.Width : arg2Tree.rectSize.Width; int joinWidth = kCHAR * (int)emSizeChar + maxWidth + kCHAR * (int)emSizeChar; int joinHeight = arg1Tree.rectSize.Height + arg2Tree.rectSize.Height; this.rectSize = new Size(joinWidth, joinHeight); break; default: break; } return(this); }
}//DrawTree //USING //Replaces GetTreeChart: any POLISH --> ready TREE, NO SIZE public static TreeChart PolishToTree(List <string> polish) { //USING //"PolishToTree: //ENUMERATION of VERTEXES is IMPOSSIBLE in VIEW of OPTIMIZATION 2,3 //1)do <<reduction of strings for "Concat">> and //2)do <<join> 1-strings-symbols for "Join"!!!"); //3)do <<star>> <<star>> as <<star>> TreeChart treeChart = null; TreeChart arg1 = null; TreeChart arg2 = null; Stack <TreeChart> stack = new Stack <TreeChart>(); List <string> listSimpleConcat = null; string joinS1S2 = ""; foreach (string s in polish) { if (s.Length == 1) { treeChart = new TreeChart(s, Size.Empty, null); stack.Push(treeChart); } else if (s.Length == 0) { //treeChart = new TreeChart("\"", Size.Empty, null); treeChart = new TreeChart("", Size.Empty, null); stack.Push(treeChart); } else { switch (s) { ////s.Length > 1 case "Star": //(startPpoint,endPoint) in the middle //TODO OPTIMIZATION arg=stack.Pop() if arg.element =="Star" then arg STAR --> arg arg1 = stack.Pop(); if (arg1.element == "Star") { treeChart = arg1; } else { treeChart = new TreeChart("Star", Size.Empty, new TreeChart[] { arg1 }); //stack.Pop() } stack.Push(treeChart); break; case "Concat": //(startPpoint,endPoint) in the middle arg2 = stack.Pop(); arg1 = stack.Pop(); //NEVER OPTIMIZE treeChart = new TreeChart("Concat", Size.Empty, new TreeChart[] { arg1, arg2 }); //childs stack.Push(treeChart); break; case "Join": //(startPpoint,endPoint) in the middle arg2 = stack.Pop(); arg1 = stack.Pop(); //DONE: JoinSimpleOperand-OPTIMIZATION //if( arg1 is <JoinSimpleOperand> && arg2 is <JoinSimpleOperand>) then arg1|arg2 is OPERAND, so //arg1,arg2 --> arg1|arg2 if (!IsJoinSimpleOperand(arg1) || !IsJoinSimpleOperand(arg2)) { treeChart = new TreeChart("Join", Size.Empty, new TreeChart[] { arg1, arg2 }); //childs stack.Push(treeChart); } else //(IsJoinSimpleOperand(arg1) && IsJoinSimpleOperand(arg2)) ; JoinSimpleOperand-OPTIMIZATION DONE { //Boath Values <<rg1.element>> and <<arg2.element>> are strings in a form of // "a" or "a0|a1|...|an" where ai is SYMBOL (ai.Length < 1)and ai != aj if i != j joinS1S2 = JoinSimpleOperand(arg1.element, arg2.element); treeChart = new TreeChart(joinS1S2, Size.Empty, null); //treeChart replaces two trees arg1 and arg2 stack.Push(treeChart); } break; default: //s.Length > 1, s is an string-concatenation //TODO: REDUCE listSimpleConcat = StringToConcat(s); foreach (string symbol in listSimpleConcat) { if (symbol.Length == 1) { treeChart = new TreeChart(symbol, Size.Empty, null); stack.Push(treeChart); } else if (symbol.Length == 0) { treeChart = new TreeChart("\"", Size.Empty, null); stack.Push(treeChart); } else //symbol == "Concat" { arg2 = stack.Pop(); arg1 = stack.Pop(); treeChart = new TreeChart("Concat", Size.Empty, new TreeChart[] { arg1, arg2 }); //childs stack.Push(treeChart); } } break; } } } return(treeChart); }
public static void PrintExpression(TreeChart root) { //root!=null whenever if (!(root.element == "Star" || root.element == "Concat" || root.element == "Join")) { if (root.element.Length == 0) { Console.Write("\"\""); strExpr = strExpr + "\"\""; } else { Console.Write("{0}", root.element); strExpr = strExpr + root.element; } //if (!root.rectSize.IsEmpty) // Console.WriteLine("({0:d3},{1:d3})", root.rectSize.Width, root.rectSize.Height); //else // Console.WriteLine(); } else { switch (root.element) { case "Star": Console.Write("{0}", "{"); strExpr = strExpr + "{"; PrintExpression(root.subTrees[0]); Console.Write("{0}", "}"); strExpr = strExpr + "}"; //if (!root.rectSize.IsEmpty) // Console.WriteLine("({0:d3},{1:d3})", root.rectSize.Width, root.rectSize.Height); //else // Console.WriteLine(); break; case "Concat": if (root.subTrees[0].element == "Join") { Console.Write("{0}", "("); strExpr = strExpr + "("; PrintExpression(root.subTrees[0]); Console.Write("{0}", ")"); strExpr = strExpr + ")"; } else { PrintExpression(root.subTrees[0]); } bool bOpExp0 = (root.subTrees[0].element == "Star" || root.subTrees[0].element == "Concat" || root.subTrees[0].element == "Join"); bool bOpExp1 = (root.subTrees[1].element == "Star" || root.subTrees[1].element == "Concat" || root.subTrees[1].element == "Join"); if (bOpExp0 || bOpExp1) { Console.Write("{0}", "*"); strExpr = strExpr + "*"; } //else //Nothing to DO //Replace root.element with root0.element+root1.element //Change Type of root if (root.subTrees[1].element == "Join") { Console.Write("{0}", "("); strExpr = strExpr + "("; PrintExpression(root.subTrees[1]); Console.Write("{0}", ")"); strExpr = strExpr + ")"; } else { PrintExpression(root.subTrees[1]); } //Console.Write("<{0}>\t", root.element); //if (!root.rectSize.IsEmpty) // Console.WriteLine("({0:d3},{1:d3})", root.rectSize.Width, root.rectSize.Height); //else // Console.WriteLine(); break; case "Join": bool bNoPair = true; bNoPair = (root.subTrees[0].element != "Join" || root.subTrees[1].element != "Join"); if (!bNoPair) { Console.Write("{0}", "("); strExpr = strExpr + "("; } PrintExpression(root.subTrees[0]); Console.Write("{0}", "|"); strExpr = strExpr + "|"; PrintExpression(root.subTrees[1]); if (!bNoPair) { Console.Write("{0}", ")"); strExpr = strExpr + ")"; } //Console.Write("<{0}>\t", root.element); //if (!root.rectSize.IsEmpty) // Console.WriteLine("({0:d3},{1:d3})", root.rectSize.Width, root.rectSize.Height); //else // Console.WriteLine(); break; default: break; } } return; }
//private void FormDiagramm_Paint(object sender, PaintEventArgs e) //{ // if (this.listTreeChart == null) // { // this.Text = "this.treeChart == null"; // return; // } // //-------this.treeChart != null ----- // TreeChart.g = e.Graphics; // Rectangle clientRec =this.ClientRectangle; // //1)==== Get <<atPoint>> for <<startVertex>> of Diagram // Point atPoint = new Point(20, 20+ clientRec.Top); // Font fontSymbol = new Font(FontFamily.GenericMonospace, 14.0F, FontStyle.Bold); // SizeF sizeFDiaName = TreeChart.g.MeasureString(TreeChart.DiagramName, fontSymbol); // //2)----- Draw <<DiagramName>> // TreeChart.g.DrawString(TreeChart.DiagramName, fontSymbol, Brushes.Red, // atPoint.X , treeChart.rectSize.Height + 50); // //3)----- Draw <<RegExp>> for Diagram // TreeChart.g.DrawString(treeChart.RegExp, fontSymbol, Brushes.Black, // atPoint.X, treeChart.rectSize.Height + 80); // //4) =========Draw Diagram as <<treeChart>> starting at <<atPoint>> ========= // treeChart.DrawTree(atPoint); // //5.0)====Draw <<startVertex>> and its nVertex == 0 // Point startVertex = new Point(atPoint.X, atPoint.Y + treeChart.rectSize.Height / 2); // TreeChart.drawVertex(startVertex, Brushes.Red ); // //------nVertex == 0 // TreeChart.drawNumberVertex(startVertex, 0); // //5.1)====Draw <<endVertex>> and its nVertex + 1 and input Arrow // Point endVertex = new Point(atPoint.X + treeChart.rectSize.Width , startVertex.Y); // TreeChart.drawVertex(endVertex, Brushes.Red); // //------nVertex // TreeChart.drawNumberVertex(endVertex, TreeChart.nVertex); // //------input Arrow // TreeChart.drawArrow(new Point(endVertex.X - TreeChart.radiusVertex, endVertex.Y)); // // nVertex+1 -- number vertexes!!! //} public void currTabPage_Paint(object sender, PaintEventArgs e) { //throw new NotImplementedException(); //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TabPage tabPage = sender as TabPage; Graphics g = e.Graphics; Rectangle clientRec = tabPage.ClientRectangle; //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< //{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{ Point atPoint = new Point(20, 20 + clientRec.Top); //////////////////////////////////////////////// int indexTabPage = tabControlDiagram.TabPages.IndexOf(tabPage); TreeChart treeChart = listTreeChart[indexTabPage]; //4) =========Draw Diagram as <<treeChart>> starting at <<atPoint>> ========= treeChart.g = g;//Only for ROOT int nVertex = 1; treeChart.DrawTree(atPoint, ref nVertex); //5.0)====Draw <<startVertex>> and its nVertex == 0 Point startVertex = new Point(atPoint.X, atPoint.Y + treeChart.rectSize.Height / 2); treeChart.drawVertex(startVertex, Brushes.Red); //------nVertex == 0 treeChart.drawNumberVertex(startVertex, 0); //5.1)====Draw <<endVertex>> and its nVertex + 1 and input Arrow Point endVertex = new Point(atPoint.X + treeChart.rectSize.Width, startVertex.Y); treeChart.drawVertex(endVertex, Brushes.Red); //------nVertex //nVertex++; treeChart.drawNumberVertex(endVertex, nVertex); //------input Arrow treeChart.drawArrow(new Point(endVertex.X - TreeChart.radiusVertex, endVertex.Y)); // nVertex+1 -- number vertexes!!! ////////////////////////////////////////////////////////// Font fontSymbol1 = new Font(FontFamily.GenericMonospace, 14.0F, FontStyle.Bold); SizeF sizeFDiaName = g.MeasureString(treeChart.DiagramName, fontSymbol1); //2)----- Draw <<DiagramName>> g.DrawString(treeChart.DiagramName, fontSymbol1, Brushes.Red, atPoint.X, treeChart.rectSize.Height + 50); //3)----- Draw <<RegExp>> for Diagram g.DrawString(treeChart.RegExp, fontSymbol1, Brushes.Black, atPoint.X, treeChart.rectSize.Height + 80); //4)----- Draw <<namedPostfixExp>> for Diagram string str_polish = TreeChart.PolishListToString(treeChart.namedPostfixExp.arrPolish); if (str_polish != "") { g.DrawString("Polish Expression:", fontSymbol1, Brushes.Black, atPoint.X, treeChart.rectSize.Height + 120); g.DrawString(str_polish, fontSymbol1, Brushes.Black, atPoint.X, treeChart.rectSize.Height + 140); } //}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Font fontSymbol2 = new Font(FontFamily.GenericMonospace, 10.0F, FontStyle.Bold); SizeF size_tabPage_Text = g.MeasureString(tabPage.Text, fontSymbol2); //2)----- Draw <<tabPage.Text>> g.DrawString(tabPage.Text, fontSymbol2, Brushes.Green, atPoint.X, clientRec.Height - 50); }
private void toolStripButton1_Click(object sender, EventArgs e) { //sender as ToolStripButton string wmfSelectedTab = tabControlDiagram.SelectedTab.Text + ".wmf"; MessageBox.Show(wmfSelectedTab); //int indexCurrent = tabControlDiagram.SelectedIndex; //MessageBox.Show(string.Format("Curr:{0}",indexCurrent)); string currDir = Directory.GetCurrentDirectory(); string pathWMF = currDir + "\\" + wmfSelectedTab; if (File.Exists(pathWMF)) { MessageBox.Show("Exists, not deleting\n" + pathWMF); //File.Delete(wmfSelectedTab);//pathWMF return; } else { MessageBox.Show("Saving\n" + pathWMF); }; //Draw Metafile: tabControlDiagram.SelectedTab.Text + ".wmf" Metafile curMetafile = null; Graphics gSelTab = tabControlDiagram.SelectedTab.CreateGraphics(); IntPtr hdc = gSelTab.GetHdc(); try { // path63 = Directory.GetCurrentDirectory(); //path63 = path63 + "\\" + "File1163.wmf"; curMetafile = new Metafile(wmfSelectedTab, hdc); } catch (Exception exp) { MessageBox.Show(exp.Message); gSelTab.ReleaseHdc(hdc); gSelTab.Dispose(); return; } // Create a Graphics object from the Metafile object Graphics g = Graphics.FromImage(curMetafile); //Draw metafile like figure on TabPage tabPage=tabControlDiagram.SelectedTab //================ //throw new NotImplementedException(); ////////TabPage tabPage = sender as TabPage; TabPage tabPage = tabControlDiagram.SelectedTab; ///////Graphics g = e.Graphics; // Rectangle clientRec = tabPage.ClientRectangle; Point atPoint = new Point(20, 20 + clientRec.Top); //////////////////////////////////////////////// //------indexTabPage <---> treeChart int indexTabPage = tabControlDiagram.TabPages.IndexOf(tabPage); TreeChart treeChart = listTreeChart[indexTabPage]; //4) =========Draw Diagram as <<treeChart>> starting at <<atPoint>> ========= treeChart.g = g;//Only for ROOT int nVertex = 1; treeChart.DrawTree(atPoint, ref nVertex); //5.0)====Draw <<startVertex>> and its nVertex == 0 Point startVertex = new Point(atPoint.X, atPoint.Y + treeChart.rectSize.Height / 2); treeChart.drawVertex(startVertex, Brushes.Red); //------nVertex == 0 treeChart.drawNumberVertex(startVertex, 0); //5.1)====Draw <<endVertex>> and its nVertex + 1 and input Arrow Point endVertex = new Point(atPoint.X + treeChart.rectSize.Width, startVertex.Y); treeChart.drawVertex(endVertex, Brushes.Red); //------nVertex treeChart.drawNumberVertex(endVertex, nVertex); //------input Arrow treeChart.drawArrow(new Point(endVertex.X - TreeChart.radiusVertex, endVertex.Y)); // nVertex+1 -- number vertexes!!! ////////////////////////////////////////////////////////// Font fontSymbol1 = new Font(FontFamily.GenericMonospace, 14.0F, FontStyle.Bold); SizeF sizeFDiaName = g.MeasureString(treeChart.DiagramName, fontSymbol1); //2)----- Draw <<DiagramName>> g.DrawString(treeChart.DiagramName, fontSymbol1, Brushes.Red, atPoint.X, treeChart.rectSize.Height + 50); //3)----- Draw <<RegExp>> for Diagram g.DrawString(treeChart.RegExp, fontSymbol1, Brushes.Black, atPoint.X, treeChart.rectSize.Height + 80); //////////////////////////////////////////////// Font fontSymbol2 = new Font(FontFamily.GenericMonospace, 10.0F, FontStyle.Bold); SizeF size_tabPage_Text = g.MeasureString(tabPage.Text, fontSymbol2); //2)----- Draw <<tabPage.Text>> g.DrawString(tabPage.Text, fontSymbol2, Brushes.Green, atPoint.X, clientRec.Height - 50); //================ gSelTab.ReleaseHdc(hdc); g.Dispose(); gSelTab.Dispose(); }