Cangjie-Examples中的CFFI与Windows GUI编程

Cangjie-Examples中的CFFI与Windows GUI编程【免费下载链接】Cangjie-Examples本仓将收集和展示高质量的仓颉示例代码，欢迎大家投稿，让全世界看到您的妙趣设计，也让更多人通过您的编码理解和喜爱仓颉语言。...

施京柱Belle

1200人浏览 · 2025-08-11 18:15:02

施京柱Belle · 2025-08-11 18:15:02 发布

Cangjie-Examples中的CFFI与Windows GUI编程

【免费下载链接】Cangjie-Examples 本仓将收集和展示高质量的仓颉示例代码，欢迎大家投稿，让全世界看到您的妙趣设计，也让更多人通过您的编码理解和喜爱仓颉语言。项目地址: https://gitcode.com/Cangjie/Cangjie-Examples

仓颉语言通过CFFI（C Foreign Function Interface）提供了与C语言的无缝互操作能力，使得开发者可以轻松调用C库函数，尤其是在Windows GUI编程中。本节将详细介绍CFFI在仓颉语言中的具体应用，包括类型映射、函数声明、结构体操作以及实际案例演示。

CFFI在仓颉语言中的应用

类型映射与函数声明

仓颉语言通过@C注解和foreign func关键字实现了与C语言的类型映射和函数声明。以下是一个典型的C函数声明示例：

@C
struct WNDCLASSEX {
    public WNDCLASSEX(
        let cbSize!: UInt32 = UInt32(sizeOf<WNDCLASSEX>()),
        let style!: UInt32 = CS_HREDRAW | CS_VREDRAW,
        let lpfnWndProc!: WindowProc = DefWindowProcA,
        // 其他字段...
    ) {}
}

foreign func CreateWindowExA(
    dwExStyle: UInt32,
    lpClassName: CString,
    lpWindowName: CString,
    dwStyle: UInt32,
    x: UInt32, y: UInt32,
    nWidth: UInt32, nHeight: UInt32,
    hWndParent: Handle,
    hMenu: Handle,
    hInstance: Handle,
    lpParam: Handle
): Handle

类型映射：仓颉语言支持C的基础数据类型（如UInt32、Int32）和指针类型（如Handle、CString）。
函数声明：通过foreign func声明C函数，参数和返回值类型需与C函数一致。

结构体操作

仓颉语言可以定义和操作C结构体，例如WNDCLASSEX和MSG：

@C
struct MSG {
    public MSG(
        let hWnd!: Handle = NULL,
        let message!: UInt32 = 0,
        let wParam!: UInt16 = 0,
        let lParam!: UInt32 = 0,
        // 其他字段...
    ) {}
}

结构体定义：使用@C注解标记结构体，字段类型需与C结构体一致。
默认值：可以为字段设置默认值，如NULL或0。

实际案例：绘制分形树

以下是一个调用Windows API绘制分形树的示例代码：

// 创建窗口
let hWnd = CreateWindowExA(
    0,
    "MyWindowClass",
    "Fractal Tree",
    WS_OVERLAPPEDWINDOW,
    100, 100, 800, 600,
    NULL, NULL, hInstance, NULL
)

// 显示窗口
ShowWindow(hWnd, SW_SHOW)
UpdateWindow(hWnd)

// 消息循环
let msg = MSG()
while (GetMessageA(&msg, NULL, 0, 0)) {
    TranslateMessage(&msg)
    DispatchMessageA(&msg)
}

流程图：CFFI调用流程

mermaid

表格：常用Windows API与仓颉映射

Windows API	仓颉声明	描述
`CreateWindowExA`	`foreign func CreateWindowExA(...)`	创建窗口
`ShowWindow`	`foreign func ShowWindow(...)`	显示窗口
`GetMessageA`	`foreign func GetMessageA(...)`	获取消息
`DefWindowProcA`	`foreign func DefWindowProcA(...)`	默认窗口消息处理

通过CFFI，仓颉语言可以高效地与C语言交互，为Windows GUI编程提供了强大的支持。

Windows GUI编程的核心流程

Windows GUI编程的核心流程涉及窗口的创建、消息循环的处理以及绘图功能的实现。以下是一个典型的流程，结合仓颉语言与Windows API的交互：

1. 窗口类的注册与创建

首先，需要定义并注册一个窗口类，这是创建窗口的基础。窗口类定义了窗口的行为和外观属性。

mermaid

示例代码：

