OnLButtonDown怎么条用

`OnLButtonDown` 是Windows应用程序框架（如MFC或WinAPI）中用于处理鼠标左键单击事件的回调函数。当你在编程中需要捕获并且响应鼠标左键按下时，这个消息函数就非常有用。它通常在窗口类（CWnd-derived class）的`afx_msg`宏定义中声明，并且可以在`.cpp`文件中进行重载以提供具体的处理逻辑。

以下是使用MFC的一般步骤：

1. **声明函数**:

   afx_msg void OnLButtonDown(UINT nFlags, CPoint point);

这里的 `nFlags` 参数包含了关于按键状态的信息，`point` 参数表示鼠标的点击位置。

2. **重载函数**:

   void CYourClass::OnLButtonDown(UINT nFlags, CPoint point) {
      if (IsChild(m_yourButtonControl)) { // 检查鼠标点击的是不是你的按钮控件
         // 在这里处理按钮左键单击的具体动作
         DoSomething();
      }
      CDialog::OnLButtonDown(nFlags, point); // 调用基类处理，防止默认行为丢失
   }

3. **连接消息**:
在资源编辑器中或者代码中，你需要将`WM_LBUTTONDOWN`消息映射到你的窗口类，并将其关联到`OnLButtonDown`函数。

相关问题

vc实现b样条曲线鼠标交互的代码

这里提供一个简单的B样条曲线鼠标交互的VC++代码，仅供参考：

#include <afxwin.h>
#include <afxext.h>
#include <math.h>

#define MAX_DEGREE 20
#define MAX_KNOTS 200
#define MAX_POINTS 200

// 定义控制点结构体
struct ControlPoint
{
    double x, y;
};

// 定义B样条曲线类
class BSplineCurve
{
public:
    BSplineCurve(int k, int n, int m, double* knots, ControlPoint* control_points);

    // 插值函数
    double Interpolate(double u);

    // 绘制函数
    void Draw(CDC& dc, CRect rect);

    // 鼠标事件处理函数
    void OnMouseMove(CPoint point);
    void OnLButtonDown(CPoint point);
    void OnLButtonUp(CPoint point);

private:
    int k; // B样条曲线次数
    int n; // 控制点个数
    int m; // 节点个数
    double* knots; // 节点数组
    ControlPoint* control_points; // 控制点数组
    double* coef; // 系数数组

    // 计算系数
    void CalcCoef();
};

BSplineCurve::BSplineCurve(int k, int n, int m, double* knots, ControlPoint* control_points)
{
    this->k = k;
    this->n = n;
    this->m = m;

    // 分配存储空间
    this->knots = new double[m];
    this->control_points = new ControlPoint[n];
    this->coef = new double[n];

    // 复制数组
    memcpy(this->knots, knots, m * sizeof(double));
    memcpy(this->control_points, control_points, n * sizeof(ControlPoint));

    // 计算系数
    CalcCoef();
}

double BSplineCurve::Interpolate(double u)
{
    // 查找u所在的区间
    int i;
    for (i = k - 1; i < m - k; i++)
    {
        if (u >= knots[i] && u < knots[i + 1])
            break;
    }

    // 计算基函数值
    double* N = new double[n];
    for (int j = 0; j < n; j++)
        N[j] = 0;

    N[i] = 1;
    for (int d = 1; d <= k; d++)
    {
        for (int j = i - d + 1; j <= i; j++)
        {
            double alpha = (u - knots[j]) / (knots[j + d] - knots[j]);
            double beta = 1 - alpha;

            double N1 = N[j];
            double N2 = (j + 1 <= i + k - d) ? N[j + 1] : 0;

            N[j] = beta * N1 + alpha * N2;
        }
    }

    // 计算插值结果
    double result = 0;
    for (int j = 0; j < n; j++)
        result += coef[j] * N[j];

    delete[] N;

    return result;
}

void BSplineCurve::Draw(CDC& dc, CRect rect)
{
    CPen pen(PS_SOLID, 1, RGB(0, 0, 0));
    dc.SelectObject(&pen);

    double step = (knots[m - 1] - knots[k - 1]) / rect.Width();
    double u = knots[k - 1];

    while (u <= knots[m - k])
    {
        double x = u;
        double y = Interpolate(u);

        int ix = (int)((x - knots[k - 1]) / step);
        int iy = (int)((y - knots[k - 1]) / step);

        dc.SetPixel(ix, iy, RGB(255, 0, 0));

        u += step;
    }

    for (int i = 0; i < n; i++)
    {
        int ix = (int)((control_points[i].x - knots[k - 1]) / step);
        int iy = (int)((control_points[i].y - knots[k - 1]) / step);

        dc.SetPixel(ix, iy, RGB(0, 0, 255));
    }
}

