Thử lập trình XLL add-in bằng C/C++ (2 người xem)

#include "XLCALL.H"
#include "FRAMEWRK.H"
#include "stdlib.h"
#include "string"
#include "Windows.h"

DWORD tlsIndex; //Khai báo một biến DWORD để lưu trữ chỉ số của Thread-local Storage mà các thread có thể sử dụng để lưu trữ dữ liệu cục bộ cho mỗi thread

//Khai báo struct để lưu trữ dữ liệu cục bộ cho mỗi thread
struct TlsData {
    XLOPER12 data;
};

//Hàm này trả về struct từ Thread-local Storage mà thread hiện tại đang sử dụng
TlsData* GetTlsData() {
    if (!tlsIndex) return NULL;
    TlsData* tlsData = reinterpret_cast<TlsData*>(TlsGetValue(tlsIndex));
    return tlsData;
}

//Khởi tạo Thread-local Storage
BOOL InitializeTls(DWORD DllMainCallReason) {
    switch (DllMainCallReason) {
    case DLL_PROCESS_ATTACH:
        if ((tlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES)
            return FALSE;
    case DLL_PROCESS_DETACH:
        if (tlsIndex) {
            TlsFree(tlsIndex);
            break;
        }
    }
    return TRUE;
}

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    //Khởi tạo Thread-local Storage
    return InitializeTls(ul_reason_for_call);
}

//Hàm này chuyển chuỗi ký tự wide char sang định dạng mà Excel yêu cầu
wchar_t *CreateCountedUnicodeWcharStringFromNullTerminatedUnicodeWCharString(const wchar_t* text) {
    size_t len; //Khai báo biến chứa độ dài của chuỗi cần chuyển đổi
    if (!text || !(len = wcslen(text))) return NULL; //Nếu chuỗi rỗng thì trả về NULL
    if (len > 32767u) len = 32767u; //Nếu độ dài chuỗi lớn hơn 32767u ký tự thì cắt gọt chuỗi
    wchar_t *wstr = new wchar_t[(len + 2)]; //Cấp phát bộ nhớ động cho chuỗi kết quả, số lượng byte cần cấp phát là độ dài chuỗi cần chuyển đổi cộng thêm 2 ký tự (để dành ký tự cuối cùng làm ký tự kết thúc chuỗi) * 2 byte
    if (!wstr) return NULL; //Nếu không cấp phát được bộ nhớ thì trả về NULL
    memcpy(wstr + 1, text, (len + 1) * sizeof(wchar_t)); //Sao chép chuỗi cần chuyển đổi, bắt đầu từ ký tự thứ hai, vào chuỗi kết quả
    wstr[0] = len; //Gán độ dài chuỗi vào vị trí đầu tiên của chuỗi kết quả
    return wstr; //Trả về chuỗi kết quả
}

extern "C" __declspec(dllexport) LPXLOPER12 WINAPI PrintHello(wchar_t* name) {
    //static LPXLOPER12 result; Không an toàn thread vì biến tĩnh này có thể bị ghi đè bởi các thread khác
    TlsData* tlsData = GetTlsData(); //Thay vào đó, sử dụng Thread-local Storage API để lưu trữ dữ liệu cục bộ cho mỗi thread
    if (!tlsData) return NULL;
    LPXLOPER12 result = &(tlsData->data); //Khai báo biến con trỏ của kiểu XLOPER12 để lưu trữ kết quả trả về
    result->xltype = xltypeStr | xlbitDLLFree; //Thiết lập kiểu trả về của hàm là chuỗi, đồng thời thông báo cho Excel biết rằng Excel sẽ giải phóng bộ nhớ cho chuỗi này do nó được cấp phát động
    wchar_t wstrInput[100] = L"Hello, "; //Khai báo một mảng ký tự wide char để lưu trữ chuỗi kết quả
    wcscat_s(wstrInput, name); //Nối chuỗi name vào chuỗi wstrInput
    wchar_t* pWstrOutput = CreateCountedUnicodeWcharStringFromNullTerminatedUnicodeWCharString(wstrInput); //Chuyển chuỗi wstrInput sang định dạng mà Excel yêu cầu
    result->val.str = pWstrOutput; //Gán địa chỉ của chuỗi kết quả vào biến con trỏ result
    return result; //Trả về con trỏ result để Excel có thể sử dụng kết quả
}
//Excel gọi hàm này khi nạp add-in
extern "C" __declspec(dllexport) int WINAPI xlAutoOpen(void)
{
    XLOPER12 xDLL;
    //Xác định tên của DLL
    if (Excel12f(xlGetName, &xDLL, 0) == xlretSuccess) {
        Excel12f(xlfRegister, 0, 11, (LPXLOPER12)&xDLL, //Đăng ký tên của DLL
            (LPXLOPER12)TempStr12(L"PrintHello"), //Tên hàm
            (LPXLOPER12)TempStr12(L"UC%"), //Kiểu tham số, ký tự đầu tiên đại diện cho kiểu dữ liệu trả về của hàm, các ký tự tiếp theo là kiểu dữ liệu của các tham số
            (LPXLOPER12)TempStr12(L"PrintHello"), //Tên hàm trong trình Function Wizard
            (LPXLOPER12)TempStr12(L"name"), //Mô tả tham số trong trình Function Wizard
            (LPXLOPER12)TempStr12(L"1"), //Kiểu macro
            (LPXLOPER12)TempStr12(L"myOwnCppFunctions"), //Hạng mục
            (LPXLOPER12)TempStr12(L""), //Tổ hợp phím tắt
            (LPXLOPER12)TempStr12(L""), //Tên tập tin Help
            (LPXLOPER12)TempStr12(L"Print 'Hello <user>'"), //Mô tả hàm khi được chọn trong trình Function Wizard
            (LPXLOPER12)TempStr12(L"")); //Mô tả tham số khi được chọn trong trình Function Wizard (tối đa lên đến 255 tham số)
        //Giải phóng biến xDLL
        Excel12f(xlFree, 0, 1, (LPXLOPER12)&xDLL);
    }
    return 1;
}

