博客园_badnewfish

买了诺基亚800c 之痛充电时无法呼通电话漏接电话

2012-05-22T14:16:00Z

坑爹的诺基亚800c 用原装充电器+充电线充电，关屏。别人就打不进来电话了，漏接电话，10次呼叫，漏接4次左右，坑爹呢。

有相同问题的加qq号码 313887852

三星s239手机与计算机同步_计算机通过手机上3G

2011-11-30T03:25:00Z

部分内容转自http://raozhl.blog.163.com/blog/static/67924495201172891328240/

1、首先安装New_PC_Studio_1.5.1.10072_2 时不要连接手机，以windows xp2兼容模式高管权限运行安装程序，装到最好会提示win32异常，不要理他。因为在默认目录下C:\Program Files\Samsung\Samsung New PC Studio已经有所有程序了

2、安装楼主所说设置手机
为了能把老婆的S239搞成笔记本的MODEM,搞了一个下午，终于成功
三星S239缺省没有把机器端口打开，缺省的也不是USB连接模式，需要通过下面方法设置
待机模式下，输入*759#813580进入测试模式
选择“端口映射图”；“图表”；“USB SER1”
回到待机模式下，输入*#2739#，选择“Open Port”
输入密码：*#67367678#，确定以自动保存（不知道三星为什么要缺省关掉USB功能，太不厚道了）
后面记得重启手机

3、连接手机，此时会在设备管理器--端口下出现一个"SAMSUNG Mobeile Modem Diagnostic Serial Port(WDM) (COMx)"，同时在同学串行总线控制器中出现一个SAMSUG USB Composite Device，如果没有这个两个设备，则在出现黄色符号的设备上(前提是没插手机之前没有黄色符号)，点击用“更新驱动软件”--“自动搜索”即可，如果不能自动搜索，需要在控制面板--打印机和设备--右键你的计算机标志--设备安装设置--选择“在我的计算机上找不到从windows update下载”--保存，然后回设备管理器搜索。

4、打开“C:\Program Files\Samsung\Samsung New PC Studio\NewPCStudio.exe”同时添加快捷方式以便后用，此时会自动连接到手机。如果此时连接不到手机，肯定是第三步驱动没有安装正确

5、软件的左下角有个齿轮图标，点一下，把发短信和“互联网连接器”添加进来，打开“互联网连接器”上面也有个小齿轮图标，添加连接设置，选择“china telecom”其它的设置不用改。回到“互联网连接器”，选择“SCH-s239”点连接即可。此时计算机右下角的网络设置(显示器图标)，里面就有一一个“连接设置1”，目录和你使用过的VPN、USB3g网卡的连接放在一个栏目里的。以后就可以用这个了。

6、切不可升级New PC Studio，因为后期的这个软件可能是针对高端机的，根据我昨天折腾半天的经验，高版本的这个软件不一定能支持这个低端手机。如果你不幸安装了这些高版本的New PC Studio和Kies软件，请先删除它们，删除安装目录下的所有文件，如果有一个usb driver的文件夹，进去卸载掉usb驱动，或者把计算机设置为不主动去windows update搜索驱动(参照步骤3)，然后卸载驱动。最后安装本例来做。

在最后，祝挣扎在折腾线上的侠客们成功！

本文链接

慎用匿名委托 Dispatcher.BeginInvoke导致UI卡死之发现

2011-11-25T06:42:00Z

先描述一下需求，服务器程序需要对终端的在线状态进行跟踪，采用ping的发放获取信息，在ping通或者ping不通后需要对UI进行更新，下面是出问题的代码(此例ping的方法比较简单，尚未进行应用测试勿用作实际用途)：