var windowClass = WNDCLASSEX(
    lpszClassName: className,
    lpfnWndProc: onMessage,  // 消息处理回调
    hInstance: GetModuleHandleA(null),
    hbrBackground: CreateSolidBrush(0xFFFFFF),
    hCursor: LoadCursorA(null, IDC_ARROW)
);
if (RegisterClassExA(inout windowClass) == 0) {
    // 注册失败处理
}
let window = CreateWindowExA(
    0,                          // 扩展样式
    className,                  // 窗口类名
    "Cangjie Window",           // 窗口标题
    WS_OVERLAPPEDWINDOW,        // 窗口样式
    CW_USEDEFAULT,              // 初始X位置
    CW_USEDEFAULT,              // 初始Y位置
    800,                        // 宽度
    600,                        // 高度
    null,                       // 父窗口句柄
    null,                       // 菜单句柄
    GetModuleHandleA(null),     // 实例句柄
    null                        // 附加数据
);

2. 消息循环

窗口创建后，需要进入消息循环以处理用户输入和系统事件。消息循环的核心是GetMessageA、TranslateMessage和DispatchMessageA。

mermaid

示例代码：

var msg = MSG();
while (GetMessageA(inout msg, null, 0, 0)) {
    TranslateMessage(inout msg);
    DispatchMessageA(inout msg);
}

3. 窗口过程

窗口过程是处理所有窗口消息的函数，包括绘制、鼠标事件、键盘事件等。

mermaid

示例代码：

func onMessage(hWnd: Handle, msg: UInt32, wParam: UInt64, lParam: UInt64): UInt64 {
    match msg {
        WM_PAINT => {
            var ps = PAINTSTRUCT();
            let hdc = BeginPaint(hWnd, inout ps);
            // 绘制逻辑
            EndPaint(hWnd, inout ps);
        }
        WM_DESTROY => PostQuitMessage(0);
        _ => return DefWindowProcA(hWnd, msg, wParam, lParam);
    }
    return 0;
}

4. 绘图功能

通过Windows GDI函数实现绘图功能，例如绘制分形树。

mermaid

示例代码：

func drawTree(hdc: Handle, x: Int32, y: Int32, angle: Double, depth: Int32) {
    if (depth <= 0) return;
    let newX = x + (cos(angle) * depth * 10).toInt32();
    let newY = y + (sin(angle) * depth * 10).toInt32();
    MoveToEx(hdc, x, y, null);
    LineTo(hdc, newX, newY);
    drawTree(hdc, newX, newY, angle - PI / 4, depth - 1);
    drawTree(hdc, newX, newY, angle + PI / 4, depth - 1);
}

5. 资源释放

在程序结束时，需要释放所有分配的资源，例如窗口句柄和内存。

示例代码：

DestroyWindow(window);

通过以上步骤，可以完成一个完整的Windows GUI程序的核心流程。仓颉语言的CFFI特性使得与Windows API的交互变得简单而高效。

分形树的绘制与交互实现

分形树是一种具有自相似性质的几何图形，常用于展示递归和分形算法的魅力。在仓颉语言的CFFI-Windows示例中，我们通过调用Windows系统的图形API，实现了分形树的绘制和交互功能。本节将详细介绍其实现原理和代码逻辑。

分形树的生成算法

分形树的生成基于迭代函数系统（IFS），通过一组仿射变换的随机组合，逐步生成分形树的点集。以下是核心代码片段：

func fractal(count: UInt64, scale: F): ArrayList<(F, F)> {
    let affines = [
        // p, a, b, c, d, e, f
        (0.25, -0.04, 0.0, -0.19, -0.47, -0.12, 0.3),
        (0.25, 0.65, 0.0, 0.0, 0.58, 0.02, 1.5),
        (0.25, 0.41, 0.46, -0.39, 0.61, 0.46, 0.4),
        (0.25, 0.52, -0.35, 0.25, 0.74, -0.48, 0.38)
    ]

    var x = 0.0
    var y = 0.0
    let random = Random()
    let result = ArrayList<(F, F)>()
    for (_ in 0..count) {
        result.add((scale * x, scale * y))
        var acc = 0.0
        let dice = random.nextFloat64()
        for ((p, a, b, c, d, e, f) in affines) {
            acc += p
            if (dice < acc) {
                (x, y) = (a * x + b * y + e, c * x + d * y + f)
                break
            }
        }
    }
    return result
}

算法解析

仿射变换组：定义了4组仿射变换参数，每组包含概率p和变换矩阵(a, b, c, d, e, f)。
随机选择：通过随机数dice选择当前迭代使用的变换组。
迭代生成：每次迭代根据选定的变换组更新坐标(x, y)，并将结果缩放后存入列表。

分形树的绘制

生成分形树的点集后，通过Windows的GDI（图形设备接口）API绘制到窗口上。以下是绘制逻辑的流程图：

mermaid

关键代码

let points = fractal(100000, 80.0) // 生成10万个点
for ((x, y) in points) {
    SetPixel(hdc, x + 400, 600 - y, RGB(0, 255, 0)) // 绘制绿色点
}