//Excel gọi hàm này khi người dùng tắt Add-in hoặc thoát khỏi Excel
extern "C" __declspec(dllexport) int WINAPI xlAutoClose(void) {
    return 1;
}

//Excel gọi hàm này khi kiểu XLOPER12 trả về có chứa cờ bit xlbitDLLFree hoặc xlbitXLFree để dọn dẹp bộ nhớ
extern "C" __declspec(dllexport) void WINAPI xlAutoFree12(LPXLOPER12 p_oper) {
    //Nếu kiểu dữ liệu trả về là chuỗi
    if (p_oper->xltype & xltypeStr) {
        delete p_oper->val.str; //Giải phóng bộ nhớ đã cấp phát động cho chuỗi
    }
}

void AsyncFuncCallback(LPXLOPER12 lpHandle) {
    //Giả lập công việc tính toán mất nhiều thời gian
    Sleep(3000);
    //Chuẩn bị kết quả để trả về cho Excel
    XLOPER12 result = {};
    result.xltype = xltypeNum;
    result.val.num = 10;
    //Trả kết quả về cho Excel
    Excel12f(xlAsyncReturn, NULL, 2, lpHandle, &result);
}

DWORD WINAPI AsyncFuncCallbackProc(LPVOID lpParam) {
    //Kiểm tra điều kiện đầu vào
    if (!lpParam) return 1;
    LPXLOPER12 pHandle = (LPXLOPER12)lpParam;
    //Gọi hàm tính toán
    AsyncFuncCallback(pHandle);
    return 0;
}

extern "C" __declspec(dllexport) void WINAPI AsyncFunc(LPXLOPER12 lpHandle) {
    //Kiểm tra điều kiện đầu vào
    if (!lpHandle) return;
    //Tạo thread để tính toán
    HANDLE hThread = CreateThread(NULL, 0, AsyncFuncCallbackProc, lpHandle, 0, NULL);
    if (!hThread) return;
}

extern "C" __declspec(dllexport) int WINAPI xlAutoOpen()
{
    XLOPER12 xlDllName;
    //Xác định tên của DLL
    if (Excel12f(xlGetName, &xlDllName, 0) == xlretSuccess) {
        //Đăng ký hàm với Excel
        Excel12f(xlfRegister, NULL, 10, (LPXLOPER12)&xlDllName, //Đăng ký tên của DLL
            (LPXLOPER12)TempStr12(L"AsyncFunc"), //Tên hàm
            (LPXLOPER12)TempStr12(L">X"), //Kiểu tham số, ký tự đầu tiên đại diện cho kiểu dữ liệu trả về của hàm, các ký tự tiếp theo là kiểu dữ liệu của các tham số
            (LPXLOPER12)TempStr12(L"AsyncFunc"), //Tên hàm trong trình Function Wizard
            (LPXLOPER12)TempStr12(L""), //Mô tả tham số trong trình Function Wizard
            (LPXLOPER12)TempStr12(L"1"), //Kiểu macro
            (LPXLOPER12)TempStr12(L"Asynchronous Functions"), //Hạng mục
            (LPXLOPER12)TempStr12(L""), //Tổ hợp phím tắt
            (LPXLOPER12)TempStr12(L""), //Tên tập tin Help
            (LPXLOPER12)TempStr12(L""));
        //Giải phóng bộ nhớ
        Excel12f(xlFree, NULL, 1, (LPXLOPER12)&xlDllName);
    }
    return 1;
}