1     public partial class MainWindow : Window
2     {
3         public MainWindow()
4         {
5             InitializeComponent();
6         }
7         List<string> ClientInfoList = new List<string>();
8         private void Window_Loaded(object sender, RoutedEventArgs e)
9         {
10             for (int i = 1; i < 50; i++)
11             {
12                 ClientInfoList.Add("192.168.1." + i.ToString());
13             }
14
15             ThreadPool.QueueUserWorkItem(
16                delegate
17                {
18                    while (true)
19                    {
20                        Debug.WriteLine(DateTime.Now.ToString() + "Ping");
21                        int OnLineCout = 0;
22                        Ping pingSender = new Ping();
23                        PingOptions options = new PingOptions();
24                        for (int i = 0; i < ClientInfoList.Count; i++)
25                        {
26                            if (ClientInfoList[i] != "")
27                            {
28                                options.DontFragment = true;
29                                bool PingSuceess = false;
30                                PingReply reply = pingSender.Send(ClientInfoList[i], 100);
31                                if (reply.Status == IPStatus.Success)
32                                {
33                                    PingSuceess = true;
34                                }
35
36                                if (!PingSuceess)
37                                {
38                                    Debug.WriteLine(DateTime.Now.ToString() + "Ping失败,终端IP:" + ClientInfoList[i]);
39                                    this.Dispatcher.BeginInvoke((Action)delegate()
40                                     {
41                                         label1.Content = ClientInfoList[i];
42                                     });
43                                }
44                                else
45                                {
46                                    OnLineCout++;
47                                }
48
49                            }
50                        }
51                        Debug.WriteLine(DateTime.Now.ToString() + "PingOver");
52                        Thread.Sleep(3000);
53                    }
54                }, null);
55
56         }
57
58         private void button1_Click(object sender, RoutedEventArgs e)
59         {
60             button1.Content = new Random().Next();
61         }
62     }

第39行为更新UI的方法，当循环执行完毕后执行第二次循环后，会不定期出现程序异常。实际的应用比这个例子代码要复杂很多，所以不断的注释，使代码简化，最终将问题锁定在本例中的39行附近，后来一直是怀疑不该使用this.Dispatcher.BeginInvoke这种方式来实现。再后来采用DispatcherTimer类来实现，由于程序其它线程也要操作一些UI对象，使用这种方式又导致UI响应太慢，出现卡顿现象(再多的DispatcherTimer都使用一个线程来调度，所以DispatcherTimer开的越多，UI越卡)。再后来找到了老赵的帖子《

警惕匿名方法造成的变量共享》受到启发，开始怀疑是匿名实现this.Dispatcher.BeginInvoke造成的，后将代码改为以下：

1     public partial class MainWindow : Window
2     {
3         public MainWindow()
4         {
5             InitializeComponent();
6         }
7         List<string> ClientInfoList = new List<string>();
8         delegate void UpdateUI(string str);
9
10         void UpdateUIMethod(string str)
11         {
12             label1.Content = str;
13         }
14         private void Window_Loaded(object sender, RoutedEventArgs e)
15         {
16             for (int i = 1; i < 50; i++)
17             {
18                 ClientInfoList.Add("192.168.1." + i.ToString());
19             }
20             UpdateUI UUI = new UpdateUI(UpdateUIMethod);
21             ThreadPool.QueueUserWorkItem(
22                delegate
23                {
24                    while (true)
25                    {
26                        Debug.WriteLine(DateTime.Now.ToString() + "Ping");
27                        int OnLineCout = 0;
28                        Ping pingSender = new Ping();
29                        PingOptions options = new PingOptions();
30                        for (int i = 0; i < ClientInfoList.Count; i++)
31                        {
32                            if (ClientInfoList[i] != "")
33                            {
34                                options.DontFragment = true;
35                                bool PingSuceess = false;
36                                PingReply reply = pingSender.Send(ClientInfoList[i], 100);
37                                if (reply.Status == IPStatus.Success)
38                                {
39                                    PingSuceess = true;
40                                }
41
42                                if (!PingSuceess)
43                                {
44                                    Debug.WriteLine(DateTime.Now.ToString() + "Ping失败,终端IP:" + ClientInfoList[i]);
45                                    //this.Dispatcher.BeginInvoke((Action)delegate()
46                                    // {
47                                    //     label1.Content = ClientInfoList[i];
48                                    // });
49                                    this.Dispatcher.BeginInvoke(UUI, ClientInfoList[i]);
50                                }
51                                else
52                                {
53                                    OnLineCout++;
54                                }
55
56                            }
57                        }
58                        Debug.WriteLine(DateTime.Now.ToString() + "PingOver");
59                        Thread.Sleep(3000);
60                    }
61                }, null);
62
63         }
64
65         private void button1_Click(object sender, RoutedEventArgs e)
66         {
67             button1.Content = new Random().Next();
68         }
69     }

本文链接

BeginInvoke更新界面 UI死掉 WPF

2011-09-02T08:21:00Z

BeginInvoke更新界面 UI死掉