交互功能的实现

通过注册窗口消息回调函数，实现了以下交互功能：

重绘：点击窗口时触发WM_PAINT消息，重新生成并绘制分形树。
缩放：通过调整scale参数控制分形树的大小。

消息处理逻辑

mermaid

总结

通过仓颉的CFFI能力，我们成功调用了Windows的图形API，实现了分形树的生成、绘制和交互功能。这一过程不仅展示了分形算法的魅力，也体现了仓颉语言在系统编程中的强大能力。

代码示例与解析

1. 分形树的生成与绘制

以下代码展示了如何使用仓颉语言生成分形树的坐标点，并通过 Windows API 绘制到窗口上。代码分为两部分：分形树的生成逻辑和窗口绘制逻辑。

分形树生成逻辑

package windows
import std.random.Random
import std.collection.ArrayList

type F = Float64
func fractal(count: UInt64, scale: F): ArrayList<(F, F)> {
    let affines = [
        // p, a, b, c, d, e, f
        (0.25, -0.04, 0.0, -0.19, -0.47, -0.12, 0.3),
        (0.25, 0.65, 0.0, 0.0, 0.58, 0.02, 1.5),
        (0.25, 0.41, 0.46, -0.39, 0.61, 0.46, 0.4),
        (0.25, 0.52, -0.35, 0.25, 0.74, -0.48, 0.38)
    ]

    var x = 0.0
    var y = 0.0
    let random = Random()
    let result = ArrayList<(F, F)>()
    for (_ in 0..count) {
        result.add((scale * x, scale * y))
        var acc = 0.0
        let dice = random.nextFloat64()
        for ((p, a, b, c, d, e, f) in affines) {
            acc += p
            if (dice < acc) {
                (x, y) = (a * x + b * y + e, c * x + d * y + f)
                break
            }
        }
    }
    return result
}

解析：

affines 数组：定义了分形树的仿射变换参数，每个元组包含概率 p 和变换参数 a 到 f。
随机迭代：通过随机数 dice 选择仿射变换，生成分形树的坐标点。
结果存储：生成的坐标点存储在 ArrayList 中，并返回。

窗口绘制逻辑

let points = fractal(100000, 80.0) // 分形树坐标数组
unsafe func process(hWnd: Handle, msg: UInt32,
        wParam: UInt64, lParam: UInt64) {
    var result = 0
    if (msg == WM_PAINT) {
        paint(hWnd) { hDC =>
            var rect = RECT()
            GetClientRect(hWnd, inout rect)
            let (width, height) = (rect.right, rect.bottom)
            for ((x, y) in points) {
                let u = Int32(x) + width / 2
                let v = height - Int32(y) - 50
                SetPixel(hDC, u, v, 0x559690)
            }
        }
    } else if (msg == WM_KEYDOWN && wParam == UInt64(VK_ESCAPE)) {
        DestroyWindow(hWnd)
    } else if (msg == WM_DESTROY) {
        PostQuitMessage(0)
    } else {
        result = DefWindowProcA(hWnd, msg, wParam, lParam)
    }
    return result
}

解析：

WM_PAINT 消息处理：当窗口需要重绘时，调用 paint 函数绘制分形树。
坐标转换：将分形树的坐标点转换为窗口坐标，并通过 SetPixel 绘制到窗口上。
键盘和关闭事件：处理 ESC 键和窗口关闭事件。

2. Windows API 的封装与调用

以下代码展示了如何封装 Windows API 并在仓颉中调用：

@C
struct WNDCLASSEX {
    public WNDCLASSEX(
        let cbSize!: UInt32 = UInt32(sizeOf<WNDCLASSEX>()),
        let style!: UInt32 = CS_HREDRAW | CS_VREDRAW,
        let lpfnWndProc!: WindowProc = DefWindowProcA,
        let cbClsExtra!: Int32 = 0,
        let cbWndExtra!: Int32 = 0,
        let hInstance!: Handle = NULL,
        let hIcon!: Handle = NULL,
        let hCursor!: Handle = NULL,
        let hbrBackground!: Handle = NULL,
        let lpszMenuName!: CString = EMPTY_STRING,
        let lpszClassName!: CString = EMPTY_STRING,
        let hIconSm!: Handle = NULL
    ) {}
}

foreign func CreateWindowExA(
    dwExStyle: UInt32,
    lpClassName: CString,
    lpWindowName: CString,
    dwStyle: UInt32,
    x: UInt32, y: UInt32,
    nWidth: UInt32, nHeight: UInt32,
    hWndParent: Handle,
    hMenu: Handle,
    hInstance: Handle,
    lpParam: Handle
): Handle

解析：