extern "C" __declspec(dllexport) wchar_t* WINAPI PrintHelloWorld();

extern "C" __declspec(dllexport) wchar_t* WINAPI PrintHelloWorld() {
    const wchar_t szInput[] = L"Hello World";
    size_t len = wcslen(szInput);
    wchar_t* pwszResult = new wchar_t[len + 1];
    if (!pwszResult) return NULL;
    errno_t err = wcscpy_s(pwszResult, len + 1, szInput);
    if (err) {
        delete[] pwszResult;
        return NULL;
    }
    return pwszResult;
}

extern "C" __declspec(dllexport) int WINAPI xlAutoOpen() {
    XLOPER12 xlDllName;
    int iResult = Excel12(xlGetName, &xlDllName, 0);
    if (iResult == xlretFailed) return 0;
    iResult = Excel12(xlfRegister, NULL, 11,
        &xlDllName,
        TempStr12(L"PrintHelloWorld"),
        TempStr12(L"C%"),
        TempStr12(L"PrintHelloWorld"),
        TempStr12(L""),
        TempStr12(L"1"),
        TempStr12(L"UDF"),
        TempStr12(L""),
        TempStr12(L""),
        TempStr12(L"PrintHelloWorld"),
        TempStr12(L"")
    );
    Excel12(xlFree, NULL, 1, &xlDllName);
    return iResult == xlretSuccess ? 1 : 0;
}

/*
** XLOPER12 structure
**
** Excel 12's fundamental data type: can hold data
** of any type. Use "U" as the argument type in the
** REGISTER function.
**/

typedef struct xloper12
{
    union
    {
        double num;                           /* xltypeNum */
        XCHAR *str;                           /* xltypeStr */
        BOOL xbool;                           /* xltypeBool */
        int err;                           /* xltypeErr */
        int w;
        struct
        {
            WORD count;                       /* always = 1 */
            XLREF12 ref;
        } sref;                        /* xltypeSRef */
        struct
        {
            XLMREF12 *lpmref;
            IDSHEET idSheet;
        } mref;                        /* xltypeRef */
        struct
        {
            struct xloper12 *lparray;
            RW rows;
            COL columns;
        } array;                    /* xltypeMulti */
        struct
        {
            union
            {
                int level;            /* xlflowRestart */
                int tbctrl;            /* xlflowPause */
                IDSHEET idSheet;        /* xlflowGoto */
            } valflow;
            RW rw;                           /* xlflowGoto */
            COL col;                       /* xlflowGoto */
            BYTE xlflow;
        } flow;                        /* xltypeFlow */
        struct
        {
            union
            {
                BYTE *lpbData;            /* data passed to XL */
                HANDLE hdata;            /* data returned from XL */
            } h;
            long cbData;
        } bigdata;                    /* xltypeBigData */
    } val;
    DWORD xltype;
} XLOPER12, *LPXLOPER12;

static XLOPER12 xlRet;
xlRet.xltype = xltypeStr;
xlRet.val.str = pwszVal;

#define MAX_XL12_STR_LEN 32767u

wchar_t* WideCharToXl12Str(const wchar_t* lpwszInput) {
    size_t len;
    if (!lpwszInput || !(len = wcslen(lpwszInput))) return NULL;
    if (len > MAX_XL12_STR_LEN) len = MAX_XL12_STR_LEN;
    wchar_t* pwszResult = new wchar_t[len + 2];
    if (!pwszResult) return NULL;
    pwszResult[0] = (wchar_t)len;
    errno_t err = wcscpy_s(pwszResult + 1, len + 1, lpwszInput);
    if (err) {
        delete[] pwszResult;
        return NULL;
    }
    return pwszResult;
}

extern "C" __declspec(dllexport) LPXLOPER12 WINAPI PrintHelloWorld() {
    const wchar_t szInput[] = L"Hello World";
    static XLOPER12 xlRet;
    xlRet.xltype = xltypeStr | xlbitDLLFree;
    xlRet.val.str = WideCharToXl12Str(szInput);
    if (!xlRet.val.str) return NULL;
    return &xlRet;
}