异步socket的处理消息事件 void ProcessA_BBuff(byte[] GetBuffer, Client.ClientInfo clientTemp)中

需要根据客户端发来的坐标信息更新UI上对应usercontrol的位置(类似于GIS系统中小人在地图上更新位置)

当只把移动的少量代码（2行）写到BeginInvoke中时就是说将BeginInvoke 写到ProcessA_BBuff这个事件里面程序跑几分钟后UI就会死掉

this.Dispatcher.BeginInvoke((Action)delegate()
{

//移动小人

});

但是在主程序中这样写就好了：

this.Dispatcher.BeginInvoke((Action)delegate()
                {
                    ProcessA_BBuff(msgBuff, CI);
                });

也就是说扩大了BeginInvoke的作用范围就好了

具体什么原因一直不解

本文链接

未处理 System.Reflection.TargetInvocationException Message=调用的目标发生了异常。

2011-09-01T09:03:00Z

遇到次问题多半是 this.Dispatcher.BeginInvoke((Action)delegate(){}) 大括号中的代码出了异常如里面访问的数组单元被外部线程清空等但是vs又捕捉不到

主程序会崩溃

本文链接

屏幕坐标系中已知两点坐标，第三点在两点的连线内且已知第三点到两点中任意一点的距离求第三点的坐标

2011-06-09T08:11:00Z

                                    if (MACs.Count == 2)
                                    {
                                        ///点1为X值小的点
                                        double X1 = StationList[Indexs[0]].Coordinates_X;
                                        double X2 = StationList[Indexs[1]].Coordinates_X;
                                        double Y1 = StationList[Indexs[0]].Coordinates_Y;
                                        double Y2 = StationList[Indexs[1]].Coordinates_Y;
                                        double DBM1 = -DBMs[0];
                                        double DBM2 = -DBMs[1];
                                        ///点1为X值小的点
                                        if (StationList[Indexs[0]].Coordinates_X > StationList[Indexs[1]].Coordinates_X)
                                        {
                                            X1 = StationList[Indexs[1]].Coordinates_X;
                                            X2 = StationList[Indexs[0]].Coordinates_X;
                                            Y1 = StationList[Indexs[1]].Coordinates_Y;
                                            Y2 = StationList[Indexs[0]].Coordinates_Y;
                                            DBM1 = -DBMs[1];
                                            DBM2 = -DBMs[2];
                                        }

                                        ///在依赖RSSI的定位系统中信号强度越大对应的距离值越准确
                                        if (DBM1 > DBM2)
                                        {

                                            //public static double GetDistance(double P1, double A1, double A2, double P2, double F,double N)
                                           // {
                                                  // return Math.Pow(10, ((P1 + A1 + A2 - P2 - 20 * Math.Log10(F) + 27.56) / 20))+N;
                                           //}

                                            double Distance = BLL.ConvertDBMToDistance.GetDistance(20, 3, 2.5, DBM1, 2400, 0);
                                            ///用反三角函数求出角度
                                            double JiaoQ = Math.Atan(Math.Abs(Y1 - Y2) / Math.Abs(X1 - X2));
                                            ///求出X的增量
                                            double XLenth = Distance * Math.Cos(JiaoQ);
                                            ///求出Y的增量
                                            double YLenth = Distance * Math.Sin(JiaoQ);
                                            if (Y1 < Y2)
                                            {
                                                X = X1 + XLenth;
                                                Y = Y1 + YLenth;
                                            }
                                            else if (Y1 > Y2)
                                            {
                                                X = X1 + XLenth;
                                                Y = Y1 - YLenth;

                                            }
                                            else if (Y1 == Y2)
                                            {
                                                X = X1 + XLenth;
                                                Y = Y1;
                                            }
                                        }
                                        else if (DBM1 < DBM2)
                                        {
                                            double Distance = BLL.ConvertDBMToDistance.GetDistance(20, 3, 2.5, DBM2, 2400, 0);
                                            double JiaoQ = Math.Atan(Math.Abs(Y1 - Y2) / Math.Abs(X1 - X2));
                                            double XLenth = Distance * Math.Cos(JiaoQ);
                                            double YLenth = Distance * Math.Sin(JiaoQ);
                                            if (Y1 < Y2)
                                            {
                                                X = X2 - XLenth;
                                                Y = Y1 - YLenth;
                                            }
                                            else if (Y1 > Y2)
                                            {
                                                X = X2 - XLenth;
                                                Y = Y2 + YLenth;

                                            }
                                            else if (Y1 == Y2)
                                            {
                                                X = X2 - XLenth;
                                                Y = Y1;
                                            }
                                        }

}

