就开始给窗体添加功能。

   在这为了简化步骤，就以父容器为Canvas考虑，由于他是绝对布局的所以实现移动较方便，大家如果要是控件的使用范围些 可以去试试用平移变换实现窗体移动。

    首先 还是先明确下一些基础点，由于 窗体的外观是在模板里定义的，所以于窗体有关的部件我们不能直接访问，不过访问的方法有好几种，我在这介绍两种。

    1.我们可以在那些模板里的部件加上Loaded事件，再在这个事件的处理函数里把，这个部件的引用保存下来。

   2.是重写OnApplyTemplate方法在这个方法里调用GetTemplateChild获得部件引用。

   我这是利用第二种方法，好现在开始实现功能

1. public override void OnApplyTemplate()  
2.        {  
3.            base.OnApplyTemplate();  

•            TitleC = GetTemplateChild("Win_Title") as TextBlock;//是呈现窗体的TextBlock  
•            BackImage = GetTemplateChild("BackRect") as Rectangle;//是背景矩形  
•            TitleC.Text = Title;//Title是窗体标题的依赖属性  
•            //窗体顶部矩形 用于移动矩形
• (GetTemplateChild("Win_Move") as Rectangle).MouseLeftButtonDown += new MouseButtonEventHandler(WInControl_MouseLeftButtonDown);  
•            //窗体四边的矩形，还记得吗上篇文章 我给他设置Cursor属性这就是为了实现 鼠标移动到窗体边缘的变化 主要要把那四个矩形的背景不能透明，即使0.05也行 就不能透明
• (GetTemplateChild("Side_Right") as Rectangle).MouseLeftButtonDown+=new MouseButtonEventHandler(WInControl_MouseLeftButtonDown);  
•            (GetTemplateChild("Side_Left") as Rectangle).MouseLeftButtonDown += new MouseButtonEventHandler(WInControl_MouseLeftButtonDown);  
•            (GetTemplateChild("Side_Top") as Rectangle).MouseLeftButtonDown += new MouseButtonEventHandler(WInControl_MouseLeftButtonDown);  
•            (GetTemplateChild("Side_Botton") as Rectangle).MouseLeftButtonDown += new MouseButtonEventHandler(WInControl_MouseLeftButtonDown);  
•            //就是窗体上的那三个按钮
• (GetTemplateChild("MinB") as Button).Click +=new RoutedEventHandler(WInControl_Click);  
•            (GetTemplateChild("MaxB") as Button).Click +=new RoutedEventHandler(WInControl_Click);  
•            (GetTemplateChild("CloseB") as Button).Click += new RoutedEventHandler(WInControl_Click);  
•        } 