void BSplineCurve::OnMouseMove(CPoint point)
{
    control_points[n - 1].x = (double)point.x;
    control_points[n - 1].y = (double)point.y;

    CalcCoef();
}

void BSplineCurve::OnLButtonDown(CPoint point)
{
    if (n < MAX_POINTS)
    {
        control_points[n].x = (double)point.x;
        control_points[n].y = (double)point.y;

        n++;

        CalcCoef();
    }
}

void BSplineCurve::OnLButtonUp(CPoint point)
{
}

void BSplineCurve::CalcCoef()
{
    // 初始化系数数组
    for (int i = 0; i < n; i++)
        coef[i] = 0;

    // 计算系数
    for (int i = 0; i < n; i++)
    {
        double* N = new double[m];
        for (int j = 0; j < m; j++)
            N[j] = 0;

        N[knots[i] <= knots[m - k] ? m - 1 : k - 1] = 1;
        for (int d = 1; d <= k; d++)
        {
            for (int j = m - k + d - 1; j >= k - d; j--)
            {
                double alpha = (knots[j + k - d] - knots[i]) / (knots[j + k - d] - knots[j]);
                double beta = 1 - alpha;

                double N1 = N[j + 1];
                double N2 = (j + k <= m - 1) ? N[j] : 0;

                N[j] = alpha * N1 + beta * N2;
            }
        }

        // 累加系数
        for (int j = 0; j < n; j++)
        {
            coef[j] += N[j] * control_points[i].y;
        }

        delete[] N;
    }
}

// 定义主窗口类
class CMainFrame : public CFrameWnd
{
public:
    CMainFrame();

protected:
    afx_msg void OnPaint();
    afx_msg void OnMouseMove(UINT nFlags, CPoint point);
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
    DECLARE_MESSAGE_MAP()

private:
    BSplineCurve* curve;
};

CMainFrame::CMainFrame()
{
    Create(NULL, _T("B-Spline Curve"), WS_OVERLAPPEDWINDOW, CRect(0, 0, 640, 480));

    // 初始化控制点数组
    ControlPoint* control_points = new ControlPoint[MAX_POINTS];
    control_points[0].x = 100;
    control_points[0].y = 200;
    control_points[1].x = 200;
    control_points[1].y = 300;
    control_points[2].x = 300;
    control_points[2].y = 200;

    // 初始化节点数组
    int k = 3;
    int n = 3;
    int m = n + k;
    double* knots = new double[m];
    knots[0] = knots[1] = knots[2] = 0;
    knots[3] = knots[4] = knots[5] = 1;

    curve = new BSplineCurve(k, n, m, knots, control_points);
}

void CMainFrame::OnPaint()
{
    CPaintDC dc(this);
    CRect rect;
    GetClientRect(&rect);

    curve->Draw(dc, rect);
}

void CMainFrame::OnMouseMove(UINT nFlags, CPoint point)
{
    curve->OnMouseMove(point);
    Invalidate();
}

void CMainFrame::OnLButtonDown(UINT nFlags, CPoint point)
{
    curve->OnLButtonDown(point);
    Invalidate();
}

void CMainFrame::OnLButtonUp(UINT nFlags, CPoint point)
{
    curve->OnLButtonUp(point);
    Invalidate();
}

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
    ON_WM_PAINT()
    ON_WM_MOUSEMOVE()
    ON_WM_LBUTTONDOWN()
    ON_WM_LBUTTONUP()
END_MESSAGE_MAP()

// 定义应用程序类
class CMyApp : public CWinApp
{
public:
    virtual BOOL InitInstance();
};

BOOL CMyApp::InitInstance()
{
    CMainFrame* frame = new CMainFrame();
    m_pMainWnd = frame;
    frame->ShowWindow(SW_SHOW);
    frame->UpdateWindow();

    return TRUE;
}

CMyApp myApp;

在这个例子中，我们使用了MFC框架，自定义了一个B-Spline Curve类，实现了插值和鼠标交互功能，并在主窗口类中调用该类的方法进行绘制和事件处理。

使用VC++6.0用鼠标左键确定四个控制点，画出控制线，然后鼠标右键分别绘制三次Bezier曲线和三次B样条曲线。