本文链接

WPF学习笔记--向界面动态添加控件或者usercontrol

2011-05-28T16:40:00Z

在做工控业界面时，运行时添加和编辑界面元素会给程序带来更大的灵活性，同时更能增加用户体验的好评度。

以下的例子代码实现：在应用程序界面需要更新时(如应用程序加载时)将存储于数据库的界面元素数据载入到UI当中，并且绑定一些事件或者菜单

前台代码:

后台代码:

/// <summary>
        /// 将所有基站添加到系统界面当中
        /// </summary>
        void AddALlStationToUI()
        {
            BLL.Station SDB = new BLL.Station();
            DataTable StationModelList = SDB.GetAll();
            if (StationModelList.TableName != "正确")
            {
                //ConnectErorr("数据库连接错误：" + StationModelList.TableName);
                //return 0;
            }
            if (StationModelList.Rows.Count < 1)
            {
                //ConnectErorr("数据库连接错误：从数据库未获取有效基站！");
                //return 0;
            }
            for (int i = 0; i < StationModelList.Rows.Count; i++)
            {
                Station ap = new Station();
                ap.IP = StationModelList.Rows[i]["IP"].ToString();
                ap.ListenPort = Convert.ToInt16(StationModelList.Rows[i]["ListenPort"]);
                ap.Coordinates_X = Convert.ToDouble(StationModelList.Rows[i]["Coordinates_X"]);
                ap.Coordinates_Y = Convert.ToDouble(StationModelList.Rows[i]["Coordinates_Y"]);
                ap.Coefficient_X = Convert.ToDouble(StationModelList.Rows[i]["Coefficient_X"]);
                ap.Coefficient_Y = Convert.ToDouble(StationModelList.Rows[i]["Coefficient_Y"]);
                ap.SN = StationModelList.Rows[i]["SN"].ToString();
                ap.Remark = StationModelList.Rows[i]["Remark"].ToString();
                ap.ID = new Guid(StationModelList.Rows[i]["ID"].ToString());
                StationList.Add(ap);
                UC.UC_AP UC_AP = new UC.UC_AP();
                UC_AP.Tag = ap.ID;
                System.Windows.Controls.ContextMenu contextmenu = new ContextMenu();
                System.Windows.Controls.MenuItem MIViewStationInfor = new MenuItem();
                MIViewStationInfor.Header = "查看详细信息";
                MIViewStationInfor.Tag = ap.ID;
                MIViewStationInfor.Click += new RoutedEventHandler(StationMenu_ViewStationInfor_Click);
                contextmenu.Items.Add(MIViewStationInfor);
                UC_AP.ContextMenu = contextmenu;
                Canvas.SetTop(UC_AP, ap.Coordinates_Y);
                Canvas.SetLeft(UC_AP, ap.Coordinates_X);
                AP_Plank.Children.Add(UC_AP);
            }
        }
        /// <summary>
        /// 基站右键菜单（查看详细信息）事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void StationMenu_ViewStationInfor_Click(object sender, RoutedEventArgs e)
        {
            System.Windows.Controls.MenuItem MI = sender as System.Windows.Controls.MenuItem;
            //此处可弹出窗口显示详细信息，同时可给窗口定义一个修改完成事件，当窗口修改完成时回刷主界面元素

MessageBox.Show(MI.Tag.ToString());
}

本文链接

附加数据库失败，操作系统错误 5:"5(拒绝访问。)"的解决办法

2011-05-27T14:52:00Z

附加数据库失败，操作系统错误 5:"5(拒绝访问。)"的解决办法

无法打开物理文件 XXX.mdf"。操作系统错误 5:"5(拒绝访问。)"。 (Microsoft SQL Server，错误:

5120) 找到xxx.MDF与xxx_log.LDF文件，右键-属性-安全-在组或用户名处添加Authenticated

Users-更改该组权限为完全权限，再次附加成功。

本文链接

事件和委托在通信编程中的应用

2011-05-19T15:33:00Z

