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

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

.net编程

开发平台：

C#

x97d171718e5c7e7f.cs：源码内容
  1. namespace Sunisoft.IrisSkin
  2. {
  3.     using System;
  4.     using System.Drawing;
  5.     using System.Drawing.Text;
  6.     using System.Windows.Forms;
  8.     internal class x97d171718e5c7e7f : x8917d01b98173f4c
  9.     {
  10.         public x97d171718e5c7e7f(Control control, SkinEngine engine) : base(control, engine)
  11.         {
  12.             if (this.x0e7ffd184973f9bc)
  13.             {
  14.                 uint windowLong = x61467fe65a98f20c.GetWindowLong(base.Handle, -20);
  15.                 if ((windowLong & 0x400000) == 0x400000)
  16.                 {
  17.                     windowLong -= 0x400000;
  18.                 }
  19.                 x61467fe65a98f20c.SetWindowLong(base.Handle, -20, windowLong);
  20.             }
  21.         }
  23.         protected override bool BeforeWndProc(ref Message m)
  24.         {
  25.             switch (((uint) m.Msg))
  26.             {
  27.                 case 15:
  28.                 {
  29.                     x40255b11ef821fa3.PAINTSTRUCT lpPaint = new x40255b11ef821fa3.PAINTSTRUCT();
  30.                     x61467fe65a98f20c.BeginPaint(base.Ctrl.Handle, out lpPaint);
  31.                     this.PaintControl();
  32.                     x61467fe65a98f20c.EndPaint(base.Ctrl.Handle, ref lpPaint);
  33.                     return false;
  34.                 }
  35.                 case 0x84:
  36.                     if (this.x0e7ffd184973f9bc)
  37.                     {
  38.                         int num = m.LParam.ToInt32();
  39.                         Point p = new Point(num & 0xffff, num >> 0x10);
  40.                         p = base.Ctrl.PointToClient(p);
  41.                         p.X = base.Ctrl.Width - p.X;
  42.                         p = base.Ctrl.PointToScreen(p);
  43.                         num = p.X + (p.Y << 0x10);
  44.                         m.LParam = new IntPtr(num);
  45.                     }
  46.                     break;
  48.                 case 0x201:
  49.                     if (this.x0e7ffd184973f9bc)
  50.                     {
  51.                         int num2 = m.LParam.ToInt32();
  52.                         num2 = ((base.Ctrl.Width - num2) & 0xffff) + (num2 & 0xfff0000);
  53.                         m.LParam = new IntPtr(num2);
  54.                     }
  55.                     break;
  56.             }
  57.             return base.BeforeWndProc(ref m);
  58.         }
  60.         protected override void OnCurrentSkinChanged(object sender, SkinChangedEventArgs e)
  61.         {
  62.             base.OnCurrentSkinChanged(sender, e);
  63.             if (!base.CanPaint)
  64.             {
  65.                 if (this.x0e7ffd184973f9bc)
  66.                 {
  67.                     uint dwNewLong = x61467fe65a98f20c.GetWindowLong(base.Handle, -20) & 0x400000;
  68.                     x61467fe65a98f20c.SetWindowLong(base.Handle, -20, dwNewLong);
  69.                 }
  70.             }
  71.             else if (this.x0e7ffd184973f9bc)
  72.             {
  73.                 uint windowLong = x61467fe65a98f20c.GetWindowLong(base.Handle, -20);
  74.                 if ((windowLong & 0x400000) == 0x400000)
  75.                 {
  76.                     windowLong -= 0x400000;
  77.                 }
  78.                 x61467fe65a98f20c.SetWindowLong(base.Handle, -20, windowLong);
  79.             }
  80.         }
  82.         protected override void PaintControl()
  83.         {
  84.             if (((base.Ctrl.ClientRectangle.Width > 0) && (base.Ctrl.ClientRectangle.Height > 0)) && base.CanPaint)
  85.             {
  86.                 using (Bitmap bitmap = new Bitmap(base.Ctrl.Width, base.Ctrl.Height))
  87.                 {
  88.                     using (Graphics graphics = Graphics.FromImage(bitmap))
  89.                     {
  90.                         this.x8bc95f030953f87b(graphics);
  91.                     }
  92.                     if (this.x0e7ffd184973f9bc)
  93.                     {
  94.                         bitmap.RotateFlip(RotateFlipType.RotateNoneFlipX);
  95.                     }
  96.                     using (Graphics graphics2 = Graphics.FromImage(bitmap))
  97.                     {
  98.                         this.x3bf72114458d67b7(graphics2);
  99.                     }
  100.                     using (Graphics graphics3 = Graphics.FromHwnd(base.Handle))
  101.                     {
  102.                         graphics3.DrawImageUnscaled(bitmap, 0, 0);
  103.                     }
  104.                 }
  105.             }
  106.         }
  108.         private void x3bf72114458d67b7(Graphics x41347a961b838962)
  109.         {
  110.             TabControl ctrl = (TabControl) base.Ctrl;
  111.             StringFormat format = new StringFormat();
  112.             format.FormatFlags = StringFormatFlags.NoWrap;
  113.             format.HotkeyPrefix = HotkeyPrefix.None;
  114.             format.LineAlignment = StringAlignment.Center;
  115.             format.Alignment = StringAlignment.Center;
  116.             int height = base.Engine.Res.TabControlRes.TabLine.Height;
  117.             int width = ctrl.Width;
  118.             for (int i = 0; i < ctrl.TabPages.Count; i++)
  119.             {
  120.                 Brush brush;
  121.                 Image image = null;
  122.                 if ((((ctrl.ImageList != null) && (ctrl.TabPages != null)) && ((ctrl.TabPages.Count > i) && (ctrl.TabPages[i] != null))) && ((ctrl.TabPages[i].ImageIndex >= 0) && (ctrl.ImageList.Images.Count > ctrl.TabPages[i].ImageIndex)))
  123.                 {
  124.                     image = ctrl.ImageList.Images[ctrl.TabPages[i].ImageIndex];
  125.                 }
  126.                 Rectangle tabRect = ctrl.GetTabRect(i);
  127.                 int num4 = 1;
  128.                 switch (ctrl.Alignment)
  129.                 {
  130.                     case TabAlignment.Bottom:
  131.                         tabRect.Y += height;
  132.                         tabRect.Height -= height;
  133.                         if (image == null)
  134.                         {
  135.                             goto Label_03B2;
  136.                         }
  137.                         if (!this.x0e7ffd184973f9bc)
  138.                         {
  139.                             break;
  140.                         }
  141.                         x41347a961b838962.DrawImageUnscaled(image, (width - image.Width) - tabRect.X, tabRect.Y);
  142.                         goto Label_0226;
  144.                     case TabAlignment.Left:
  145.                         tabRect.X += num4;
  146.                         format.FormatFlags = StringFormatFlags.DirectionVertical;
  147.                         tabRect.Width -= height;
  148.                         if (image == null)
  149.                         {
  150.                             goto Label_03B2;
  151.                         }
  152.                         if (!this.x0e7ffd184973f9bc)
  153.                         {
  154.                             goto Label_02B8;
  155.                         }
  156.                         x41347a961b838962.DrawImageUnscaled(image, (width - image.Width) - tabRect.X, (tabRect.Bottom - image.Height) - 3);
  157.                         goto Label_02D8;
  159.                     case TabAlignment.Right:
  160.                         tabRect.X -= num4;
  161.                         tabRect.X += height;
  162.                         tabRect.Width -= height;
  163.                         format.FormatFlags = StringFormatFlags.DirectionVertical;
  164.                         tabRect.Width -= height;
  165.                         if (image == null)
  166.                         {
  167.                             goto Label_03B2;
  168.                         }
  169.                         if (!this.x0e7ffd184973f9bc)
  170.                         {
  171.                             goto Label_036C;
  172.                         }
  173.                         x41347a961b838962.DrawImageUnscaled(image, (width - image.Width) - tabRect.X, tabRect.Y + 3);
  174.                         goto Label_0384;
  176.                     default:
  177.                         tabRect.Y += num4;
  178.                         tabRect.Height -= height;
  179.                         if (image != null)
  180.                         {
  181.                             if (this.x0e7ffd184973f9bc)
  182.                             {
  183.                                 x41347a961b838962.DrawImageUnscaled(image, (width - image.Width) - (tabRect.X + 2), tabRect.Y);
  184.                             }
  185.                             else
  186.                             {
  187.                                 x41347a961b838962.DrawImageUnscaled(image, tabRect.X + 2, tabRect.Y);
  188.                             }
  189.                             tabRect.X += image.Width + 3;
  190.                             tabRect.Width -= image.Width + 3;
  191.                         }
  192.                         goto Label_03B2;
  193.                 }
  194.                 x41347a961b838962.DrawImageUnscaled(image, tabRect.X, tabRect.Y);
  195.             Label_0226:
  196.                 tabRect.X += image.Width;
  197.                 tabRect.Width -= image.Width;
  198.                 goto Label_03B2;
  199.             Label_02B8:
  200.                 x41347a961b838962.DrawImageUnscaled(image, tabRect.X, (tabRect.Bottom - image.Height) - 3);
  201.             Label_02D8:
  202.                 tabRect.Height -= image.Height + 3;
  203.                 goto Label_03B2;
  204.             Label_036C:
  205.                 x41347a961b838962.DrawImageUnscaled(image, tabRect.X, tabRect.Y + 3);
  206.             Label_0384:
  207.                 tabRect.Y += image.Height + 3;
  208.                 tabRect.Height -= image.Height + 3;
  209.             Label_03B2:
  210.                 if (ctrl.SelectedIndex == i)
  211.                 {
  212.                     brush = base.Engine.Res.Brushes.SKIN2_TABCONTROLACTIVEFONTCOLOR;
  213.                 }
  214.                 else
  215.                 {
  216.                     brush = base.Engine.Res.Brushes.SKIN2_TABCONTROLINACTIVEFONTCOLOR;
  217.                 }
  218.                 if (this.x0e7ffd184973f9bc)
  219.                 {
  220.                     tabRect.X = (width - tabRect.X) - tabRect.Width;
  221.                 }
  222.                 x41347a961b838962.DrawString(ctrl.TabPages[i].Text, ctrl.Font, brush, tabRect, format);
  223.                 format.FormatFlags = StringFormatFlags.NoWrap;
  224.             }
  225.         }
  227.         private void x8bc95f030953f87b(Graphics x4b101060f4767186)
  228.         {
  229.             TabControl ctrl = (TabControl) base.Ctrl;
  230.             Brush brush = base.Engine.Res.Brushes.SKIN2_FORMCOLOR;
  231.             x4b101060f4767186.FillRectangle(brush, ctrl.ClientRectangle);
  232.             this.xa7a441e9d4de36b0(x4b101060f4767186);
  233.             for (int i = 0; i < ctrl.TabPages.Count; i++)
  234.             {
  235.                 this.xc33f5f7a18a754cb(x4b101060f4767186, i);
  236.             }
  237.         }
  239.         private void xa7a441e9d4de36b0(Graphics x4b101060f4767186)
  240.         {
  241.             Rectangle rectangle;
  242.             Bitmap bitmap2;
  243.             TabControl ctrl = (TabControl) base.Ctrl;
  244.             Bitmap tabLine = base.Engine.Res.TabControlRes.TabLine;
  245.             switch (ctrl.Alignment)
  246.             {
  247.                 case TabAlignment.Bottom:
  248.                     rectangle = new Rectangle(0, ctrl.DisplayRectangle.Bottom + 2, ctrl.Width, tabLine.Height);
  249.                     bitmap2 = new Bitmap(ctrl.Width, tabLine.Height);
  250.                     break;
  252.                 case TabAlignment.Left:
  253.                     rectangle = new Rectangle((ctrl.DisplayRectangle.X - 2) - tabLine.Height, 0, tabLine.Height, ctrl.Height);
  254.                     bitmap2 = new Bitmap(ctrl.Height, tabLine.Height);
  255.                     break;
  257.                 case TabAlignment.Right:
  258.                     rectangle = new Rectangle(ctrl.DisplayRectangle.Right + 2, 0, tabLine.Height, ctrl.Height);
  259.                     bitmap2 = new Bitmap(ctrl.Height, tabLine.Height);
  260.                     break;
  262.                 default:
  263.                     rectangle = new Rectangle(0, (ctrl.DisplayRectangle.Y - 2) - tabLine.Height, ctrl.Width, tabLine.Height);
  264.                     bitmap2 = new Bitmap(ctrl.Width, tabLine.Height);
  265.                     break;
  266.             }
  267.             using (Graphics graphics = Graphics.FromImage(bitmap2))
  268.             {
  269.                 graphics.DrawImage(tabLine, new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), 0, 0, tabLine.Width, tabLine.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileX);
  270.             }
  271.             switch (ctrl.Alignment)
  272.             {
  273.                 case TabAlignment.Bottom:
  274.                     bitmap2.RotateFlip(RotateFlipType.Rotate180FlipNone);
  275.                     break;
  277.                 case TabAlignment.Left:
  278.                     bitmap2.RotateFlip(RotateFlipType.Rotate270FlipNone);
  279.                     break;
  281.                 case TabAlignment.Right:
  282.                     bitmap2.RotateFlip(RotateFlipType.Rotate90FlipNone);
  283.                     break;
  284.             }
  285.             x4b101060f4767186.DrawImageUnscaled(bitmap2, rectangle);
  286.             bitmap2.Dispose();
  287.             Pen borderPen = base.Engine.Res.TabControlRes.BorderPen;
  288.             switch (ctrl.Alignment)
  289.             {
  290.                 case TabAlignment.Bottom:
  291.                     x4b101060f4767186.DrawLine(borderPen, 0, 0, 0, ctrl.DisplayRectangle.Bottom + 2);
  292.                     x4b101060f4767186.DrawLine(borderPen, 0, 0, ctrl.Width, 0);
  293.                     x4b101060f4767186.DrawLine(borderPen, ctrl.Width - 1, 0, ctrl.Width - 1, ctrl.DisplayRectangle.Bottom + 2);
  294.                     return;
  296.                 case TabAlignment.Left:
  297.                     x4b101060f4767186.DrawLine(borderPen, ctrl.DisplayRectangle.X - 2, 0, ctrl.Width, 0);
  298.                     x4b101060f4767186.DrawLine(borderPen, ctrl.DisplayRectangle.X - 2, ctrl.Height - 1, ctrl.Width, ctrl.Height - 1);
  299.                     x4b101060f4767186.DrawLine(borderPen, ctrl.Width - 1, 0, ctrl.Width - 1, ctrl.Height);
  300.                     return;
  302.                 case TabAlignment.Right:
  303.                     x4b101060f4767186.DrawLine(borderPen, 0, 0, 0, ctrl.Height);
  304.                     x4b101060f4767186.DrawLine(borderPen, 0, 0, ctrl.DisplayRectangle.Right + 2, 0);
  305.                     x4b101060f4767186.DrawLine(borderPen, 0, ctrl.Height - 1, ctrl.DisplayRectangle.Right + 2, ctrl.Height - 1);
  306.                     return;
  307.             }
  308.             x4b101060f4767186.DrawLine(borderPen, 0, ctrl.DisplayRectangle.Y - 2, 0, ctrl.Height);
  309.             x4b101060f4767186.DrawLine(borderPen, 0, ctrl.Height - 1, ctrl.Width, ctrl.Height - 1);
  310.             x4b101060f4767186.DrawLine(borderPen, ctrl.Width - 1, ctrl.DisplayRectangle.Y - 2, ctrl.Width - 1, ctrl.Height);
  311.         }
  313.         private void xc33f5f7a18a754cb(Graphics x41347a961b838962, int x067d6ddeefb41622)
  314.         {
  315.             Bitmap bitmap2;
  316.             int num3;
  317.             TabControl ctrl = (TabControl) base.Ctrl;
  318.             Rectangle tabRect = ctrl.GetTabRect(x067d6ddeefb41622);
  319.             if (ctrl.SelectedIndex == x067d6ddeefb41622)
  320.             {
  321.                 num3 = 0;
  322.             }
  323.             else
  324.             {
  325.                 num3 = 1;
  326.             }
  327.             switch (ctrl.Alignment)
  328.             {
  329.                 case TabAlignment.Left:
  330.                 case TabAlignment.Right:
  331.                     bitmap2 = new Bitmap(tabRect.Height, tabRect.Width);
  332.                     break;
  334.                 default:
  335.                     bitmap2 = new Bitmap(tabRect.Width, tabRect.Height);
  336.                     break;
  337.             }
  338.             using (Graphics graphics = Graphics.FromImage(bitmap2))
  339.             {
  340.                 Bitmap image = base.Engine.Res.TabControlRes.TabImage[num3, 0];
  341.                 Rectangle destRect = new Rectangle(0, 0, image.Width, bitmap2.Height);
  342.                 int right = destRect.Right;
  343.                 graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  344.                 image = base.Engine.Res.TabControlRes.TabImage[num3, 2];
  345.                 destRect = new Rectangle(bitmap2.Width - image.Width, 0, image.Width, bitmap2.Height);
  346.                 int left = destRect.Left;
  347.                 graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  348.                 image = base.Engine.Res.TabControlRes.TabImage[num3, 1];
  349.                 destRect = Rectangle.FromLTRB(right, 0, left, bitmap2.Height);
  350.                 graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileY);
  351.                 image = base.Engine.Res.TabControlRes.TabLine;
  352.                 int height = image.Height;
  353.                 Rectangle rectangle2 = new Rectangle(0, 0, image.Width, image.Height);
  354.                 destRect = new Rectangle(0, bitmap2.Height - image.Height, bitmap2.Width, image.Height);
  355.                 graphics.DrawImage(image, destRect, rectangle2.X, rectangle2.Y, rectangle2.Width, rectangle2.Height, GraphicsUnit.Pixel, x448fd9ab43628c71.DrawImageAttrTileX);
  356.             }
  357.             switch (ctrl.Alignment)
  358.             {
  359.                 case TabAlignment.Bottom:
  360.                     bitmap2.RotateFlip(RotateFlipType.Rotate180FlipNone);
  361.                     break;
  363.                 case TabAlignment.Left:
  364.                     bitmap2.RotateFlip(RotateFlipType.Rotate270FlipNone);
  365.                     break;
  367.                 case TabAlignment.Right:
  368.                     bitmap2.RotateFlip(RotateFlipType.Rotate90FlipNone);
  369.                     break;
  370.             }
  371.             x41347a961b838962.DrawImageUnscaled(bitmap2, tabRect.X, tabRect.Y);
  372.             bitmap2.Dispose();
  373.         }
  375.         protected override bool ChangeBackColor
  376.         {
  377.             get
  378.             {
  379.                 return false;
  380.             }
  381.         }
  383.         private bool x0e7ffd184973f9bc
  384.         {
  385.             get
  386.             {
  387.                 TabControl ctrl = (TabControl) base.Ctrl;
  388.                 return (ctrl.RightToLeftLayout && ((ctrl.RightToLeft & RightToLeft.Yes) == RightToLeft.Yes));
  389.             }
  390.         }
  391.     }
  392. }