以下是使用MFC和VC++6.0实现的代码：

#include "stdafx.h"
#include "BezierBsplines.h"
#include "math.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define MAX_CONTROL_POINTS 4
#define MAX_CURVE_POINTS 200
#define BEZIER_CURVE 0
#define BSPLINE_CURVE 1

/////////////////////////////////////////////////////////////////////////////
// CBezierBsplinesApp

BEGIN_MESSAGE_MAP(CBezierBsplinesApp, CWinApp)
    //{{AFX_MSG_MAP(CBezierBsplinesApp)
    // NOTE - the ClassWizard will add and remove mapping macros here.
    //    DO NOT EDIT what you see in these blocks of generated code !
    ON_COMMAND(ID_HELP, CWinApp::OnHelp)
    ON_WM_LBUTTONDOWN()
    ON_WM_RBUTTONDOWN()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBezierBsplinesApp construction

CBezierBsplinesApp::CBezierBsplinesApp()
{
    // TODO: add construction code here,
    // Place all significant initialization in InitInstance
}

/////////////////////////////////////////////////////////////////////////////
// The one and only CBezierBsplinesApp object

CBezierBsplinesApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CBezierBsplinesApp initialization

BOOL CBezierBsplinesApp::InitInstance()
{
    // Standard initialization
    // If you are not using these features and wish to reduce the size
    //  of your final executable, you should remove from the following
    //  the specific initialization routines you do not need.

#ifdef _AFXDLL
    Enable3dControls();			// Call this when using MFC in a shared DLL
#else
    Enable3dControlsStatic();	// Call this when linking to MFC statically
#endif

    CBezierBsplinesDlg dlg;
    m_pMainWnd = &dlg;
    int nResponse = dlg.DoModal();
    if (nResponse == IDOK)
    {
        // TODO: Place code here to handle when the dialog is
        //  dismissed with OK
    }
    else if (nResponse == IDCANCEL)
    {
        // TODO: Place code here to handle when the dialog is
        //  dismissed with Cancel
    }

    // Since the dialog has been closed, return FALSE so that we exit the
    //  application, rather than start the application's message pump.
    return FALSE;
}

void CBezierBsplinesApp::OnLButtonDown(UINT nFlags, CPoint point) 
{
    // TODO: Add your message handler code here and/or call default
    static int curPoint = 0;
    if (curPoint < MAX_CONTROL_POINTS)
    {
        m_controlPoints[curPoint++] = point;
        DrawControlPoints();
    }
    CWinApp::OnLButtonDown(nFlags, point);
}

void CBezierBsplinesApp::DrawControlPoints()
{
    // Draw all control points
    CClientDC dc(m_pMainWnd);
    CBrush brush;
    brush.CreateSolidBrush(RGB(0, 0, 255));
    CBrush* pOldBrush = dc.SelectObject(&brush);
    for (int i = 0; i < MAX_CONTROL_POINTS; i++)
    {
        dc.Ellipse(m_controlPoints[i].x - 2, m_controlPoints[i].y - 2, m_controlPoints[i].x + 2, m_controlPoints[i].y + 2);
    }
    dc.SelectObject(pOldBrush);

    // Draw control lines
    CPen pen;
    pen.CreatePen(PS_SOLID, 1, RGB(0, 255, 0));
    CPen* pOldPen = dc.SelectObject(&pen);
    dc.MoveTo(m_controlPoints[0]);
    for (int i = 1; i < MAX_CONTROL_POINTS; i++)
    {
        dc.LineTo(m_controlPoints[i]);
    }
    dc.SelectObject(pOldPen);
}

void CBezierBsplinesApp::OnRButtonDown(UINT nFlags, CPoint point) 
{
    // TODO: Add your message handler code here and/or call default
    static int curveType = BEZIER_CURVE;
    if (curveType == BEZIER_CURVE)
    {
        DrawBezierCurve();
    }
    else if (curveType == BSPLINE_CURVE)
    {
        DrawBSplineCurve();
    }
    curveType = (curveType + 1) % 2;
    CWinApp::OnRButtonDown(nFlags, point);
}

void CBezierBsplinesApp::DrawBezierCurve()
{
    // Draw Bezier curve
    CClientDC dc(m_pMainWnd);
    CPen pen;
    pen.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
    CPen* pOldPen = dc.SelectObject(&pen);
    for (int i = 0; i < MAX_CURVE_POINTS; i++)
    {
        double t = (double)i / (MAX_CURVE_POINTS - 1);
        CPoint pt = CalculateBezierPoint(t);
        if (i == 0)
        {
            dc.MoveTo(pt);
        }
        else
        {
            dc.LineTo(pt);
        }
    }
    dc.SelectObject(pOldPen);
}