封装后的socket类

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Net.Sockets;
  5 using System.Net;
  6
  7 namespace SICOMSocket
  8 {
  9     public class SocketAsyncServer
10     {
11
12         public delegate void ProcessMessageeDelegate(Socket clientSock, byte[] msgBuff, DateTime getDataTime);
13         public event ProcessMessageeDelegate ProcessMessageeEnvent;
14
15         public delegate void ClearFlag();
16         public event ClearFlag Clear;
17
18         public delegate void NewConnectDelegate(string IP, string port, Socket clinetSocket);
19         public event NewConnectDelegate NewConnectEnvent;
20
21         public delegate void ClientShutDownDelegate(string IP, string port);
22         public event ClientShutDownDelegate ClientShutDownEnvent;
23
24
25         private Socket serverSock;
26         byte[] msgBuff = new byte[1024];
27
28         public void Start(int port)
29         {
30             try
31             {
32                 serverSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
33                 serverSock.Bind(new IPEndPoint(IPAddress.Any, port));
34                 serverSock.Listen(10);
35                 Console.WriteLine("开始监听端口" + port + "......");
36                 serverSock.BeginAccept(new AsyncCallback(OnConnectRequest), serverSock);
37             }
38             catch (Exception ex)
39             {
40                 Console.WriteLine("监听端口" + port + "失败，请检查该端口是否被占用！ " + ex.Message);
41             }
42         }
43
44         public void OnConnectRequest(IAsyncResult ar)
45         {
46             try
47             {
48                 Socket listenerSock = (Socket)ar.AsyncState;
49                 NewConnection(listenerSock.EndAccept(ar));
50                 listenerSock.BeginAccept(new AsyncCallback(OnConnectRequest), listenerSock);
51                 Console.WriteLine("已接受远程连接！");
52             }
53             catch (Exception ex)
54             {
55                 Console.WriteLine("新链接创建错误：" + ex.Message);
56             }
57         }
58
59         private void NewConnection(Socket clientSock)
60         {
61             try
62             {
63                 EndPoint tempRemoteEP = clientSock.RemoteEndPoint;
64                 IPEndPoint tempRemoteIP = (IPEndPoint)tempRemoteEP;
65                 string rempip = tempRemoteIP.Address.ToString();
66                 string remoport = tempRemoteIP.Port.ToString();
67                 NewConnectEnvent(rempip, remoport, clientSock);
68                 Clear();
69                 AsyncCallback recieveData = new AsyncCallback(OnRecievedData);
70                 clientSock.BeginReceive(msgBuff, 0, msgBuff.Length, SocketFlags.None, recieveData, clientSock);
71             }
72             catch (Exception ex)
73             {
74                 Console.WriteLine("接收回调函数设置失败 {0}", ex.Message);
75             }
76         }
77
78         public void OnRecievedData(IAsyncResult ar)
79         {
80             Socket sock = (Socket)ar.AsyncState;
81             try
82             {
83                 DateTime getDataTime = DateTime.Now;
84                 int nBytesRec = sock.EndReceive(ar);
85                 if (nBytesRec > 0)
86                 {
87                     byte[] recievedNowBuff = new byte[nBytesRec];
88                     Array.Copy(msgBuff, recievedNowBuff, nBytesRec);
89                     try
90                     {
91                         AsyncCallback recieveData = new AsyncCallback(OnRecievedData);
92                         sock.BeginReceive(msgBuff, 0, msgBuff.Length, SocketFlags.None, recieveData, sock);
93                     }
94                     catch (Exception ex)
95                     {
96                         Console.WriteLine("接收回调函数设置失败 {0}", ex.Message);
97                     }
98
99                     System.Threading.Thread t1 = new System.Threading.Thread(delegate() { ProcessMessageeEnvent(sock, recievedNowBuff, getDataTime); });
100                     t1.Start();
101                 }
102                 else
103                 {
104                     Console.WriteLine("连接中断 {0}", sock.RemoteEndPoint);
105                     EndPoint tempRemoteEP = sock.RemoteEndPoint;
106                     IPEndPoint tempRemoteIP = (IPEndPoint)tempRemoteEP;
107                     string rempip = tempRemoteIP.Address.ToString();
108                     string remoport = tempRemoteIP.Port.ToString();
109                     sock.Shutdown(SocketShutdown.Both);
110                     sock.Close();
111                     ClientShutDownEnvent(rempip, remoport);
112                 }
113             }
114             catch (Exception ex)
115             {
116                 Console.WriteLine(ex.Message, "未知错误!");
117             }
118         }
119     }
120
121 }

