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

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

.net编程

开发平台：

C#

x448fd9ab43628c71.cs：源码内容
  1. namespace Sunisoft.IrisSkin
  2. {
  3.     using System;
  4.     using System.Collections;
  5.     using System.ComponentModel;
  6.     using System.Drawing;
  7.     using System.Drawing.Drawing2D;
  8.     using System.Drawing.Imaging;
  9.     using System.Drawing.Text;
  10.     using System.Reflection;
  11.     using System.Runtime.InteropServices;
  12.     using System.Windows.Forms;
  13.     using x293b01486f981425;
  15.     internal class x448fd9ab43628c71
  16.     {
  17.         public const int AlignWidth = 0;
  18.         public const byte Encript1 = 0x44;
  19.         public static byte Encript2 = 0x38;
  20.         public const byte Encript3 = 0x21;
  21.         public static byte Encript4 = 0x33;
  22.         public const byte IV1 = 0x63;
  23.         public static byte IV2 = 0x76;
  24.         public static byte IV3 = 0xa1;
  25.         public static byte IV4 = 0xa6;
  26.         private static bool x02a9729195580525 = false;
  27.         internal static Hashtable x1c12011307e0a753;
  28.         private static Color x27d07b3cbf2c9479 = Color.FromArgb(0xff, 0, 0xff);
  29.         private static StringFormat x488379a1c8afe803;
  30.         private static Pen x4f0034703b20af0f;
  31.         private static bool x605ccaa3586218f6 = false;
  32.         private static ImageAttributes x68a7ff53010868dc = new ImageAttributes();
  33.         private static ImageAttributes xa11b666f50e9398f = new ImageAttributes();
  34.         private static StringFormat xad5d7fbaf75245c8;
  35.         private static ImageAttributes xc7766c1739984987 = new ImageAttributes();
  36.         private static StringFormat xd02bd90925d5d5ca;
  37.         private static StringFormat xe8c22659bee459d5;
  39.         static x448fd9ab43628c71()
  40.         {
  41.             IV4 = 0xb5;
  42.             x4f0034703b20af0f = new Pen(Color.Black, 1f);
  43.             x4f0034703b20af0f.DashStyle = DashStyle.Dot;
  44.             x488379a1c8afe803 = new StringFormat();
  45.             x488379a1c8afe803.Alignment = StringAlignment.Center;
  46.             x488379a1c8afe803.LineAlignment = StringAlignment.Center;
  47.             x488379a1c8afe803.HotkeyPrefix = HotkeyPrefix.Show;
  48.             xd02bd90925d5d5ca = new StringFormat();
  49.             xd02bd90925d5d5ca.Alignment = StringAlignment.Near;
  50.             xd02bd90925d5d5ca.LineAlignment = StringAlignment.Center;
  51.             xd02bd90925d5d5ca.HotkeyPrefix = HotkeyPrefix.Show;
  52.             xe8c22659bee459d5 = new StringFormat();
  53.             xe8c22659bee459d5.Alignment = StringAlignment.Near;
  54.             xe8c22659bee459d5.LineAlignment = StringAlignment.Center;
  55.             xe8c22659bee459d5.HotkeyPrefix = HotkeyPrefix.Show;
  56.             xe8c22659bee459d5.FormatFlags = StringFormatFlags.DirectionRightToLeft;
  57.             xad5d7fbaf75245c8 = new StringFormat();
  58.             xad5d7fbaf75245c8.Alignment = StringAlignment.Far;
  59.             xad5d7fbaf75245c8.LineAlignment = StringAlignment.Center;
  60.             xad5d7fbaf75245c8.HotkeyPrefix = HotkeyPrefix.None;
  61.             xc7766c1739984987.SetWrapMode(WrapMode.TileFlipX);
  62.             x68a7ff53010868dc.SetWrapMode(WrapMode.TileFlipY);
  63.             xa11b666f50e9398f.SetNoOp();
  64.             xa11b666f50e9398f.SetWrapMode(WrapMode.TileFlipXY);
  65.             IV2 = 0x77;
  66.             Encript2 = 0x44;
  67.             x1c12011307e0a753 = new Hashtable();
  68.             x1c12011307e0a753.Add("flcRzsRtDNr2XBiCoY7NrAC352AiFA/4YuLs4nDCyOHZX5xvWtgH/g==", null);
  69.             x1c12011307e0a753.Add("isBx30VBCC0GTnJuOKmQ0jK7I8NqeyOjDigXGIG5v1dN7aw4qc3Ogw==", null);
  70.         }
  72.         private x448fd9ab43628c71()
  73.         {
  74.         }
  76.         public static void CalcLayoutRect(ContentAlignment align, Rectangle clientRect, RightToLeft rightToLeft, out Rectangle rect, out StringFormat format)
  77.         {
  78.             format = new StringFormat();
  79.             if (rightToLeft == RightToLeft.Yes)
  80.             {
  81.                 format.FormatFlags = StringFormatFlags.DirectionRightToLeft;
  82.             }
  83.             format.HotkeyPrefix = HotkeyPrefix.Show;
  84.             rect = Rectangle.FromLTRB(clientRect.Left, clientRect.Top, clientRect.Right, clientRect.Bottom);
  85.             switch (align)
  86.             {
  87.                 case ContentAlignment.TopLeft:
  88.                     format.Alignment = StringAlignment.Near;
  89.                     format.LineAlignment = StringAlignment.Near;
  90.                     return;
  92.                 case ContentAlignment.TopCenter:
  93.                     format.Alignment = StringAlignment.Center;
  94.                     format.LineAlignment = StringAlignment.Near;
  95.                     return;
  97.                 case ContentAlignment.TopRight:
  98.                     format.Alignment = StringAlignment.Far;
  99.                     format.LineAlignment = StringAlignment.Near;
  100.                     return;
  102.                 case ContentAlignment.MiddleLeft:
  103.                     format.Alignment = StringAlignment.Near;
  104.                     format.LineAlignment = StringAlignment.Center;
  105.                     return;
  107.                 case ContentAlignment.BottomCenter:
  108.                     format.Alignment = StringAlignment.Center;
  109.                     format.LineAlignment = StringAlignment.Far;
  110.                     return;
  112.                 case ContentAlignment.BottomRight:
  113.                     format.Alignment = StringAlignment.Far;
  114.                     format.LineAlignment = StringAlignment.Far;
  115.                     return;
  117.                 case ContentAlignment.MiddleRight:
  118.                     format.Alignment = StringAlignment.Far;
  119.                     format.LineAlignment = StringAlignment.Center;
  120.                     return;
  122.                 case ContentAlignment.BottomLeft:
  123.                     format.Alignment = StringAlignment.Near;
  124.                     format.LineAlignment = StringAlignment.Far;
  125.                     return;
  126.             }
  127.             format.Alignment = StringAlignment.Center;
  128.             format.LineAlignment = StringAlignment.Center;
  129.         }
  131.         public static Rectangle CalcLayoutRect(ContentAlignment align, RightToLeft rightToLeft, Rectangle clientRect, int width, int height)
  132.         {
  133.             return CalcLayoutRect(align, rightToLeft, clientRect, width, height, 0);
  134.         }
  136.         public static Rectangle CalcLayoutRect(ContentAlignment align, RightToLeft rightToLeft, Rectangle clientRect, int width, int height, int alignWidth)
  137.         {
  138.             return CalcLayoutRect(align, rightToLeft, clientRect, width, height, alignWidth, alignWidth);
  139.         }
  141.         public static Rectangle CalcLayoutRect(ContentAlignment align, RightToLeft rightToLeft, Rectangle clientRect, int width, int height, int alignW, int alignH)
  142.         {
  143.             int num = alignW;
  144.             int num2 = alignH;
  145.             switch (align)
  146.             {
  147.                 case ContentAlignment.TopLeft:
  148.                     if ((rightToLeft & RightToLeft.Yes) != RightToLeft.Yes)
  149.                     {
  150.                         return new Rectangle(clientRect.Left + num, clientRect.Top + num2, width, height);
  151.                     }
  152.                     return new Rectangle((clientRect.Right - num) - width, clientRect.Top + num2, width, height);
  154.                 case ContentAlignment.TopCenter:
  155.                     return new Rectangle((clientRect.Width - width) / 2, clientRect.Top + num2, width, height);
  157.                 case ContentAlignment.TopRight:
  158.                     if ((rightToLeft & RightToLeft.Yes) != RightToLeft.Yes)
  159.                     {
  160.                         return new Rectangle((clientRect.Right - num) - width, clientRect.Top + num2, width, height);
  161.                     }
  162.                     return new Rectangle(clientRect.Left + num, clientRect.Top + num2, width, height);
  164.                 case ContentAlignment.MiddleLeft:
  165.                     if ((rightToLeft & RightToLeft.Yes) == RightToLeft.Yes)
  166.                     {
  167.                         return new Rectangle((clientRect.Right - num) - width, (clientRect.Height - height) / 2, width, height);
  168.                     }
  169.                     return new Rectangle(clientRect.Left + num, (clientRect.Height - height) / 2, width, height);
  171.                 case ContentAlignment.MiddleCenter:
  172.                     return new Rectangle((clientRect.Width - width) / 2, (clientRect.Height - height) / 2, width, height);
  174.                 case ContentAlignment.BottomCenter:
  175.                     return new Rectangle((clientRect.Width - width) / 2, (clientRect.Bottom - num2) - height, width, height);
  177.                 case ContentAlignment.BottomRight:
  178.                     if ((rightToLeft & RightToLeft.Yes) == RightToLeft.Yes)
  179.                     {
  180.                         return new Rectangle(clientRect.Left + num, (clientRect.Bottom - num2) - height, width, height);
  181.                     }
  182.                     return new Rectangle((clientRect.Right - num) - width, (clientRect.Bottom - num2) - height, width, height);
  184.                 case ContentAlignment.MiddleRight:
  185.                     if ((rightToLeft & RightToLeft.Yes) == RightToLeft.Yes)
  186.                     {
  187.                         return new Rectangle(clientRect.Left + num, (clientRect.Height - height) / 2, width, height);
  188.                     }
  189.                     return new Rectangle((clientRect.Right - num) - width, (clientRect.Height - height) / 2, width, height);
  191.                 case ContentAlignment.BottomLeft:
  192.                     if ((rightToLeft & RightToLeft.Yes) == RightToLeft.Yes)
  193.                     {
  194.                         return new Rectangle((clientRect.Right - num) - width, (clientRect.Bottom - num2) - height, width, height);
  195.                     }
  196.                     return new Rectangle(clientRect.Left + num, (clientRect.Bottom - num2) - height, width, height);
  197.             }
  198.             return new Rectangle((clientRect.Width - width) / 2, (clientRect.Height - height) / 2, width, height);
  199.         }
  201.         public static Color CalculateColor(Color front, Color back, int alpha)
  202.         {
  203.             Color color = Color.FromArgb(0xff, front);
  204.             Color color2 = Color.FromArgb(0xff, back);
  205.             float r = color.R;
  206.             float g = color.G;
  207.             float b = color.B;
  208.             float num4 = color2.R;
  209.             float num5 = color2.G;
  210.             float num6 = color2.B;
  211.             float num7 = ((r * alpha) / 255f) + (num4 * (((float) (0xff - alpha)) / 255f));
  212.             float num8 = ((g * alpha) / 255f) + (num5 * (((float) (0xff - alpha)) / 255f));
  213.             float num9 = ((b * alpha) / 255f) + (num6 * (((float) (0xff - alpha)) / 255f));
  214.             byte red = (byte) num7;
  215.             byte green = (byte) num8;
  216.             byte blue = (byte) num9;
  217.             return Color.FromArgb(0xff, red, green, blue);
  218.         }
  220.         public static string ConvertBase64StringToUpperCase(string str)
  221.         {
  222.             str = str.ToUpper();
  223.             string str2 = "";
  224.             foreach (char ch in str)
  225.             {
  226.                 char ch2 = ch;
  227.                 if (ch2 == '+')
  228.                 {
  229.                     str2 = str2 + 'J';
  230.                 }
  231.                 else if (ch2 != '/')
  232.                 {
  233.                     if (ch2 != '=')
  234.                     {
  235.                         goto Label_0061;
  236.                     }
  237.                     str2 = str2 + 'Z';
  238.                 }
  239.                 else
  240.                 {
  241.                     str2 = str2 + 'F';
  242.                 }
  243.                 goto Label_006E;
  244.             Label_0061:
  245.                 str2 = str2 + ch;
  246.             Label_006E:;
  247.             }
  248.             return str2;
  249.         }
  251.         public static void DrawArrowDown(Graphics g, int x, int y, bool enabled)
  252.         {
  253.             Pen white;
  254.             Brush gray;
  255.             Point[] points = new Point[3];
  256.             if (!enabled)
  257.             {
  258.                 white = Pens.White;
  259.                 gray = Brushes.White;
  260.                 points[0] = new Point(x + 1, y + 1);
  261.                 points[1] = new Point(x + 7, y + 1);
  262.                 points[2] = new Point(x + 4, y + 4);
  263.                 g.DrawPolygon(white, points);
  264.                 g.FillPolygon(gray, points);
  265.                 white = Pens.Gray;
  266.                 gray = Brushes.Gray;
  267.             }
  268.             else
  269.             {
  270.                 gray = Brushes.Black;
  271.                 white = Pens.Black;
  272.             }
  273.             points[0] = new Point(x, y);
  274.             points[1] = new Point(x + 6, y);
  275.             points[2] = new Point(x + 3, y + 3);
  276.             g.DrawPolygon(white, points);
  277.             g.FillPolygon(gray, points);
  278.         }
  280.         public static void DrawArrowLeft(Graphics g, int x, int y, bool enabled)
  281.         {
  282.             Brush white;
  283.             Point[] points = new Point[3];
  284.             if (!enabled)
  285.             {
  286.                 white = Brushes.White;
  287.                 points[0] = new Point(x + 1, y + 1);
  288.                 points[1] = new Point(x + 4, y + 4);
  289.                 points[2] = new Point(x + 4, y - 2);
  290.                 g.FillPolygon(white, points);
  291.                 white = Brushes.Gray;
  292.             }
  293.             else
  294.             {
  295.                 white = Brushes.Black;
  296.             }
  297.             points[0] = new Point(x, y);
  298.             points[1] = new Point(x + 3, y + 3);
  299.             points[2] = new Point(x + 3, y - 3);
  300.             g.FillPolygon(white, points);
  301.         }
  303.         public static void DrawArrowRight(Graphics g, int x, int y, bool enabled)
  304.         {
  305.             Brush white;
  306.             Point[] points = new Point[3];
  307.             if (!enabled)
  308.             {
  309.                 white = Brushes.White;
  310.                 points[0] = new Point(x + 1, y + 1);
  311.                 points[1] = new Point(x + 1, y + 7);
  312.                 points[2] = new Point(x + 4, y + 4);
  313.                 g.FillPolygon(white, points);
  314.                 white = Brushes.Gray;
  315.             }
  316.             else
  317.             {
  318.                 white = Brushes.Black;
  319.             }
  320.             points[0] = new Point(x, y);
  321.             points[1] = new Point(x, y + 6);
  322.             points[2] = new Point(x + 3, y + 3);
  323.             g.FillPolygon(white, points);
  324.         }
  326.         public static void DrawArrowUp(Graphics g, int x, int y, bool enabled)
  327.         {
  328.             Pen white;
  329.             Brush gray;
  330.             Point[] points = new Point[3];
  331.             if (!enabled)
  332.             {
  333.                 white = Pens.White;
  334.                 gray = Brushes.White;
  335.                 points[0] = new Point(x + 1, y + 1);
  336.                 points[1] = new Point(x + 7, y + 1);
  337.                 points[2] = new Point(x + 4, y - 2);
  338.                 g.DrawPolygon(white, points);
  339.                 g.FillPolygon(gray, points);
  340.                 white = Pens.Gray;
  341.                 gray = Brushes.Gray;
  342.             }
  343.             else
  344.             {
  345.                 gray = Brushes.Black;
  346.                 white = Pens.Black;
  347.             }
  348.             points[0] = new Point(x, y);
  349.             points[1] = new Point(x + 6, y);
  350.             points[2] = new Point(x + 3, y - 3);
  351.             g.DrawPolygon(white, points);
  352.             g.FillPolygon(gray, points);
  353.         }
  355.         public static string FormatStringWithWidth(Graphics g, string s, Font font, int width)
  356.         {
  357.             string text = s;
  358.             Font font2 = font;
  359.             int num = (int) g.MeasureString(s, font2).Width;
  360.             if (width > num)
  361.             {
  362.                 return text;
  363.             }
  364.             for (int i = 1; i < s.Length; i++)
  365.             {
  366.                 text = s.Substring(0, i) + "...";
  367.                 num = (int) g.MeasureString(text, font2).Width;
  368.                 if (num >= width)
  369.                 {
  370.                     return text;
  371.                 }
  372.             }
  373.             return s;
  374.         }
  376.         public static Font GetCaptionFont()
  377.         {
  378.             return new Font(SystemInformation.MenuFont, FontStyle.Bold);
  379.         }
  381.         public static string GetCommonDialogVersion()
  382.         {
  383.             x02a9729195580525 = true;
  384.             string fullName = Assembly.GetAssembly(typeof(CommonDialog)).FullName;
  385.             string str2 = null;
  386.             int index = fullName.IndexOf("Version=");
  387.             if (index != -1)
  388.             {
  389.                 index += 8;
  390.                 int num2 = fullName.IndexOf(",", index);
  391.                 if (num2 == -1)
  392.                 {
  393.                     num2 = fullName.Length - 1;
  394.                 }
  395.                 try
  396.                 {
  397.                     str2 = fullName.Substring(index, num2 - index);
  398.                 }
  399.                 catch
  400.                 {
  401.                 }
  402.             }
  403.             return str2;
  404.         }
  406.         public static StringFormat GetControlCaptionOutputStringFormat(ContentAlignment align, Control control)
  407.         {
  408.             StringFormat format = new StringFormat();
  409.             if ((control.RightToLeft & RightToLeft.Yes) == RightToLeft.Yes)
  410.             {
  411.                 format.FormatFlags = StringFormatFlags.DirectionRightToLeft;
  412.             }
  413.             format.HotkeyPrefix = HotkeyPrefix.Show;
  414.             switch (align)
  415.             {
  416.                 case ContentAlignment.TopLeft:
  417.                     format.Alignment = StringAlignment.Near;
  418.                     format.LineAlignment = StringAlignment.Near;
  419.                     return format;
  421.                 case ContentAlignment.TopCenter:
  422.                     format.Alignment = StringAlignment.Center;
  423.                     format.LineAlignment = StringAlignment.Near;
  424.                     return format;
  426.                 case ContentAlignment.TopRight:
  427.                     format.Alignment = StringAlignment.Far;
  428.                     format.LineAlignment = StringAlignment.Near;
  429.                     return format;
  431.                 case ContentAlignment.MiddleLeft:
  432.                     format.Alignment = StringAlignment.Near;
  433.                     format.LineAlignment = StringAlignment.Center;
  434.                     return format;
  436.                 case ContentAlignment.MiddleCenter:
  437.                     format.Alignment = StringAlignment.Center;
  438.                     format.LineAlignment = StringAlignment.Center;
  439.                     return format;
  441.                 case ContentAlignment.BottomCenter:
  442.                     format.Alignment = StringAlignment.Center;
  443.                     format.LineAlignment = StringAlignment.Far;
  444.                     return format;
  446.                 case ContentAlignment.BottomRight:
  447.                     format.Alignment = StringAlignment.Far;
  448.                     format.LineAlignment = StringAlignment.Far;
  449.                     return format;
  451.                 case ContentAlignment.MiddleRight:
  452.                     format.Alignment = StringAlignment.Far;
  453.                     format.LineAlignment = StringAlignment.Center;
  454.                     return format;
  456.                 case ContentAlignment.BottomLeft:
  457.                     format.Alignment = StringAlignment.Near;
  458.                     format.LineAlignment = StringAlignment.Far;
  459.                     return format;
  460.             }
  461.             format.Alignment = StringAlignment.Center;
  462.             format.LineAlignment = StringAlignment.Center;
  463.             return format;
  464.         }
  466.         public static Font GetMessageFont()
  467.         {
  468.             return SystemInformation.MenuFont;
  469.         }
  471.         public static string GetShortCutString(Shortcut shortcut)
  472.         {
  473.             char ch = (char) ((ushort) (shortcut & ((Shortcut) 0xffff)));
  474.             if ((ch < '0') || (ch > '9'))
  475.             {
  476.                 return TypeDescriptor.GetConverter(typeof(Keys)).ConvertToString((Keys) shortcut);
  477.             }
  478.             string str = "";
  479.             int num = (int) (((long) shortcut) & 0xffff0000L);
  480.             if ((num & 0x10000) != 0)
  481.             {
  482.                 str = str + "Shift+";
  483.             }
  484.             if ((num & 0x20000) != 0)
  485.             {
  486.                 str = str + "Ctrl+";
  487.             }
  488.             if ((num & 0x40000) != 0)
  489.             {
  490.                 str = str + "Alt+";
  491.             }
  492.             return (str + ch);
  493.         }
  495.         public static bool InRect(Point p, xae4dd1cafd2eb77c.RECT r)
  496.         {
  497.             return ((((p.X >= r.left) && (p.X <= r.right)) && (p.Y >= r.top)) && (p.Y <= r.bottom));
  498.         }
  500.         public static bool InRect(Point p, Rectangle r)
  501.         {
  502.             return ((((p.X >= r.Left) && (p.X <= r.Right)) && (p.Y >= r.Top)) && (p.Y <= r.Bottom));
  503.         }
  505.         public static bool InRect(int x, int y, Rectangle r)
  506.         {
  507.             return ((((x >= r.Left) && (x <= r.Right)) && (y >= r.Top)) && (y <= r.Bottom));
  508.         }
  510.         public static Point MakePoint(IntPtr lParam)
  511.         {
  512.             int num = lParam.ToInt32();
  513.             return new Point(num | 0xff, (num | 0xff00) >> 4);
  514.         }
  516.         public static void OffsetRect(ref xae4dd1cafd2eb77c.RECT rect, int dx, int dy)
  517.         {
  518.             rect.left += dx;
  519.             rect.right += dx;
  520.             rect.top += dy;
  521.             rect.bottom += dy;
  522.         }
  524.         public static void OffsetRect(ref Rectangle rect, int dx, int dy)
  525.         {
  526.             rect.X += dx;
  527.             rect.Y += dy;
  528.         }
  530.         public static void PaintSlider(SkinEngine Engine, Graphics g, Rectangle r, bool vScroll)
  531.         {
  532.             Bitmap bitmap;
  533.             Rectangle rectangle;
  534.             Rectangle rectangle2;
  535.             int bottom;
  536.             int top;
  537.             int right;
  538.             int left;
  539.             int num = 0;
  540.             if (vScroll)
  541.             {
  542.                 num = 0;
  543.             }
  544.             else
  545.             {
  546.                 num = 1;
  547.             }
  548.             if (vScroll)
  549.             {
  550.                 if (Engine.Res.ScrollBarRes.IsMacOS && (r.Height > 0x10))
  551.                 {
  552.                     SpitDrawVertical(Engine.Res.Bitmaps.SKIN2_SCROLLBAR, g, r, false);
  553.                 }
  554.                 else
  555.                 {
  556.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 0];
  557.                     if (r.Height <= (bitmap.Height * 2))
  558.                     {
  559.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  560.                         rectangle2 = new Rectangle(r.Left, r.Top, r.Width, r.Height / 2);
  561.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  562.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 4];
  563.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  564.                         rectangle2 = Rectangle.FromLTRB(r.Left, rectangle2.Bottom, r.Right, r.Bottom);
  565.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  566.                     }
  567.                     else if (r.Height <= ((bitmap.Height * 2) + Engine.Res.ScrollBarRes.Slider[num, 2].Height))
  568.                     {
  569.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  570.                         rectangle2 = new Rectangle(r.Left, r.Top, r.Width, bitmap.Height);
  571.                         bottom = rectangle2.Bottom;
  572.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  573.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 4];
  574.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  575.                         rectangle2 = new Rectangle(r.Left, r.Bottom - bitmap.Height, r.Width, bitmap.Height);
  576.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  577.                         top = rectangle2.Top;
  578.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 2];
  579.                         rectangle2 = Rectangle.FromLTRB(r.Left, bottom, r.Right, top);
  580.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  581.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  582.                     }
  583.                     else
  584.                     {
  585.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  586.                         rectangle2 = new Rectangle(r.Left, r.Top, r.Width, bitmap.Height);
  587.                         bottom = rectangle2.Bottom;
  588.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  589.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 2];
  590.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  591.                         rectangle2 = new Rectangle(r.Left, r.Top + ((r.Height - bitmap.Height) / 2), r.Width, bitmap.Height);
  592.                         top = rectangle2.Top;
  593.                         right = rectangle2.Bottom;
  594.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  595.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 4];
  596.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  597.                         rectangle2 = new Rectangle(r.Left, r.Bottom - bitmap.Height, r.Width, bitmap.Height);
  598.                         left = rectangle2.Top;
  599.                         g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  600.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 1];
  601.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  602.                         rectangle2 = Rectangle.FromLTRB(r.Left, bottom, r.Right, top);
  603.                         g.DrawImage(bitmap, rectangle2, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, GraphicsUnit.Pixel, DrawImageAttrTileY);
  604.                         bitmap = Engine.Res.ScrollBarRes.Slider[num, 3];
  605.                         rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  606.                         rectangle2 = Rectangle.FromLTRB(r.Left, right, r.Right, left);
  607.                         g.DrawImage(bitmap, rectangle2, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, GraphicsUnit.Pixel, DrawImageAttrTileY);
  608.                     }
  609.                 }
  610.             }
  611.             else if (Engine.Res.ScrollBarRes.IsMacOS && (r.Width > 0x10))
  612.             {
  613.                 SpitDrawHorizontal(Engine.Res.Bitmaps.SKIN2_SCROLLBAR, g, r, false);
  614.             }
  615.             else
  616.             {
  617.                 bitmap = Engine.Res.ScrollBarRes.Slider[num, 0];
  618.                 if (r.Width <= (bitmap.Width * 2))
  619.                 {
  620.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  621.                     rectangle2 = new Rectangle(r.Left, r.Top, r.Width / 2, r.Height);
  622.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  623.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 4];
  624.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  625.                     rectangle2 = Rectangle.FromLTRB(rectangle2.Right, r.Top, r.Right, r.Bottom);
  626.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  627.                 }
  628.                 else if (r.Width <= ((bitmap.Width * 2) + Engine.Res.ScrollBarRes.Slider[num, 2].Width))
  629.                 {
  630.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  631.                     rectangle2 = new Rectangle(r.Left, r.Top, bitmap.Width, r.Height);
  632.                     bottom = rectangle2.Right;
  633.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  634.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 4];
  635.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  636.                     rectangle2 = new Rectangle(r.Right - bitmap.Width, r.Top, bitmap.Width, r.Height);
  637.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  638.                     top = rectangle2.Left;
  639.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  640.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 2];
  641.                     rectangle2 = Rectangle.FromLTRB(bottom, r.Top, top, r.Bottom);
  642.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  643.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  644.                 }
  645.                 else
  646.                 {
  647.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  648.                     rectangle2 = new Rectangle(r.Left, r.Top, bitmap.Width, r.Height);
  649.                     bottom = rectangle2.Right;
  650.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  651.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 2];
  652.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  653.                     rectangle2 = new Rectangle(r.Left + ((r.Width - bitmap.Width) / 2), r.Top, bitmap.Width, r.Height);
  654.                     top = rectangle2.Left;
  655.                     right = rectangle2.Right;
  656.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  657.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 4];
  658.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  659.                     rectangle2 = new Rectangle(r.Right - bitmap.Width, r.Top, bitmap.Width, r.Height);
  660.                     left = rectangle2.Left;
  661.                     g.DrawImage(bitmap, rectangle2, rectangle, GraphicsUnit.Pixel);
  662.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 1];
  663.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  664.                     rectangle2 = Rectangle.FromLTRB(bottom, r.Top, top, r.Bottom);
  665.                     g.DrawImage(bitmap, rectangle2, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, GraphicsUnit.Pixel, DrawImageAttrTileX);
  666.                     bitmap = Engine.Res.ScrollBarRes.Slider[num, 3];
  667.                     rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
  668.                     rectangle2 = Rectangle.FromLTRB(right, r.Top, left, r.Bottom);
  669.                     g.DrawImage(bitmap, rectangle2, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, GraphicsUnit.Pixel, DrawImageAttrTileX);
  670.                 }
  671.             }
  672.         }
  674.         public static void RemoveAllControl(Control control)
  675.         {
  676.             if ((control != null) && (control.Controls.Count > 0))
  677.             {
  678.                 Button button = null;
  679.                 Form form = control.FindForm();
  680.                 if (form != null)
  681.                 {
  682.                     button = new Button();
  683.                     button.Visible = false;
  684.                     form.Controls.Add(button);
  685.                     form.ActiveControl = button;
  686.                 }
  687.                 control.Controls.Clear();
  688.                 if (form != null)
  689.                 {
  690.                     button.Dispose();
  691.                     form.Controls.Remove(button);
  692.                 }
  693.             }
  694.         }
  696.         public static void RemoveControl(Control.ControlCollection coll, Control item)
  697.         {
  698.             if ((coll != null) && (item != null))
  699.             {
  700.                 Button button = null;
  701.                 Form form = item.FindForm();
  702.                 if (form != null)
  703.                 {
  704.                     button = new Button();
  705.                     button.Visible = false;
  706.                     form.Controls.Add(button);
  707.                     form.ActiveControl = button;
  708.                 }
  709.                 coll.Remove(item);
  710.                 if (form != null)
  711.                 {
  712.                     button.Dispose();
  713.                     form.Controls.Remove(button);
  714.                 }
  715.             }
  716.         }
  718.         public static Bitmap RoundPicture(Bitmap src)
  719.         {
  720.             Bitmap bitmap = new Bitmap(src.Height, src.Width);
  721.             for (int i = 0; i < src.Height; i++)
  722.             {
  723.                 for (int j = 0; j < src.Width; j++)
  724.                 {
  725.                     bitmap.SetPixel(i, (src.Width - j) - 1, src.GetPixel(j, i));
  726.                 }
  727.             }
  728.             return bitmap;
  729.         }
  731.         public static int ShowSystemMessageBox(IntPtr hWnd, string l, string c, uint u)
  732.         {
  733.             return x61467fe65a98f20c.MessageBox(hWnd, l, c, u);
  734.         }
  736.         public static void SkinShowMessageBox()
  737.         {
  738.             MessageBox.Show(string.Intern(x1110bdd110cdcea4._d574bb1a8f3e9cbc("npldnfmfonhejhodoekebhcfdedfkgkfhgkhcchidmchilojkhpcakgdejndljeeihlenicfiijfkiagfcggijhmpkmnilmnjkinmcfpkimoabhjipkcgocbhiopkpdocallmpbm", 0x555ddb55)) + string.Intern(x1110bdd110cdcea4._d574bb1a8f3e9cbc("eppknpglkpnldpemkllmmkcnjkjnooaolohoiooomjfponmpnndadnkalmbbcniblmpbplgckmncbieddlldllcejhjealafglhfkkofblfgokmgdkdhojkhakbiofii", 0x595baf8c)), " ");
  739.         }
  741.         public static void SpitDrawHorizontal(Bitmap bmp, Graphics g, Rectangle r, bool transParent)
  742.         {
  743.             Rectangle rectangle;
  744.             Rectangle rectangle2;
  745.             int width = bmp.Width / 3;
  746.             if (width > r.Width)
  747.             {
  748.                 rectangle = new Rectangle(0, 0, bmp.Width, bmp.Height);
  749.                 rectangle2 = r;
  750.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  751.                 rectangle = new Rectangle(bmp.Width - 2, 0, 2, bmp.Height);
  752.                 rectangle2 = new Rectangle(r.Right - 2, 0, 2, bmp.Height);
  753.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  754.             }
  755.             else
  756.             {
  757.                 rectangle2 = new Rectangle(r.X, r.Y, width, r.Height);
  758.                 rectangle = new Rectangle(0, 0, width, bmp.Height);
  759.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  760.                 rectangle2 = Rectangle.FromLTRB(r.X + width, r.Y, r.Right - width, r.Bottom);
  761.                 rectangle = new Rectangle(width, 0, width, bmp.Height);
  762.                 g.DrawImage(bmp, rectangle2, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, GraphicsUnit.Pixel, DrawImageAttrTileX, null);
  763.                 rectangle2 = new Rectangle(r.Right - width, r.Y, width, r.Height);
  764.                 rectangle = new Rectangle(bmp.Width - width, 0, width, bmp.Height);
  765.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  766.             }
  767.         }
  769.         public static void SpitDrawVertical(Bitmap bmp, Graphics g, Rectangle r, bool transParent)
  770.         {
  771.             Rectangle rectangle;
  772.             Rectangle rectangle2;
  773.             int height = bmp.Height / 3;
  774.             if (height > r.Height)
  775.             {
  776.                 rectangle = new Rectangle(0, 0, bmp.Width, bmp.Height);
  777.                 rectangle2 = r;
  778.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  779.                 rectangle = new Rectangle(0, bmp.Height - 2, bmp.Width, 2);
  780.                 rectangle2 = new Rectangle(r.Left, r.Bottom - 2, r.Width, 2);
  781.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  782.             }
  783.             else
  784.             {
  785.                 rectangle2 = new Rectangle(r.X, r.Y, r.Width, height);
  786.                 rectangle = new Rectangle(0, 0, bmp.Width, height);
  787.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  788.                 rectangle2 = Rectangle.FromLTRB(r.X, r.Y + height, r.Right, r.Bottom - height);
  789.                 rectangle = new Rectangle(0, height, bmp.Width, height);
  790.                 g.DrawImage(bmp, rectangle2, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, GraphicsUnit.Pixel, DrawImageAttrTileX, null);
  791.                 rectangle2 = new Rectangle(r.X, r.Bottom - height, r.Width, height);
  792.                 rectangle = new Rectangle(0, bmp.Height - height, bmp.Width, height);
  793.                 g.DrawImage(bmp, rectangle2, rectangle, GraphicsUnit.Pixel);
  794.             }
  795.         }
  797.         public static Bitmap SplitBitmap(Bitmap source, int count, int index)
  798.         {
  799.             if ((source == null) || (count == 0))
  800.             {
  801.                 return null;
  802.             }
  803.             float width = ((float) source.Width) / ((float) count);
  804.             float height = source.Height;
  805.             RectangleF rect = new RectangleF(new PointF(width * (index - 1), 0f), new SizeF(width, height));
  806.             return source.Clone(rect, source.PixelFormat);
  807.         }
  809.         public static void SplitDraw(Bitmap src, Graphics gDest, Rectangle rect)
  810.         {
  811.             Color fuchsia = Color.Fuchsia;
  812.             if (rect.Bottom >= rect.Top)
  813.             {
  814.                 Rectangle rectangle7;
  815.                 int width = rect.Width;
  816.                 int height = rect.Height;
  817.                 Rectangle rectangle4 = new Rectangle(0, 0, 0, 0);
  818.                 Rectangle rectangle3 = rectangle4;
  819.                 Rectangle rectangle5 = rectangle4;
  820.                 Rectangle rectangle6 = rectangle4;
  821.                 Rectangle srcRect = Rectangle.FromLTRB(0, 0, src.Width / 2, src.Height / 2);
  822.                 Rectangle destRect = Rectangle.FromLTRB(0, 0, width / 2, height / 2);
  823.                 int num3 = Math.Min(srcRect.Width, destRect.Width);
  824.                 if (num3 < 0)
  825.                 {
  826.                     num3 = 0;
  827.                 }
  828.                 int num4 = Math.Min(srcRect.Height, destRect.Height);
  829.                 if (num4 < 0)
  830.                 {
  831.                     num4 = 0;
  832.                 }
  833.                 if ((num3 != 0) && (num4 != 0))
  834.                 {
  835.                     if (num3 < srcRect.Width)
  836.                     {
  837.                         srcRect.Width = num3;
  838.                     }
  839.                     if (num4 < srcRect.Height)
  840.                     {
  841.                         srcRect.Height = num4;
  842.                     }
  843.                     rectangle7 = new Rectangle(0, 0, num3, num4);
  844.                     gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  845.                     rectangle3 = new Rectangle(0, 0, num3, num4);
  846.                 }
  847.                 srcRect = Rectangle.FromLTRB(0, (src.Height - (src.Height / 2)) + 1, src.Width / 2, src.Height);
  848.                 destRect = Rectangle.FromLTRB(0, (height - (height / 2)) + 1, width / 2, height);
  849.                 if (destRect.Bottom > destRect.Top)
  850.                 {
  851.                     num3 = Math.Min(srcRect.Width, destRect.Width);
  852.                     if (num3 < 0)
  853.                     {
  854.                         num3 = 0;
  855.                     }
  856.                     num4 = Math.Min(srcRect.Height, destRect.Height);
  857.                     if (num4 < 0)
  858.                     {
  859.                         num4 = 0;
  860.                     }
  861.                     if ((num3 != 0) && (num4 != 0))
  862.                     {
  863.                         if (num4 < srcRect.Height)
  864.                         {
  865.                             srcRect.Y += srcRect.Height - num4;
  866.                             srcRect.Height = num4;
  867.                         }
  868.                         if (num3 < srcRect.Width)
  869.                         {
  870.                             srcRect.Width = num3;
  871.                         }
  872.                         rectangle7 = new Rectangle(0, rect.Bottom - num4, num3, num4);
  873.                         gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  874.                         rectangle4 = new Rectangle(0, rect.Bottom - num4, num3, num4);
  875.                     }
  876.                     srcRect = Rectangle.FromLTRB(0, src.Height / 2, src.Width / 2, src.Height - (src.Height / 2));
  877.                     destRect = Rectangle.FromLTRB(0, rectangle3.Bottom, rectangle3.Right, rectangle4.Top);
  878.                     if (destRect.Bottom > destRect.Top)
  879.                     {
  880.                         num3 = destRect.Width;
  881.                         num4 = destRect.Height;
  882.                         if ((num3 != 0) && (num4 != 0))
  883.                         {
  884.                             if (num3 < srcRect.Width)
  885.                             {
  886.                                 srcRect.Width = num3;
  887.                             }
  888.                             rectangle7 = new Rectangle(0, 0, num3, num4);
  889.                             gDest.DrawImage(src, destRect, srcRect, GraphicsUnit.Pixel);
  890.                         }
  891.                     }
  892.                     srcRect = Rectangle.FromLTRB((src.Width - (src.Width / 2)) + 1, 0, src.Width, src.Height / 2);
  893.                     destRect = Rectangle.FromLTRB((width - (width / 2)) + 1, 0, width, height / 2);
  894.                     if (destRect.Bottom > destRect.Top)
  895.                     {
  896.                         num3 = Math.Min(srcRect.Width, destRect.Width);
  897.                         if (num3 < 0)
  898.                         {
  899.                             num3 = 0;
  900.                         }
  901.                         num4 = Math.Min(srcRect.Height, destRect.Height);
  902.                         if (num4 < 0)
  903.                         {
  904.                             num4 = 0;
  905.                         }
  906.                         if ((num4 != 0) && (num3 != 0))
  907.                         {
  908.                             if (num3 < srcRect.Width)
  909.                             {
  910.                                 srcRect.X += srcRect.Width - num3;
  911.                                 srcRect.Width = num3;
  912.                             }
  913.                             if (num4 < srcRect.Height)
  914.                             {
  915.                                 srcRect.Height = num4;
  916.                             }
  917.                             rectangle7 = new Rectangle(rect.Right - num3, 0, num3, num4);
  918.                             gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  919.                             rectangle5 = new Rectangle(rect.Right - num3, 0, num3, num4);
  920.                         }
  921.                         srcRect = Rectangle.FromLTRB((src.Width - (src.Width / 2)) + 1, (src.Height - (src.Height / 2)) + 1, src.Width, src.Height);
  922.                         destRect = Rectangle.FromLTRB((width - (width / 2)) + 1, (height - (height / 2)) + 1, width, height);
  923.                         if (destRect.Bottom > destRect.Top)
  924.                         {
  925.                             num3 = Math.Min(srcRect.Width, destRect.Width);
  926.                             if (num3 < 0)
  927.                             {
  928.                                 num3 = 0;
  929.                             }
  930.                             num4 = Math.Min(srcRect.Height, destRect.Height);
  931.                             if (num4 < 0)
  932.                             {
  933.                                 num4 = 0;
  934.                             }
  935.                             if ((num3 != 0) && (num4 != 0))
  936.                             {
  937.                                 if (num3 < srcRect.Width)
  938.                                 {
  939.                                     srcRect.X += srcRect.Width - num3;
  940.                                     srcRect.Width = num3;
  941.                                 }
  942.                                 if (num4 < srcRect.Height)
  943.                                 {
  944.                                     srcRect.Y += srcRect.Height - num4;
  945.                                     srcRect.Height = num4;
  946.                                 }
  947.                                 rectangle7 = new Rectangle(rect.Right - num3, rect.Bottom - num4, num3, num4);
  948.                                 gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  949.                                 rectangle6 = new Rectangle(rect.Right - num3, rect.Bottom - num4, num3, num4);
  950.                             }
  951.                             srcRect = Rectangle.FromLTRB((src.Width - (src.Width / 2)) + 1, src.Height - (src.Height / 2), src.Width, (src.Height / 2) + 2);
  952.                             destRect = Rectangle.FromLTRB(rectangle5.Left, rectangle5.Bottom, rectangle5.Right, rectangle6.Top);
  953.                             if (destRect.Bottom > destRect.Top)
  954.                             {
  955.                                 num3 = destRect.Width;
  956.                                 num4 = destRect.Height;
  957.                                 if ((num3 != 0) && (num4 != 0))
  958.                                 {
  959.                                     if (num3 < srcRect.Width)
  960.                                     {
  961.                                         srcRect.X += srcRect.Width - num3;
  962.                                         srcRect.Width = num3;
  963.                                     }
  964.                                     rectangle7 = new Rectangle(destRect.X, destRect.Y, num3, num4);
  965.                                     gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  966.                                 }
  967.                             }
  968.                             srcRect = Rectangle.FromLTRB(src.Width / 2, 0, (src.Width - (src.Width / 2)) + 1, src.Height / 2);
  969.                             destRect = Rectangle.FromLTRB(rectangle3.Right, 0, rectangle5.Left, rectangle3.Bottom);
  970.                             if (destRect.Bottom > destRect.Top)
  971.                             {
  972.                                 num3 = destRect.Width;
  973.                                 num4 = destRect.Height;
  974.                                 if ((num3 != 0) && (num4 != 0))
  975.                                 {
  976.                                     if (num4 < srcRect.Height)
  977.                                     {
  978.                                         srcRect.Height = num4;
  979.                                     }
  980.                                     rectangle7 = new Rectangle(destRect.X, destRect.Y, num3, num4);
  981.                                     gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  982.                                 }
  983.                             }
  984.                             srcRect = Rectangle.FromLTRB(src.Width / 2, src.Height / 2, (src.Width - (src.Width / 2)) + 1, src.Height - (src.Height / 2));
  985.                             destRect = Rectangle.FromLTRB(rectangle3.Right, rectangle3.Bottom, rectangle5.Left, rectangle6.Top - 1);
  986.                             if (destRect.Bottom > destRect.Top)
  987.                             {
  988.                                 num3 = destRect.Width;
  989.                                 num4 = destRect.Height;
  990.                                 if ((num3 != 0) && (num3 != 0))
  991.                                 {
  992.                                     rectangle7 = new Rectangle(destRect.X, destRect.Y, num3, num4);
  993.                                     gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  994.                                 }
  995.                             }
  996.                             srcRect = Rectangle.FromLTRB(src.Width / 2, src.Height - (src.Height / 2), (src.Width - (src.Width / 2)) + 1, src.Height);
  997.                             destRect = Rectangle.FromLTRB(rectangle3.Right - 1, rectangle4.Top - 1, rectangle6.Left, rectangle6.Bottom);
  998.                             if (destRect.Bottom > destRect.Top)
  999.                             {
  1000.                                 num3 = destRect.Width;
  1001.                                 num4 = destRect.Height;
  1002.                                 if ((num3 != 0) && (num4 != 0))
  1003.                                 {
  1004.                                     if (num4 < srcRect.Height)
  1005.                                     {
  1006.                                         srcRect.Y += srcRect.Height - num4;
  1007.                                         srcRect.Height = num4;
  1008.                                     }
  1009.                                     rectangle7 = new Rectangle(destRect.X, destRect.Y, num3, num4);
  1010.                                     gDest.DrawImage(src, rectangle7, srcRect, GraphicsUnit.Pixel);
  1011.                                 }
  1012.                             }
  1013.                         }
  1014.                     }
  1015.                 }
  1016.             }
  1017.         }
  1019.         public static void StretchDrawWithHeader(Graphics g, Bitmap bmp, Rectangle dest, Rectangle src, int header)
  1020.         {
  1021.             Rectangle srcRect = new Rectangle(src.X, src.Y, src.Width, header);
  1022.             Rectangle destRect = new Rectangle(dest.X, dest.Y, dest.Width, header);
  1023.             g.DrawImage(bmp, destRect, srcRect, GraphicsUnit.Pixel);
  1024.             srcRect = new Rectangle(src.X, src.Y + header, src.Width, src.Height - header);
  1025.             destRect = new Rectangle(dest.X, dest.Y + header, dest.Width, dest.Height - header);
  1026.             g.DrawImage(bmp, destRect, srcRect, GraphicsUnit.Pixel);
  1027.         }
  1029.         public static Color TabBackgroundFromBaseColor(Color backColor)
  1030.         {
  1031.             if (((backColor.R == 0xd4) && (backColor.G == 0xd0)) && (backColor.B == 200))
  1032.             {
  1033.                 return Color.FromArgb(0xf7, 0xf3, 0xe9);
  1034.             }
  1035.             if (((backColor.R == 0xec) && (backColor.G == 0xe9)) && (backColor.B == 0xd8))
  1036.             {
  1037.                 return Color.FromArgb(0xff, 0xfb, 0xe9);
  1038.             }
  1039.             int red = 0xff - ((0xff - backColor.R) / 2);
  1040.             int green = 0xff - ((0xff - backColor.G) / 2);
  1041.             int blue = 0xff - ((0xff - backColor.B) / 2);
  1042.             return Color.FromArgb(red, green, blue);
  1043.         }
  1045.         public static Color DefaultTransparentColor
  1046.         {
  1047.             get
  1048.             {
  1049.                 return x27d07b3cbf2c9479;
  1050.             }
  1051.         }
  1053.         public static ImageAttributes DrawImageAttrTileX
  1054.         {
  1055.             get
  1056.             {
  1057.                 return xc7766c1739984987;
  1058.             }
  1059.         }
  1061.         public static ImageAttributes DrawImageAttrTileXY
  1062.         {
  1063.             get
  1064.             {
  1065.                 return xa11b666f50e9398f;
  1066.             }
  1067.         }
  1069.         public static ImageAttributes DrawImageAttrTileY
  1070.         {
  1071.             get
  1072.             {
  1073.                 return x68a7ff53010868dc;
  1074.             }
  1075.         }
  1077.         public static Pen FocusRectanglePen
  1078.         {
  1079.             get
  1080.             {
  1081.                 return x4f0034703b20af0f;
  1082.             }
  1083.         }
  1085.         public static bool IsNeedHookCommonDialog
  1086.         {
  1087.             get
  1088.             {
  1089.                 if (!x02a9729195580525)
  1090.                 {
  1091.                     switch (GetCommonDialogVersion())
  1092.                     {
  1093.                         case "1.0.3300.0":
  1094.                         case "1.0.5000.0":
  1095.                             x605ccaa3586218f6 = false;
  1096.                             goto Label_0035;
  1097.                     }
  1098.                     x605ccaa3586218f6 = true;
  1099.                 }
  1100.             Label_0035:
  1101.                 return x605ccaa3586218f6;
  1102.             }
  1103.         }
  1105.         public static bool IsVista
  1106.         {
  1107.             get
  1108.             {
  1109.                 return (((Environment.OSVersion.Platform == PlatformID.Win32NT) && (Environment.OSVersion.Version.Major == 6)) && (Environment.OSVersion.Version.Minor == 0));
  1110.             }
  1111.         }
  1113.         public static StringFormat MainMenuStringFormat
  1114.         {
  1115.             get
  1116.             {
  1117.                 return x488379a1c8afe803;
  1118.             }
  1119.         }
  1121.         public static StringFormat MenuItemShortcutFormat
  1122.         {
  1123.             get
  1124.             {
  1125.                 return xad5d7fbaf75245c8;
  1126.             }
  1127.         }
  1129.         public static StringFormat MenuItemStringFormat
  1130.         {
  1131.             get
  1132.             {
  1133.                 return xd02bd90925d5d5ca;
  1134.             }
  1135.         }
  1137.         public static StringFormat MenuItemStringFormatR
  1138.         {
  1139.             get
  1140.             {
  1141.                 return xe8c22659bee459d5;
  1142.             }
  1143.         }
  1145.         public static Font TitleFont
  1146.         {
  1147.             get
  1148.             {
  1149.                 return GetCaptionFont();
  1150.             }
  1151.         }
  1152.     }
  1153. }