• 这里就是移动窗体和尺寸拉伸的 代码

   

  protected void WInControl_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)  

  1.        {  
  2.            Rectangle rect = sender as Rectangle;  
  3.  
  4.            rect.MouseMove += new MouseEventHandler(rect_MouseMove);  
  5.            rect.MouseLeftButtonUp += new MouseButtonEventHandler(rect_MouseLeftButtonUp);  
  6.            rect.CaptureMouse();  
  7.            LastPoint = e.GetPosition(Owner);  
  8.           // 这里就注册鼠标移动事件 和 弹起事件
  9.        }  
  10.  
  11.        void rect_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)  
  12.        {  
  13.              
  14.            Rectangle rect = sender as Rectangle;  
  15.            rect.MouseMove -= rect_MouseMove;  
  16.            rect.MouseLeftButtonUp -= rect_MouseLeftButtonUp;  
  17.            rect.ReleaseMouseCapture();  
  18. //这里也没什么好说
  19.        }  
  20.  
  21.        protected void rect_MouseMove(object sender, MouseEventArgs e)  
  22.        {  
  23.            Rectangle rect = sender as Rectangle;  
  24.            Point p = e.GetPosition(Owner);
  25. //这里按照Name判断执行什么操作 
  26.            switch (rect.Name)  
  27.            {  
  28.                case "Win_Move": MoveWin(p); break;  
  29.                case "Side_Right": ChangeRightWin(p); break;  
  30.                case "Side_Left": ChangeLeftWin(p); break;  
  31.                case "Side_Top": ChangeTopWin(p); break;  
  32.                case "Side_Botton": ChangeBottomWIn(p); break;  
  33.            }  
  34.             
  35.        }  
  36.   //而这里是移动的主要逻辑 如果大家做过拖曳控件的功能就非常简单
  37.        public void MoveWin(Point e)  
  38.        {  //LastPoint在鼠标点击事件里赋值 记录了上一个事件里鼠标的位置
  39. // 而这用这事鼠标的位置减去上一时刻的鼠标位置 然后再移动窗体这个差值
  40. //这两个判断语句是防止窗体整个移界面
  41.            Point D_point = new Point(e.X - LastPoint.X, e.Y - LastPoint.Y);  
  42.            if (!(Canvas.GetTop(this) <= 0 && D_point.Y <= 0))  
  43.            {  
  44.                if (!(Canvas.GetTop(this) > Owner.ActualHeight && D_point.Y >= 0))  
  45.                {  
  46.                   Canvas.SetLeft(this, Canvas.GetLeft(this) + D_point.X);  
  47.                   Canvas.SetTop(this, Canvas.GetTop(this) + D_point.Y);  
  48. //再保存位置
  49.                   LastPoint = e;  
  50.                }  
  51.            }  
  52.             
  53.        }  
  54.   //下面四个方法是改变窗体大小的
  55.        void ChangeBottomWIn(Point e)  
  56.        {  //这个是底边拉伸窗体 也很好理解 就是计算出 当鼠标点下 后每次Move的差值 在把这个差值加到窗体高度上
  57.            double M_mun = e.Y - Canvas.GetTop(this) - this.Height;  
  58.            if (this.Height >= 100 || M_mun > 0)  
  59.                this.Height += M_mun;  
  60.        }  
  61.  
  62.        void ChangeTopWin(Point e)  
  63.        {            //这是顶部拉伸的代码 但这不能简单把移动差值加到 控件高度上
  64. //这样会造成向上拉伸 向下变长的现象 我们必须先向上移动控件 这个差值再加  
  65. double M_mun = Canvas.GetTop(this) - e.Y;  
  66.                    if(this.Height >= 100 || M_mun >0)  
  67.                    this.Height += M_mun;  
  68.                    LastPoint = e;  
  69.                    Canvas.SetTop(this, LastPoint.Y);  
  70.        }  
  71.  //接下来的左边和右边就不讲 原理和上面一样
  72.        void ChangeLeftWin(Point e)  
  73.        {  
  74.            double M_mun = Canvas.GetLeft(this) - e.X;  
  75.            if (this.Width >= 100 || M_mun > 0)  
  76.                this.Width += M_mun;  
  77.            LastPoint = e;  
  78.            Canvas.SetLeft(this, LastPoint.X);  
  79.        }  
  80.  
  81.        void ChangeRightWin(Point e)  
  82.        {  
  83.            double M_mun = e.X - Canvas.GetLeft(this) - this.Width;  
  84.            if (this.Width >= 100 || M_mun > 0)  
  85.                this.Width += M_mun;  
  86.        } 

  接下来是实现最大化的功能

   

  接着看代码

  1. public static readonly DependencyProperty IsMaxmunProperty = DependencyProperty.Register("IsMaxmun", typeof(bool), typeof(WInControl), new PropertyMetadata(false, onIsMaxmunChange)); //这是定义的最大化的依赖属性说是最大化 其实是最大化和窗口化

   

  1. public bool IsMaxmun//最大化  
  2.         {  
  3.             get { return (bool)this.GetValue(IsMaxmunProperty); }  
  4.             set { this.SetValue(IsMaxmunProperty, value); }  
  5.         } 
  1. public static void onIsMaxmunChange(DependencyObject sender, DependencyPropertyChangedEventArgs e)  
  2.         {  
  3.             WInControl This = sender as WInControl;  
  4.             if (This.IsMaxmun == true)  
  5.                 This.ToMaxmun();  
  6.             else 
  7.                 This.ToMinnormal();  
  8.         } 
  1. protected virtual void ToMaxmun()  
  2.        {  //把窗体高和宽保存起来 再把窗体设置成与父容器 这里有个Owner是用来设置父容器引用
  3. //大家也可 用Parent属性 他就是在可视树上的父节点
  4.            LastPoint.X = Canvas.GetLeft(this);  
  5.            LastPoint.Y = Canvas.GetTop(this);  
  6.            LastWinSize.Width = this.Width;  
  7.            LastWinSize.Height = this.Height;  
  8.  
  9.            Canvas.SetLeft(this, 0);  
  10.            Canvas.SetTop(this, 0);  
  11.            this.Height = (Owner).RenderSize.Height;  
  12.            this.Width = (Owner).RenderSize.Width;  
  13.  
  14.        }  
  15.  
  16.        protected virtual void ToMinnormal()  
  17.        {  //这里就是还原窗体
  18.            Canvas.SetLeft(this, LastPoint.X);  
  19.            Canvas.SetTop(this, LastPoint.Y);  
  20.            this.Height = LastWinSize.Height;  
  21.            this.Width = LastWinSize.Width;  
  22.        } 

  这就是最大化和窗口化功能 还有一点在最大化时大家要 移除那几个矩形的鼠标点击事件 再在

  窗口化添加这个事件 最小化就留给大家自己考虑。

   

  1. public static readonly DependencyProperty TitleProperty = DependencyProperty.Register("Title", typeof(string), typeof(WInControl), new PropertyMetadata(string.Empty, OnTitleChanged)); 

  这个是窗体标题

   

  1. public string Title  
  2.        {  
  3.            get { return (string)GetValue(TitleProperty); }  
  4.            set { SetValue(TitleProperty, value); }  
  5.        } 
  1. public static void OnTitleChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)  
  2.        {  
  3.            WInControl This = sender as WInControl;  
  4.            if (This.TitleC != null)  
  5.                This.TitleC.Text = This.Title;  
  6.        } 

  这里有一点要注意 由于这个方法比较早调用 而 TitleC没有设置引用 所以要判断下是否为null

  这里一部分基本功能已经完成了

  不过有两个重要的功能就是关闭 和打开窗体

  这里的repeat和repeat2是防止动画被多次设定

  动画已经在资源里

  只是没有设定作用对象

  1. public override void Close()  
  2.        {  
  3.            Storyboard app = Resources["_disappear"] as Storyboard;  
  4.            if (repeat == false)  
  5.            {  
  6.                foreach (var item in app.Children)  
  7.                {  
  8.                    Storyboard.SetTarget(item, this);  
  9.                }  
  10.                repeat = true;  
  11.            }  
  12.            app.Begin();   
  13.        }  
  14.  
  15.        public override void Open()  
  16.        {  
  17.            Storyboard app = Resources["_appear"] as Storyboard;  
  18.            this.Visibility = Visibility.Visible;  
  19.            if (repeat2 == false)  
  20.            {  
  21.                foreach (var item in app.Children)  
  22.                {  
  23.                    Storyboard.SetTarget(item, this);  
  24.                }  
  25.                repeat2 = true;  
  26.            }  
  27.            app.Begin();   
  28.        } 

  就这样就可以实现关闭和打开的功能

  而且动画由你自己设定

  这里先讲到这里 可能有很多不足 但免免强强一个自己写的win窗体控件算完成了

  对于那些sl老手可能没什么

  但我希望对sl初学的朋友有帮助

  还请大家多提意见相互学习 Demo我整理下晚点发上来

  希望大家这个基础上继续加强！！！！！！！！！！

   

  演示地址http://anye6488-001-site1.site4future.com/anyePath.web/anyePathTestPage1.html

注：本文转自http://dingtao-wgs.blog.163.com/blog/static/502607142010101754018734/，仅供学习之用。