调用类：

SICOMSocket.SocketAsyncServer SAC = new SICOMSocket.SocketAsyncServer();
        byte ServerID;
        public void Start(byte ServerID)
        {
            this.ServerID = ServerID;
            SAC.ClientShutDownEnvent += new SICOMSocket.SocketAsyncServer.ClientShutDownDelegate(SAC_ClientShutDownEnvent);
            SAC.NewConnectEnvent += new SICOMSocket.SocketAsyncServer.NewConnectDelegate(SAC_NewConnectEnvent);
            SAC.ProcessMessageeEnvent += new SICOMSocket.SocketAsyncServer.ProcessMessageeDelegate(SAC_ProcessMessageeEnvent);
            SAC.Start(502);
        }
void SAC_NewConnectEnvent(string IP, string port, System.Net.Sockets.Socket clinetSocket)
        {
            Console.WriteLine(DateTime.Now.ToString() + "监听到一个新的连接:对方IP[" + IP + "]" + "对方端口[" + port + "]");
        }

        void SAC_ClientShutDownEnvent(string IP, string port)
        {
            Console.WriteLine(DateTime.Now.ToString() + "连接中断:对方IP[" + IP + "]" + "对方端口[" + port + "]");
        }

本文链接

WPF学习笔记--运行时画图的实现

2011-05-19T15:23:00Z

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;

namespace Main.Ranging
{
    public class Ruler
    {
        public delegate void PolygonAddedDelegate(Polygon Points);
        public event PolygonAddedDelegate PolygonAddedEvent;

        UInt16 AreaTempCount = 0;
        double Sum = 0;//距离
        Point mousePosition; //鼠标坐标
        bool TrunOn_OffSwitch = false;//测距开关量
        bool RulerKey = false;//标尺显示开关量
        double Ruler_X = 0;//顶点X值
        double Ruler_Y = 0;//顶点Y值
        double movePlank_X = 0;
        double movePlank_Y = 0;
        UC_Ruler UC_ruler = new UC_Ruler();
        Canvas RulerBoard;
        Canvas MovePlank;
        double zoomValue = 1;
        PointCollection PointListTemp = new PointCollection();
        Polygon MyPolygon = new Polygon();
        bool _Eraser = false;
        /// <summary>
        /// 用于判断操作类型的开关
        /// </summary>
        public bool Eraser
        {
            get { return _Eraser; }
            set { _Eraser = value; }
        }

