开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > .net编程 > 查看源码
xa427f1b2281f554b.cs
资源名称：Csharp_skin.rar　[点击查看]
上传用户：xlxx0122
上传日期：2015-04-24
资源大小：3904k
文件大小：28k
源码类别：

.net编程

开发平台：

C#

xa427f1b2281f554b.cs：源码内容
  1. namespace Sunisoft.IrisSkin
  2. {
  3.     using Sunisoft.IrisSkin.InternalControls;
  4.     using System;
  5.     using System.Collections;
  6.     using System.Drawing;
  7.     using System.Drawing.Drawing2D;
  8.     using System.Windows.Forms;
  10.     internal class xa427f1b2281f554b : xd24df615efe9450e
  11.     {
  12.         private x3c41176af7e54b01 x5486200f56f78413;
  13.         private bool x71d812f69bdec219;
  14.         private Color x7c26c2d810682d2e;
  15.         private MainMenu x946d4396b0c9cde4;
  16.         private xa1883d0b59b7005b xad9f8190f430c699;
  17.         private x095234c5c1abb370 xf6c8424d43a8aa53;
  19.         internal xa427f1b2281f554b(IntPtr handle, SkinEngine engine) : base(handle, engine)
  20.         {
  21.             base.Target = (Form) Control.FromHandle(handle);
  22.             this.x7c26c2d810682d2e = base.Target.BackColor;
  23.             this.x5486200f56f78413 = new x3c41176af7e54b01(base.Engine);
  24.             this.x30c11b5a89921b08();
  25.             if (base.Target.ContextMenu != null)
  26.             {
  27.                 this.xad9f8190f430c699 = new xa1883d0b59b7005b(base.Engine, base.Target.ContextMenu);
  28.             }
  29.             this.x33251e4c534e7926();
  30.             base.ChildTable = new Hashtable();
  31.             if (base.Target.IsMdiContainer)
  32.             {
  33.                 this.x08d09b54d1a926bd();
  34.             }
  35.             this.x05931f73c2d66689();
  36.             if (base.Target.ContextMenuStrip != null)
  37.             {
  38.                 this.xf6c8424d43a8aa53 = new x095234c5c1abb370(base.Target.ContextMenuStrip, base.Engine);
  39.             }
  40.             if (base.Target.MainMenuStrip != null)
  41.             {
  42.                 base.Target.MainMenuStrip.LocationChanged += new EventHandler(this.x1d183dacf6b4e43c);
  43.             }
  44.         }
  46.         protected override bool BeforeWndProc(ref Message m)
  47.         {
  48.             if ((m.Msg == 0x20d3) && (m.WParam.ToInt32() == 0x20d3))
  49.             {
  50.                 this.xbe3f57786c90d37f();
  51.             }
  52.             return base.BeforeWndProc(ref m);
  53.         }
  55.         protected override void OnCurrentSkinChanged(object sender, SkinChangedEventArgs e)
  56.         {
  57.             if (!this.CanPaint)
  58.             {
  59.                 if (this.x5486200f56f78413 != null)
  60.                 {
  61.                     this.x5486200f56f78413.MdiContainer = null;
  62.                     if (base.Target.Controls.Contains(this.x5486200f56f78413))
  63.                     {
  64.                         base.Target.Controls.Remove(this.x5486200f56f78413);
  65.                     }
  66.                 }
  67.                 if ((base.Target.Menu != this.x946d4396b0c9cde4) && (this.x946d4396b0c9cde4 != null))
  68.                 {
  69.                     base.Target.Menu = this.x946d4396b0c9cde4;
  70.                 }
  71.                 this.x33251e4c534e7926();
  72.                 if (this.CanPaintChild)
  73.                 {
  74.                     this.x7ca6c09f91bb596a();
  75.                 }
  76.             }
  77.             else
  78.             {
  79.                 this.x30c11b5a89921b08();
  80.                 this.x33251e4c534e7926();
  81.                 this.x7ca6c09f91bb596a();
  82.                 this.RegionWindow();
  83.             }
  84.             this.x05931f73c2d66689();
  85.             base.OnCurrentSkinChanged(sender, e);
  86.         }
  88.         protected override void PaintBorder(Graphics g)
  89.         {
  90.             Rectangle rectangle;
  91.             Rectangle rectangle2;
  92.             Rectangle rectangle3;
  93.             Rectangle rectangle4;
  94.             base.PaintBorder(g);
  95.             if (((base.Engine.LeftBorderWidth >= base.cxBorder) && (base.Engine.RightBorderWidth >= base.cxBorder)) || (this.x946d4396b0c9cde4 == null))
  96.             {
  97.                 goto Label_0357;
  98.             }
  99.             int height = this.x5486200f56f78413.Height;
  100.             Bitmap image = base.Engine.Res.Bitmaps.SKIN2_MENUBAR;
  101.             if (base.Engine.LeftBorderWidth < base.cxBorder)
  102.             {
  103.                 rectangle = new Rectangle(base.Engine.LeftBorderWidth, base.Engine.TitleHeight + this.x5486200f56f78413.Top, base.cxBorder - base.Engine.LeftBorderWidth, height);
  104.                 if (image != null)
  105.                 {
  106.                     if (image.Width > (base.cxBorder - base.Engine.LeftBorderWidth))
  107.                     {
  108.                         rectangle2 = new Rectangle(0, 0, base.cxBorder - base.Engine.LeftBorderWidth, image.Height);
  109.                     }
  110.                     else
  111.                     {
  112.                         rectangle2 = new Rectangle(0, 0, image.Width, image.Height);
  113.                     }
  114.                     g.DrawImage(image, rectangle, rectangle2.X, rectangle2.Y, rectangle2.Width, rectangle2.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  115.                 }
  116.                 else
  117.                 {
  118.                     if (base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR != base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR)
  119.                     {
  120.                         using (LinearGradientBrush brush = new LinearGradientBrush(rectangle, base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR, base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR, LinearGradientMode.Vertical))
  121.                         {
  122.                             g.FillRectangle(brush, rectangle);
  123.                             goto Label_01CD;
  124.                         }
  125.                     }
  126.                     g.FillRectangle(base.Engine.Res.Brushes.SKIN2_MENUBARSTARTCOLOR, rectangle);
  127.                 }
  128.             }
  129.         Label_01CD:
  130.             if (base.Engine.RightBorderWidth < base.cxBorder)
  131.             {
  132.                 rectangle = new Rectangle(this.Width - base.cxBorder, this.x5486200f56f78413.Top + base.Engine.TitleHeight, base.cxBorder - base.Engine.RightBorderWidth, height);
  133.                 if (image != null)
  134.                 {
  135.                     if (image.Width > (base.cxBorder - base.Engine.RightBorderWidth))
  136.                     {
  137.                         rectangle2 = new Rectangle((image.Width - base.cxBorder) + base.Engine.RightBorderWidth, 0, base.cxBorder - base.Engine.RightBorderWidth, image.Height);
  138.                     }
  139.                     else
  140.                     {
  141.                         rectangle2 = new Rectangle(0, 0, image.Width, image.Height);
  142.                     }
  143.                     g.DrawImage(image, rectangle, rectangle2.X, rectangle2.Y, rectangle2.Width, rectangle2.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  144.                 }
  145.                 else
  146.                 {
  147.                     if (base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR != base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR)
  148.                     {
  149.                         using (LinearGradientBrush brush2 = new LinearGradientBrush(rectangle, base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR, base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR, LinearGradientMode.Vertical))
  150.                         {
  151.                             g.FillRectangle(brush2, rectangle);
  152.                             goto Label_0357;
  153.                         }
  154.                     }
  155.                     g.FillRectangle(base.Engine.Res.Brushes.SKIN2_MENUBARSTARTCOLOR, rectangle);
  156.                 }
  157.             }
  158.         Label_0357:
  159.             if (((base.Engine.LeftBorderWidth >= base.cxBorder) && (base.Engine.RightBorderWidth >= base.cxBorder)) || (base.Target.MainMenuStrip == null))
  160.             {
  161.                 return;
  162.             }
  163.             int num2 = base.Target.MainMenuStrip.Height;
  164.             Bitmap bitmap2 = base.Engine.Res.Bitmaps.SKIN2_MENUBAR;
  165.             if (base.Engine.LeftBorderWidth < base.cxBorder)
  166.             {
  167.                 rectangle3 = new Rectangle(base.Engine.LeftBorderWidth, base.Engine.TitleHeight + base.Target.MainMenuStrip.Top, base.cxBorder - base.Engine.LeftBorderWidth, num2);
  168.                 if (bitmap2 != null)
  169.                 {
  170.                     if (bitmap2.Width > (base.cxBorder - base.Engine.LeftBorderWidth))
  171.                     {
  172.                         rectangle4 = new Rectangle(0, 0, base.cxBorder - base.Engine.LeftBorderWidth, bitmap2.Height);
  173.                     }
  174.                     else
  175.                     {
  176.                         rectangle4 = new Rectangle(0, 0, bitmap2.Width, bitmap2.Height);
  177.                     }
  178.                     g.DrawImage(bitmap2, rectangle3, rectangle4.X, rectangle4.Y, rectangle4.Width, rectangle4.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  179.                 }
  180.                 else
  181.                 {
  182.                     if (base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR != base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR)
  183.                     {
  184.                         using (LinearGradientBrush brush3 = new LinearGradientBrush(rectangle3, base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR, base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR, LinearGradientMode.Vertical))
  185.                         {
  186.                             g.FillRectangle(brush3, rectangle3);
  187.                             goto Label_0539;
  188.                         }
  189.                     }
  190.                     g.FillRectangle(base.Engine.Res.Brushes.SKIN2_MENUBARSTARTCOLOR, rectangle3);
  191.                 }
  192.             }
  193.         Label_0539:
  194.             if (base.Engine.RightBorderWidth < base.cxBorder)
  195.             {
  196.                 rectangle3 = new Rectangle(this.Width - base.cxBorder, base.Engine.TitleHeight + base.Target.MainMenuStrip.Top, base.cxBorder - base.Engine.RightBorderWidth, num2);
  197.                 if (bitmap2 != null)
  198.                 {
  199.                     if (bitmap2.Width > (base.cxBorder - base.Engine.RightBorderWidth))
  200.                     {
  201.                         rectangle4 = new Rectangle((bitmap2.Width - base.cxBorder) + base.Engine.RightBorderWidth, 0, base.cxBorder - base.Engine.RightBorderWidth, bitmap2.Height);
  202.                     }
  203.                     else
  204.                     {
  205.                         rectangle4 = new Rectangle(0, 0, bitmap2.Width, bitmap2.Height);
  206.                     }
  207.                     g.DrawImage(bitmap2, rectangle3, rectangle4.X, rectangle4.Y, rectangle4.Width, rectangle4.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  208.                     return;
  209.                 }
  210.                 if (base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR != base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR)
  211.                 {
  212.                     using (LinearGradientBrush brush4 = new LinearGradientBrush(rectangle3, base.Engine.Res.Colors.SKIN2_MENUBARSTARTCOLOR, base.Engine.Res.Colors.SKIN2_MENUBARENDCOLOR, LinearGradientMode.Vertical))
  213.                     {
  214.                         g.FillRectangle(brush4, rectangle3);
  215.                         return;
  216.                     }
  217.                 }
  218.                 g.FillRectangle(base.Engine.Res.Brushes.SKIN2_MENUBARSTARTCOLOR, rectangle3);
  219.             }
  220.         }
  222.         protected override Point PointToScreen(Point point)
  223.         {
  224.             return base.Target.PointToScreen(point);
  225.         }
  227.         protected override void RefreshMainMenu()
  228.         {
  229.             if (this.x5486200f56f78413 != null)
  230.             {
  231.                 this.x5486200f56f78413.Refresh();
  232.             }
  233.         }
  235.         protected override void RefreshWindow()
  236.         {
  237.             base.Target.Refresh();
  238.         }
  240.         protected override void SkinControls()
  241.         {
  242.             if (!base.Target.IsDisposed)
  243.             {
  244.                 base.Target.ControlAdded += new ControlEventHandler(this.xe08c104b24ddae95);
  245.                 base.Target.ControlRemoved += new ControlEventHandler(this.xbd90dc5580ff6562);
  246.             }
  247.             if (this.CanPaintChild)
  248.             {
  249.                 ArrayList list = new ArrayList();
  250.                 foreach (Control control in base.Target.Controls)
  251.                 {
  252.                     if (!(control is MdiClient) && !base.ControlTable.ContainsKey(control.Handle))
  253.                     {
  254.                         list.Add(control);
  255.                     }
  256.                 }
  257.                 foreach (Control control2 in list)
  258.                 {
  259.                     if (!base.ControlTable.ContainsKey(control2.Handle))
  260.                     {
  261.                         xbd3f2493841f18a1 xbdffa = xf3f6919ac5d158dc.Create(control2, base.Engine);
  262.                         base.ControlTable.Add(control2.Handle, xbdffa);
  263.                     }
  264.                 }
  265.             }
  266.         }
  268.         private void x05931f73c2d66689()
  269.         {
  270.             if (this.CanPaint)
  271.             {
  272.                 base.Target.BackColor = base.Engine.Res.Colors.SKIN2_FORMCOLOR;
  273.             }
  274.             else if (!this.IsDisposed && (this.BorderStyle != FormBorderStyle.None))
  275.             {
  276.                 base.Target.BackColor = this.x7c26c2d810682d2e;
  277.             }
  278.         }
  280.         private void x08d09b54d1a926bd()
  281.         {
  282.             base.Target.MdiChildActivate += new EventHandler(this.x23daf02978257d54);
  283.             this.x23daf02978257d54(null, null);
  284.         }
  286.         private void x1d183dacf6b4e43c(object xe0292b9ed559da7d, EventArgs xfbf34718e704c6bc)
  287.         {
  288.             base.x3b8ca818f0c2637e();
  289.         }
  291.         private void x23daf02978257d54(object xe0292b9ed559da7d, EventArgs xfbf34718e704c6bc)
  292.         {
  293.             xa427f1b2281f554b xafbfb;
  294.             foreach (Form form in base.Target.MdiChildren)
  295.             {
  296.                 if (((form != null) && !form.IsDisposed) && (form.Visible && !base.ChildTable.ContainsKey(form.Handle)))
  297.                 {
  298.                     xafbfb = new xa427f1b2281f554b(form.Handle, base.Engine);
  299.                     base.ChildTable.Add(form.Handle, xafbfb);
  300.                 }
  301.             }
  302.             if (base.Target.ActiveMdiChild != null)
  303.             {
  304.                 foreach (object obj3 in base.ChildTable.Keys)
  305.                 {
  306.                     if (obj3 is IntPtr)
  307.                     {
  308.                         object obj2;
  309.                         if (((IntPtr) obj3) == base.Target.ActiveMdiChild.Handle)
  310.                         {
  311.                             obj2 = base.ChildTable[obj3];
  312.                             if (obj2 is xa427f1b2281f554b)
  313.                             {
  314.                                 xafbfb = (xa427f1b2281f554b) obj2;
  315.                                 xafbfb.IsActive = true;
  316.                             }
  317.                         }
  318.                         else
  319.                         {
  320.                             obj2 = base.ChildTable[obj3];
  321.                             if (obj2 is xa427f1b2281f554b)
  322.                             {
  323.                                 xafbfb = (xa427f1b2281f554b) obj2;
  324.                                 xafbfb.IsActive = false;
  325.                                 x61467fe65a98f20c.SendMessage((IntPtr) obj3, 0x85, IntPtr.Zero, IntPtr.Zero);
  326.                             }
  327.                         }
  328.                     }
  329.                 }
  330.             }
  331.         }
  333.         private void x30c11b5a89921b08()
  334.         {
  335.             if (base.Target.Menu == null)
  336.             {
  337.                 if (base.Target.IsMdiContainer && (this.x5486200f56f78413 != null))
  338.                 {
  339.                     this.x5486200f56f78413.MdiContainer = base.Target;
  340.                 }
  341.             }
  342.             else if ((!base.Target.IsMdiContainer || (base.Target.MainMenuStrip == null)) && this.CanPaint)
  343.             {
  344.                 this.x946d4396b0c9cde4 = base.Target.Menu;
  345.                 base.Target.Menu = null;
  346.                 this.x45cc2ae14a69c414();
  347.                 if (base.Target.IsMdiContainer)
  348.                 {
  349.                     this.x5486200f56f78413.MdiContainer = base.Target;
  350.                 }
  351.                 base.Target.Controls.Add(this.x5486200f56f78413);
  352.                 new x4fef14ebf3863c7f(this.x5486200f56f78413, this.x946d4396b0c9cde4);
  353.             }
  354.         }
  356.         private void x33251e4c534e7926()
  357.         {
  358.             if (!base.Target.IsDisposed && (base.Target.WindowState == FormWindowState.Normal))
  359.             {
  360.                 int num = base.Engine.TitleHeight + Math.Max(base.Engine.BottomBorderHeight, base.cyBorder);
  361.                 int num2 = Math.Max(base.Engine.LeftBorderWidth, base.cxBorder) + Math.Max(base.Engine.RightBorderWidth, base.cxBorder);
  362.                 if (this.CanPaint)
  363.                 {
  364.                     base.Target.Height = (num + base.RestoreClientHeight) + this.MenuHeight;
  365.                     base.Target.Width = num2 + base.RestoreClientWidth;
  366.                 }
  367.                 else
  368.                 {
  369.                     base.Target.Height = base.RestoreHeight;
  370.                     base.Target.Width = base.RestoreWidth;
  371.                 }
  372.                 if (!this.x71d812f69bdec219)
  373.                 {
  374.                     this.x71d812f69bdec219 = true;
  375.                     if (this.MenuHeight > 0)
  376.                     {
  377.                         foreach (Control control in base.Target.Controls)
  378.                         {
  379.                             if (control != this.x5486200f56f78413)
  380.                             {
  381.                                 try
  382.                                 {
  383.                                     if (control.Dock == DockStyle.None)
  384.                                     {
  385.                                         control.Top += this.MenuHeight;
  386.                                     }
  387.                                     continue;
  388.                                 }
  389.                                 catch
  390.                                 {
  391.                                     continue;
  392.                                 }
  393.                             }
  394.                         }
  395.                     }
  396.                 }
  397.             }
  398.         }
  400.         private void x45cc2ae14a69c414()
  401.         {
  402.             if (this.x946d4396b0c9cde4 != null)
  403.             {
  404.                 x5f4b657f68f87baa xfbffbaa;
  405.                 if (this.x5486200f56f78413 == null)
  406.                 {
  407.                     this.x5486200f56f78413 = new x3c41176af7e54b01(base.Engine);
  408.                 }
  409.                 if ((this.x946d4396b0c9cde4.RightToLeft & System.Windows.Forms.RightToLeft.Inherit) == System.Windows.Forms.RightToLeft.Inherit)
  410.                 {
  411.                     this.x5486200f56f78413.RightToLeft = base.Target.RightToLeft;
  412.                 }
  413.                 else
  414.                 {
  415.                     this.x5486200f56f78413.RightToLeft = this.x946d4396b0c9cde4.RightToLeft;
  416.                 }
  417.                 this.x5486200f56f78413.MenuCommands.Clear();
  418.                 ArrayList list = new ArrayList();
  419.                 ArrayList list2 = new ArrayList();
  420.                 foreach (MenuItem item2 in this.x946d4396b0c9cde4.MenuItems)
  421.                 {
  422.                     xfbffbaa = this.xd010ef1851698a47(item2);
  423.                     this.x5486200f56f78413.MenuCommands.Add(xfbffbaa);
  424.                     if (item2.MenuItems.Count > 0)
  425.                     {
  426.                         list.Add(item2);
  427.                         list2.Add(xfbffbaa);
  428.                     }
  429.                 }
  430.                 while (list.Count > 0)
  431.                 {
  432.                     MenuItem item = (MenuItem) list[0];
  433.                     x5f4b657f68f87baa xfbffbaa2 = (x5f4b657f68f87baa) list2[0];
  434.                     list.RemoveAt(0);
  435.                     list2.RemoveAt(0);
  436.                     foreach (MenuItem item3 in item.MenuItems)
  437.                     {
  438.                         xfbffbaa = this.xd010ef1851698a47(item3);
  439.                         xfbffbaa2.MenuCommands.Add(xfbffbaa);
  440.                         if (item3.MenuItems.Count > 0)
  441.                         {
  442.                             list.Add(item3);
  443.                             list2.Add(xfbffbaa);
  444.                         }
  445.                     }
  446.                 }
  447.             }
  448.         }
  450.         private void x7ca6c09f91bb596a()
  451.         {
  452.             if (this.CanPaintChild)
  453.             {
  454.                 ArrayList list = new ArrayList();
  455.                 foreach (Control control in base.Target.Controls)
  456.                 {
  457.                     if (!(control is MdiClient) && !base.ControlTable.ContainsKey(control.Handle))
  458.                     {
  459.                         list.Add(control);
  460.                     }
  461.                 }
  462.                 foreach (Control control2 in list)
  463.                 {
  464.                     if (!base.ControlTable.ContainsKey(control2.Handle))
  465.                     {
  466.                         xbd3f2493841f18a1 xbdffa = xf3f6919ac5d158dc.Create(control2, base.Engine);
  467.                         base.ControlTable.Add(control2.Handle, xbdffa);
  468.                     }
  469.                 }
  470.             }
  471.         }
  473.         private void xbd90dc5580ff6562(object xe0292b9ed559da7d, ControlEventArgs xfbf34718e704c6bc)
  474.         {
  475.         }
  477.         private void xbe3f57786c90d37f()
  478.         {
  479.             if ((this.CanPaint && (this.x5486200f56f78413 != null)) && (this.x946d4396b0c9cde4 != null))
  480.             {
  481.                 this.xe09f26c14e176ef5();
  482.             }
  483.         }
  485.         private x5f4b657f68f87baa xd010ef1851698a47(MenuItem xccb63ca5f63dc470)
  486.         {
  487.             x5f4b657f68f87baa xfbffbaa = new x5f4b657f68f87baa();
  488.             xfbffbaa.AttachedMenuItem = xccb63ca5f63dc470;
  489.             xfbffbaa.Click += new EventHandler(this.xe26186777e7e0508);
  490.             return xfbffbaa;
  491.         }
  493.         private void xe08c104b24ddae95(object xe0292b9ed559da7d, ControlEventArgs xfbf34718e704c6bc)
  494.         {
  495.             if (this.CanPaintChild)
  496.             {
  497.                 Control control = xfbf34718e704c6bc.Control;
  498.                 if (!(control is MdiClient) && !base.ControlTable.ContainsKey(control.Handle))
  499.                 {
  500.                     xbd3f2493841f18a1 xbdffa = xf3f6919ac5d158dc.Create(control, base.Engine);
  501.                     base.ControlTable.Add(control.Handle, xbdffa);
  502.                 }
  503.             }
  504.         }
  506.         private void xe09f26c14e176ef5()
  507.         {
  508.             x5f4b657f68f87baa xfbffbaa;
  509.             this.x5486200f56f78413.MenuCommands.Clear();
  510.             ArrayList list = new ArrayList();
  511.             ArrayList list2 = new ArrayList();
  512.             foreach (MenuItem item2 in this.x946d4396b0c9cde4.MenuItems)
  513.             {
  514.                 xfbffbaa = this.xd010ef1851698a47(item2);
  515.                 this.x5486200f56f78413.MenuCommands.Add(xfbffbaa);
  516.                 if (item2.MenuItems.Count > 0)
  517.                 {
  518.                     list.Add(item2);
  519.                     list2.Add(xfbffbaa);
  520.                 }
  521.             }
  522.             while (list.Count > 0)
  523.             {
  524.                 MenuItem item = (MenuItem) list[0];
  525.                 x5f4b657f68f87baa xfbffbaa2 = (x5f4b657f68f87baa) list2[0];
  526.                 list.RemoveAt(0);
  527.                 list2.RemoveAt(0);
  528.                 foreach (MenuItem item3 in item.MenuItems)
  529.                 {
  530.                     xfbffbaa = this.xd010ef1851698a47(item3);
  531.                     xfbffbaa2.MenuCommands.Add(xfbffbaa);
  532.                     if (item3.MenuItems.Count > 0)
  533.                     {
  534.                         list.Add(item3);
  535.                         list2.Add(xfbffbaa);
  536.                     }
  537.                 }
  538.             }
  539.         }
  541.         private void xe26186777e7e0508(object xe0292b9ed559da7d, EventArgs xfbf34718e704c6bc)
  542.         {
  543.             if (xe0292b9ed559da7d is x5f4b657f68f87baa)
  544.             {
  545.                 x5f4b657f68f87baa xfbffbaa = (x5f4b657f68f87baa) xe0292b9ed559da7d;
  546.                 if (xfbffbaa.AttachedMenuItem != null)
  547.                 {
  548.                     xfbffbaa.AttachedMenuItem.PerformClick();
  549.                 }
  550.             }
  551.         }
  553.         protected override FormBorderStyle BorderStyle
  554.         {
  555.             get
  556.             {
  557.                 return base.Target.FormBorderStyle;
  558.             }
  559.         }
  561.         protected override Rectangle ClientRectangle
  562.         {
  563.             get
  564.             {
  565.                 return base.Target.ClientRectangle;
  566.             }
  567.         }
  569.         protected override bool ControlBox
  570.         {
  571.             get
  572.             {
  573.                 return base.Target.ControlBox;
  574.             }
  575.         }
  577.         protected override int Height
  578.         {
  579.             get
  580.             {
  581.                 return base.Target.Height;
  582.             }
  583.         }
  585.         protected override bool HelpButton
  586.         {
  587.             get
  588.             {
  589.                 return base.Target.HelpButton;
  590.             }
  591.         }
  593.         protected override System.Drawing.Icon Icon
  594.         {
  595.             get
  596.             {
  597.                 switch (base.Target.FormBorderStyle)
  598.                 {
  599.                     case FormBorderStyle.FixedToolWindow:
  600.                     case FormBorderStyle.SizableToolWindow:
  601.                         return null;
  602.                 }
  603.                 return base.Target.Icon;
  604.             }
  605.         }
  607.         protected override bool IsActive
  608.         {
  609.             get
  610.             {
  611.                 if (base.Target.IsMdiChild)
  612.                 {
  613.                     return (base.Target == base.Target.MdiParent.ActiveMdiChild);
  614.                 }
  615.                 if (base.Target.IsMdiContainer)
  616.                 {
  617.                     return (base.Target == Form.ActiveForm);
  618.                 }
  619.                 return base.IsActive;
  620.             }
  621.             set
  622.             {
  623.                 base.IsActive = value;
  624.             }
  625.         }
  627.         protected override bool IsDisposed
  628.         {
  629.             get
  630.             {
  631.                 return base.Target.IsDisposed;
  632.             }
  633.         }
  635.         protected override bool IsMdiChild
  636.         {
  637.             get
  638.             {
  639.                 return base.Target.IsMdiChild;
  640.             }
  641.         }
  643.         protected override bool IsMdiContainer
  644.         {
  645.             get
  646.             {
  647.                 return base.Target.IsMdiContainer;
  648.             }
  649.         }
  651.         protected override bool MaximizeBox
  652.         {
  653.             get
  654.             {
  655.                 switch (base.Target.FormBorderStyle)
  656.                 {
  657.                     case FormBorderStyle.FixedToolWindow:
  658.                     case FormBorderStyle.SizableToolWindow:
  659.                         return false;
  660.                 }
  661.                 return base.Target.MaximizeBox;
  662.             }
  663.         }
  665.         protected override int MenuHeight
  666.         {
  667.             get
  668.             {
  669.                 if ((this.x946d4396b0c9cde4 != null) && (this.x5486200f56f78413 != null))
  670.                 {
  671.                     return this.x5486200f56f78413.Height;
  672.                 }
  673.                 return 0;
  674.             }
  675.         }
  677.         protected override bool MinimizeBox
  678.         {
  679.             get
  680.             {
  681.                 switch (base.Target.FormBorderStyle)
  682.                 {
  683.                     case FormBorderStyle.FixedToolWindow:
  684.                     case FormBorderStyle.SizableToolWindow:
  685.                         return false;
  686.                 }
  687.                 return base.Target.MinimizeBox;
  688.             }
  689.         }
  691.         protected override System.Drawing.Region Region
  692.         {
  693.             get
  694.             {
  695.                 return base.Target.Region;
  696.             }
  697.             set
  698.             {
  699.                 base.Target.Region = value;
  700.             }
  701.         }
  703.         protected override System.Windows.Forms.RightToLeft RightToLeft
  704.         {
  705.             get
  706.             {
  707.                 return base.Target.RightToLeft;
  708.             }
  709.         }
  711.         protected override bool RightToLeftLayout
  712.         {
  713.             get
  714.             {
  715.                 return (base.Target.RightToLeftLayout && ((base.Target.RightToLeft & System.Windows.Forms.RightToLeft.Yes) == System.Windows.Forms.RightToLeft.Yes));
  716.             }
  717.         }
  719.         protected override object Tag
  720.         {
  721.             get
  722.             {
  723.                 return base.Target.Tag;
  724.             }
  725.         }
  727.         protected override string Text
  728.         {
  729.             get
  730.             {
  731.                 return base.Target.Text;
  732.             }
  733.         }
  735.         protected override int TitleHeight
  736.         {
  737.             get
  738.             {
  739.                 if ((this.IsMdiChild && (this.WindowState == FormWindowState.Maximized)) && (this.x946d4396b0c9cde4 != null))
  740.                 {
  741.                     return (this.x5486200f56f78413.Height - 1);
  742.                 }
  743.                 return base.Engine.TitleHeight;
  744.             }
  745.         }
  747.         protected override int Width
  748.         {
  749.             get
  750.             {
  751.                 return base.Target.Width;
  752.             }
  753.         }
  754.     }
  755. }