extern "C" __declspec(dllexport) int WINAPI xlAutoOpen() {
    XLOPER12 xlDllName;
    int iResult = Excel12(xlGetName, &xlDllName, 0);
    if (iResult == xlretFailed) return 0;
    iResult = Excel12(xlfRegister, NULL, 11,
        &xlDllName,
        TempStr12(L"PrintHelloWorld"),
        TempStr12(L"Q"),
        TempStr12(L"PrintHelloWorld"),
        TempStr12(L""),
        TempStr12(L"1"),
        TempStr12(L"UDF"),
        TempStr12(L""),
        TempStr12(L""),
        TempStr12(L"PrintHelloWorld"),
        TempStr12(L"")
    );
    Excel12(xlFree, NULL, 1, &xlDllName);
    return iResult == xlretSuccess ? 1 : 0;
}

extern "C" __declspec(dllexport) int WINAPI xlAutoFree12(LPXLOPER12 pOper) {
    if (!pOper) return 0;
    if (pOper->xltype & (xltypeStr | xlbitDLLFree) || pOper->val.str) {
        delete[] pOper->val.str;
    }
    return 0;
}

///***************************************************************************
// File:        XLCall.pas
//
// Muc dich:    Ban dich Pascal (Delphi) day du cua XLCALL.H - header C
//              cua Microsoft Excel Developer's Toolkit (dinh nghia kieu
//              du lieu va hang so dung trong Excel C API / XLL).
//
// Ghi chu quan trong:
//              - Day la ban dich 1-1 toan bo hang so (~1094 gia tri) va
//                cau truc du lieu tu XLCALL.H goc, de dung lau dai cho
//                nhieu du an XLL viet bang Delphi.
//              - Khac voi C (header .h rieng, implementation .cpp rieng),
//                mot unit Delphi gop ca hai phan (interface = header,
//                implementation = file .cpp) trong CUNG MOT FILE. Do la
//                quy uoc chuan cua Delphi, khong phai thieu sot.
//              - Cac ham Excel4()/Excel4v()/XLCallVer()/LPenHelper() la
//                API Excel4 kieu cu (truoc Excel 2007), KHONG duoc cai
//                dat trong unit nay vi ban XLCALL.CPP goc cua du an cung
//                khong co cai dat cho chung (da bi loai bo khi vi ban
//                C++ Builder chuyen sang chi dung Excel12/XLOPER12). Neu
//                thuc su can dung API Excel4 cu, ban se can bo sung rieng.
//              - Excel12() va Excel12v() duoc cai dat day du, dich chinh
//                xac tu XLCALL.CPP, dung co che GetProcAddress giong het
//                ban C++.
//
// Nen tang:    Microsoft Windows (Win32/Win64)
//***************************************************************************

unit XLCall;

interface

uses
  Windows;