        public double ZoomValue
        {
            get { return zoomValue; }
            set { zoomValue = value; }
        }
        double x_cut, y_cut;
        /// <summary>
        ///
        /// </summary>
        /// <param name="movePlank"></param>
        /// <param name="rulerBoard">要计算的底层面板</param>
        /// <param name="x_cut">绝对坐标偏差</param>
        /// <param name="y_cut">相对坐标偏差</param>
        public Ruler(Canvas movePlank, Canvas rulerBoard, double x_cut, double y_cut)
        {
            this.x_cut = x_cut;
            this.y_cut = y_cut;
            this.MovePlank = movePlank;
            this.RulerBoard = rulerBoard;
            movePlank.MouseMove += new MouseEventHandler(RulerBoard_MouseMove);
            movePlank.MouseLeftButtonDown += new MouseButtonEventHandler(RulerBoard_MouseLeftButtonDown);
            movePlank.MouseRightButtonDown += new MouseButtonEventHandler(RulerBoard_MouseRightButtonDown);
            MovePlank.MouseWheel += new MouseWheelEventHandler(RulerBoard_MouseWheel);
            //PointListTemp.Add(new PointCollection());
            init();
        }
        private void init()
        {
            TrunOn_OffSwitch = false;//测距开关量
            RulerKey = false;//标尺显示开关量
            Ruler_X = 0;//顶点X值
            Ruler_Y = 0;//顶点Y值
            Sum = 0;//距离
            //RulerBoard.Width = 3300;
            //RulerBoard.Height = 2200;
        }
        public void AddElement(UserControl element, double x, double y)
        {
            Canvas.SetTop(element, y);
            Canvas.SetLeft(element, x);
            RulerBoard.Children.Add(element);
        }
        /// <summary>
        /// 开始测量或关闭测量
        /// </summary>
        /// <param name="TrunOn_Off">true为开false为关</param>
        public void RulerSwitch(bool TrunOn_Off)
        {
            TrunOn_OffSwitch = TrunOn_Off;
        }
        private void RulerBoard_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (!_Eraser)
            {
                if (TrunOn_OffSwitch)
                {
                    if (RulerKey)
                    {
                        RulerBoard.Children.Remove(UC_ruler);
                        RulerKey = !RulerKey;
                    }
                    mousePosition = e.GetPosition(null);
                    UC_Coordinates coordinates = new UC_Coordinates();
                    //addElement(coordinates, (mousePosition.X - movePlank_X) / zoomValue, (mousePosition.Y - movePlank_Y) / zoomValue);
                    AddElement(coordinates, (mousePosition.X - movePlank_X - x_cut) / zoomValue, (mousePosition.Y - movePlank_Y - y_cut) / zoomValue);
                    PointListTemp.Add(new Point((mousePosition.X - movePlank_X - x_cut) / zoomValue, (mousePosition.Y - movePlank_Y - y_cut) / zoomValue));

                    string text = "起点";
                    if (Ruler_X == 0 && Ruler_Y == 0)
                    {
                        //Ruler_X = (mousePosition.X - movePlank_X) / zoomValue;
                        //Ruler_Y = (mousePosition.Y - movePlank_Y) / zoomValue;
                        Ruler_X = (mousePosition.X - x_cut - movePlank_X) / zoomValue;
                        Ruler_Y = (mousePosition.Y - movePlank_Y - y_cut) / zoomValue;
                        coordinates.setValue(text);
                        return;
                    }
                    //Point startPt = new Point(Ruler_X, Ruler_Y);
                    //Sum += setDifference((mousePosition.X - movePlank_X) / zoomValue, (mousePosition.Y - movePlank_Y) / zoomValue);
                    Sum += setDifference((mousePosition.X - movePlank_X - x_cut) / zoomValue, (mousePosition.Y - movePlank_Y - y_cut) / zoomValue);
                    text = Sum.ToString() + "米";
                    coordinates.setValue(text);
                    //Point endPt = new Point((mousePosition.X - movePlank_X) / zoomValue, (mousePosition.Y - movePlank_Y) / zoomValue);
                    //Ruler_X = (mousePosition.X - movePlank_X) / zoomValue;
                    //Ruler_Y = (mousePosition.Y - movePlank_Y) / zoomValue;
                    //Point endPt = new Point((mousePosition.X - movePlank_X - x_cut) / zoomValue, (mousePosition.Y - movePlank_Y - y_cut) / zoomValue);
                    Ruler_X = (mousePosition.X - movePlank_X - x_cut) / zoomValue;
                    Ruler_Y = (mousePosition.Y - movePlank_Y - y_cut) / zoomValue;
                    //DrawingLine(startPt, endPt);

                    for (int i = 0; i < RulerBoard.Children.Count; i++)
                    {
                        FrameworkElement element = RulerBoard.Children[i] as FrameworkElement;
                        if (element.Tag != null)
                            if ("TempPolygon" == element.Tag.ToString())
                            {
                                RulerBoard.Children.RemoveAt(i);
                                break;
                            }
                    }

                    MyPolygon.Stroke = System.Windows.Media.Brushes.Black;
                    MyPolygon.Fill = System.Windows.Media.Brushes.LightSeaGreen;
                    MyPolygon.StrokeThickness = 2;
                    MyPolygon.HorizontalAlignment = HorizontalAlignment.Left;
                    MyPolygon.VerticalAlignment = VerticalAlignment.Center;
                    MyPolygon.Points = PointListTemp;
                    MyPolygon.Tag = "TempPolygon";
                    RulerBoard.Children.Add(MyPolygon);

                }
            }
        }
        private void RulerBoard_MouseMove(object sender, MouseEventArgs e)
        {
            if (!_Eraser)
            {
                if (TrunOn_OffSwitch)
                {
                    string text = "单击确定起点";
                    FrameworkElement element = MovePlank as FrameworkElement;
                    movePlank_X = (double)element.GetValue(Canvas.LeftProperty);
                    movePlank_Y = (double)element.GetValue(Canvas.TopProperty);
                    mousePosition = e.GetPosition(null);
                    if (!RulerKey)
                    {

                        //addElement(UC_ruler, (mousePosition.X - movePlank_X) / zoomValue, (mousePosition.Y - movePlank_Y) / zoomValue);
                        AddElement(UC_ruler, (mousePosition.X - movePlank_X - x_cut) / zoomValue, (mousePosition.Y - movePlank_Y) / zoomValue);
                        RulerKey = !RulerKey;
                    }
                    //UC_ruler.SetValue(Canvas.LeftProperty, (mousePosition.X - movePlank_X) / zoomValue);
                    //UC_ruler.SetValue(Canvas.TopProperty, (mousePosition.Y - movePlank_Y) / zoomValue);
                    UC_ruler.SetValue(Canvas.LeftProperty, (mousePosition.X - movePlank_X - x_cut) / zoomValue);
                    UC_ruler.SetValue(Canvas.TopProperty, (mousePosition.Y - movePlank_Y) / zoomValue);
                    if (Ruler_X == 0 && Ruler_Y == 0)
                    {
                        UC_ruler.setValue(text);
                        return;
                    }
                    //double str = Sum + setDifference(mousePosition.X / zoomValue, mousePosition.Y / zoomValue);
                    double str = Sum + setDifference((mousePosition.X - movePlank_X - x_cut) / zoomValue, (mousePosition.Y - movePlank_X) / zoomValue);
                    text = "总长：" + str.ToString() + "米";
                    UC_ruler.setValue(text);
                    e.Handled = true;
                }
            }
        }
        private void RulerBoard_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (!_Eraser)
            {
                if (PointListTemp.Count > 0)
                    PolygonAddedEvent(MyPolygon);
                //RulerBoard.Children.Remove(UC_ruler);
                //init();
                //PointListTemp.Clear();
            }
        }
        private void RulerBoard_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            FrameworkElement element = MovePlank as FrameworkElement;
            movePlank_X = (double)element.GetValue(Canvas.LeftProperty);
            movePlank_Y = (double)element.GetValue(Canvas.TopProperty);
            //ruler.SetValue(Canvas.LeftProperty, (mousePosition.X - movePlank_X) / zoomValue);
            //ruler.SetValue(Canvas.TopProperty, (mousePosition.Y - movePlank_Y) / zoomValue);
            UC_ruler.SetValue(Canvas.LeftProperty, (mousePosition.X - x_cut - movePlank_X) / zoomValue);
            UC_ruler.SetValue(Canvas.TopProperty, (mousePosition.Y - y_cut - movePlank_Y) / zoomValue);
            e.Handled = true;

        }
        private double setDifference(double x, double y)
        {
            return Math.Round(Math.Sqrt(Math.Pow(x - Ruler_X, 2) + Math.Pow(y - Ruler_Y, 2)), 2);
        }
        //划线
        protected void DrawingLine(Point startPt, Point endPt)
        {
            LineGeometry myLineGeometry = new LineGeometry();
            myLineGeometry.StartPoint = startPt;
            myLineGeometry.EndPoint = endPt;
            Path myPath = new Path();
            myPath.Stroke = Brushes.Red;
            myPath.StrokeThickness = 2;
            myPath.Data = myLineGeometry;
            RulerBoard.Children.Add(myPath);
        }
        public void ClearAll()
        {
            init();
            RulerBoard.Children.Clear();
        }

        public void AddNewArea()
        {
            PointListTemp.Clear();
            //AreaTempCount++;
        }
    }
}

本文链接

博客园_badnewfish

买了 诺基亚800c 之痛 充电时 无法呼通电话 漏接电话

三星s239手机与计算机同步_计算机通过手机上3G

慎用匿名委托 Dispatcher.BeginInvoke导致UI卡死之发现

BeginInvoke更新界面 UI死掉 WPF

未处理 System.Reflection.TargetInvocationException Message=调用的目标发生了异常。

屏幕坐标系中 已知两点坐标，第三点在两点的连线内 且已知第三点到两点中任意一点的距离 求第三点的坐标

WPF学习笔记--向界面动态添加控件或者usercontrol

附加数据库失败，操作系统错误 5:"5(拒绝访问。)"的解决办法

事件和委托在通信编程中的应用

WPF学习笔记--运行时画图的实现

买了诺基亚800c 之痛充电时无法呼通电话漏接电话

屏幕坐标系中已知两点坐标，第三点在两点的连线内且已知第三点到两点中任意一点的距离求第三点的坐标