void CBezierBsplinesApp::DrawBSplineCurve()
{
    // Draw B-spline curve
    CClientDC dc(m_pMainWnd);
    CPen pen;
    pen.CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
    CPen* pOldPen = dc.SelectObject(&pen);
    for (int i = 0; i < MAX_CURVE_POINTS; i++)
    {
        double t = (double)i / (MAX_CURVE_POINTS - 1);
        CPoint pt = CalculateBSplinePoint(t);
        if (i == 0)
        {
            dc.MoveTo(pt);
        }
        else
        {
            dc.LineTo(pt);
        }
    }
    dc.SelectObject(pOldPen);
}

CPoint CBezierBsplinesApp::CalculateBezierPoint(double t)
{
    // Calculate Bezier point
    CPoint pt;
    pt.x = (int)(pow(1 - t, 3) * m_controlPoints[0].x +
                 3 * t * pow(1 - t, 2) * m_controlPoints[1].x +
                 3 * pow(t, 2) * (1 - t) * m_controlPoints[2].x +
                 pow(t, 3) * m_controlPoints[3].x);
    pt.y = (int)(pow(1 - t, 3) * m_controlPoints[0].y +
                 3 * t * pow(1 - t, 2) * m_controlPoints[1].y +
                 3 * pow(t, 2) * (1 - t) * m_controlPoints[2].y +
                 pow(t, 3) * m_controlPoints[3].y);
    return pt;
}

CPoint CBezierBsplinesApp::CalculateBSplinePoint(double t)
{
    // Calculate B-spline point
    CPoint pt;
    double b0 = pow(1 - t, 3) / 6;
    double b1 = (3 * pow(t, 3) - 6 * pow(t, 2) + 4) / 6;
    double b2 = (-3 * pow(t, 3) + 3 * pow(t, 2) + 3 * t + 1) / 6;
    double b3 = pow(t, 3) / 6;
    pt.x = (int)(b0 * m_controlPoints[0].x +
                 b1 * m_controlPoints[1].x +
                 b2 * m_controlPoints[2].x +
                 b3 * m_controlPoints[3].x);
    pt.y = (int)(b0 * m_controlPoints[0].y +
                 b1 * m_controlPoints[1].y +
                 b2 * m_controlPoints[2].y +
                 b3 * m_controlPoints[3].y);
    return pt;
}

这里的`CBezierBsplinesDlg`是使用MFC的对话框类，可以使用Visual Studio创建。

在对话框类的`OnInitDialog()`函数中，我们可以添加以下代码：

// Initialize control points
m_controlPoints[0] = CPoint(100, 100);
m_controlPoints[1] = CPoint(150, 200);
m_controlPoints[2] = CPoint(250, 200);
m_controlPoints[3] = CPoint(300, 100);

// Draw control points
DrawControlPoints();

这里我们初始化了四个控制点，并且调用`DrawControlPoints()`函数绘制控制点和控制线。

在`OnLButtonDown()`函数中，我们处理鼠标左键按下事件，如果当前控制点数量小于4，则将当前鼠标位置作为一个新的控制点，并调用`DrawControlPoints()`函数重新绘制控制点和控制线。

在`OnRButtonDown()`函数中，我们处理鼠标右键按下事件，根据当前曲线类型（Bezier曲线或B样条曲线），调用对应的函数`DrawBezierCurve()`或`DrawBSplineCurve()`绘制曲线，并将曲线类型切换为下一个类型。

在`DrawBezierCurve()`和`DrawBSplineCurve()`函数中，我们分别使用`CalculateBezierPoint()`和`CalculateBSplinePoint()`函数计算曲线上的点，并使用`CClientDC`和`CPen`绘制曲线。

在`CalculateBezierPoint()`函数中，我们使用Bezier曲线的公式计算曲线上的点。

在`CalculateBSplinePoint()`函数中，我们使用B样条曲线的公式计算曲线上的点。

最后，我们在`CBezierBsplinesApp`类中定义了`m_controlPoints`数组存储四个控制点，在`DrawControlPoints()`函数中绘制控制点和控制线，在`CalculateBezierPoint()`函数和`CalculateBSplinePoint()`函数中计算曲线上的点。