// -------------------------------------------------------------------------
// Kieu du lieu co ban XL12 (XL 12 Basic Datatypes)
// -------------------------------------------------------------------------
// Ghi chu: khong dinh nghia lai BOOL o day - don vi Windows cua Delphi da
// co san BOOL = LongBool (Longint 4 byte, 0 = False, khac 0 = True), hoan
// toan tuong thich voi "typedef INT32 BOOL" trong C.
type
  XCHAR  = WideChar;              // Wide Character (WCHAR trong C)
  PXCHAR = PWideChar;
  RW     = Integer;               // XL 12 Row  (INT32)
  COL    = Integer;               // XL 12 Column (INT32)
  IDSHEET = NativeUInt;           // XL12 Sheet ID (DWORD_PTR)

  // -----------------------------------------------------------------------
  // XLREF - Mo ta MOT tham chieu hinh chu nhat (kieu cu, truoc Excel 2007)
  // -----------------------------------------------------------------------
  PXLREF = ^TXLREF;
  LPXLREF = PXLREF;
  TXLREF = record
    rwFirst:  Word;
    rwLast:   Word;
    colFirst: Byte;
    colLast:  Byte;
  end;

  // -----------------------------------------------------------------------
  // XLMREF - Mo ta NHIEU tham chieu hinh chu nhat (kieu cu)
  // Day la cau truc kich thuoc thay doi: reftbl thuc te co "count" phan
  // tu, khong phai 1. Khi cap phat dong, cap phat them (count-1) phan tu
  // XLREF sau cau truc nay.
  // -----------------------------------------------------------------------
  PXLMREF = ^TXLMREF;
  LPXLMREF = PXLMREF;
  TXLMREF = record
    count:  Word;
    reftbl: array[0..0] of TXLREF; // thuc te la reftbl[count]
  end;

  // -----------------------------------------------------------------------
  // XLREF12 - Mo ta MOT tham chieu hinh chu nhat (Excel 2007 tro len)
  // -----------------------------------------------------------------------
  PXLREF12 = ^TXLREF12;
  LPXLREF12 = PXLREF12;
  TXLREF12 = record
    rwFirst:  RW;
    rwLast:   RW;
    colFirst: COL;
    colLast:  COL;
  end;

  // -----------------------------------------------------------------------
  // XLMREF12 - Mo ta NHIEU tham chieu hinh chu nhat (Excel 2007 tro len)
  // Cung la cau truc kich thuoc thay doi, xem ghi chu cua XLMREF o tren.
  // -----------------------------------------------------------------------
  PXLMREF12 = ^TXLMREF12;
  LPXLMREF12 = PXLMREF12;
  TXLMREF12 = record
    count:  Word;
    reftbl: array[0..0] of TXLREF12; // thuc te la reftbl[count]
  end;

  // -----------------------------------------------------------------------
  // FP / FP12 - Mang so thuc 2 chieu (kieu du lieu "P" trong REGISTER)
  // Truong "array" trong C doi ten thanh "arr" vi "array" la tu khoa cua
  // Pascal. Kich thuoc thuc te la rows * columns phan tu.
  // -----------------------------------------------------------------------
  PFP = ^TFP;
  TFP = record
    rows:    Word;
    columns: Word;
    arr:     array[0..0] of Double; // thuc te la array[rows][columns]
  end;

  PFP12 = ^TFP12;
  TFP12 = record
    rows:    Integer;
    columns: Integer;
    arr:     array[0..0] of Double; // thuc te la array[rows][columns]
  end;

  // =========================================================================
  // XLOPER (kieu cu, truoc Excel 2007) - "R" trong REGISTER
  // =========================================================================
  // Cau truc C goc:
  //   struct xloper { union { ... } val; WORD xltype; };
  //
  // Trong Pascal khong the dat mot truong binh thuong SAU phan variant
  // (case...of), nen ta tach union "val" thanh mot kieu record rieng
  // (TXLOperVal), roi dat no truoc truong xltype trong TXLOPER - dung
  // thu tu bo nho nhu ban C.
  PXLOPER = ^TXLOPER;
  LPXLOPER = PXLOPER;

  TXLOperSRef = record
    count: Word;      // luon = 1
    ref:   TXLREF;
  end;

  TXLOperMRef = record
    lpmref:  LPXLMREF;
    idSheet: IDSHEET;
  end;

  TXLOperArray = record
    lparray: LPXLOPER;
    rows:    Word;
    columns: Word;
  end;

  TXLOperFlowValflow = record
    case Integer of
      0: (level:   SmallInt);  // xlflowRestart
      1: (tbctrl:  SmallInt);  // xlflowPause
      2: (idSheet: IDSHEET);   // xlflowGoto
  end;

  TXLOperFlow = record
    valflow: TXLOperFlowValflow;
    rw:      Word;   // xlflowGoto
    col:     Byte;    // xlflowGoto
    xlflow:  Byte;
  end;

  TXLOperBigDataH = record
    case Integer of
      0: (lpbData: PByte);   // du lieu truyen vao XL
      1: (hdata:   THandle); // du lieu XL tra ve
  end;

  TXLOperBigData = record
    h:      TXLOperBigDataH;
    cbData: LongInt;
  end;

  TXLOperVal = record
    case Integer of
      0: (num:   Double);          // xltypeNum
      1: (str:   PAnsiChar);       // xltypeStr (chuoi ANSI kieu Pascal-string, byte dau la do dai)
      2: (xbool: Word);            // xltypeBool
      3: (err:   Word);            // xltypeErr
      4: (w:     SmallInt);        // xltypeInt
      5: (sref:  TXLOperSRef);     // xltypeSRef
      6: (mref:  TXLOperMRef);     // xltypeRef
      7: (arr:   TXLOperArray);    // xltypeMulti
      8: (flow:  TXLOperFlow);     // xltypeFlow
      9: (bigdata: TXLOperBigData); // xltypeBigData
  end;

  TXLOPER = record
    val:    TXLOperVal;
    xltype: Word;
  end;

  // =========================================================================
  // XLOPER12 (Excel 2007 tro len) - "U" trong REGISTER
  // =========================================================================
  // Day la kieu du lieu chinh dung trong toan bo cac ham Excel12 cua du an.
  PXLOPER12 = ^TXLOPER12;
  LPXLOPER12 = PXLOPER12;

  TXLOper12SRef = record
    count: Word;       // luon = 1
    ref:   TXLREF12;
  end;

  TXLOper12MRef = record
    lpmref:  LPXLMREF12;
    idSheet: IDSHEET;
  end;

  TXLOper12Array = record
    lparray: LPXLOPER12;
    rows:    RW;
    columns: COL;
  end;

  TXLOper12FlowValflow = record
    case Integer of
      0: (level:   Integer);  // xlflowRestart
      1: (tbctrl:  Integer);  // xlflowPause
      2: (idSheet: IDSHEET);  // xlflowGoto
  end;

  TXLOper12Flow = record
    valflow: TXLOper12FlowValflow;
    rw:      RW;    // xlflowGoto
    col:     COL;   // xlflowGoto
    xlflow:  Byte;
  end;

  TXLOper12BigDataH = record
    case Integer of
      0: (lpbData: PByte);   // du lieu truyen vao XL
      1: (hdata:   THandle); // du lieu XL tra ve
  end;

  TXLOper12BigData = record
    h:      TXLOper12BigDataH;
    cbData: LongInt;
  end;

  TXLOper12Val = record
    case Integer of
      0: (num:     Double);         // xltypeNum
      1: (str:     PWideChar);      // xltypeStr (chuoi Unicode kieu Pascal-string, ky tu dau la do dai)
      2: (xbool:   BOOL);           // xltypeBool
      3: (err:     Integer);        // xltypeErr
      4: (w:       Integer);        // xltypeInt
      5: (sref:    TXLOper12SRef);  // xltypeSRef
      6: (mref:    TXLOper12MRef);  // xltypeRef
      7: (arr:     TXLOper12Array); // xltypeMulti
      8: (flow:    TXLOper12Flow);  // xltypeFlow
      9: (bigdata: TXLOper12BigData); // xltypeBigData
  end;

  TXLOPER12 = record
    val:    TXLOper12Val;
    xltype: DWORD;
  end;

  // -----------------------------------------------------------------------
  // FMLAINFO / MOUSEINFO - dung voi LPenHelper (API cu, xem ghi chu cuoi
  // file). Dich day du de tuong thich kieu du lieu, du hien khong co ham
  // nao trong unit nay su dung truc tiep.
  // -----------------------------------------------------------------------
  PFmlaInfo = ^TFmlaInfo;
  TFmlaInfo = record
    wPointMode: Integer;  // che do soan thao hien tai. 0 => phan con lai chua xac dinh
    cch:        Integer;  // so ky tu trong cong thuc
    lpch:       PAnsiChar; // con tro toi ky tu cong thuc. CHI DOC!!!
    ichFirst:   Integer;  // vi tri bat dau vung chon
    ichLast:    Integer;  // vi tri ket thuc vung chon (co the > cch)
    ichCaret:   Integer;  // vi tri con tro nhap nhay
  end;

  PMouseInfo = ^TMouseInfo;
  TMouseInfo = record
    // phan nhap
    hwnd: HWND;   // cua so can lay thong tin
    pt:   TPoint; // vi tri chuot can lay thong tin
    // phan xuat
    dt:  Integer; // loai tai lieu (document/page)
    ht:  Integer; // ma hit-test
    rw:  Integer; // dong tai vi tri chuot (-1 neu khong xac dinh)
    col: Integer; // cot tai vi tri chuot (-1 neu khong xac dinh)
  end;

  // -----------------------------------------------------------------------
  // Con tro ham callback bat dong bo cho Cluster Connector (HPC)
  // -----------------------------------------------------------------------
  TXlHpcAsyncCallback = function(operAsyncHandle: LPXLOPER12;
                                  operReturn: LPXLOPER12): Integer; stdcall;

const

extern "C" __declspec(dllexport) LPXLOPER12 WINAPI Foo(double a, double b) {
    static XLOPER12 xlRet;
    double dblRet = 0;
    //Tính toán cái gì đấy rồi trả về giá trị cho biến dblRet

    xlRet.xltype = xltypeNum;
    xlRet.val.num = dblRet;
    //Làm một số công việc nào đó, vd: dọn dẹp chẳng hạn
    return &xlRet;
}