tech.txt

中文编程语言——易语言(可视化编程

            CMyDWordArray aryText;

            if (nLen1 > 0 && nCount != 0)
            {
                if (nLen2 == 0)
                {
                    // 有关 CloneTextData 请参见
                    aryText.Add ((DWORD)CloneTextData (szBeSplited));
                }
                else
                {
                    LPTSTR pBegin = szBeSplited;
                    LPTSTR ps = pBegin;

                    while (nLen1 >= nLen2)
                    {
                        if (!memcmp (ps, szMark, nLen2))
                        {
                            aryText.Add ((DWORD)CloneTextData (pBegin, ps - pBegin));
                            ps += nLen2;
                            nLen1 -= nLen2;
                            pBegin = ps;
                            if (nCount != -1)
                            {
                                nCount--;
                                if (nCount == 0)  break;
                            }
                        }
                        else
                        {
                            if (IS_CC (*ps))
                            {
                                if (ps [1] == 0)  break;
                                ps++;
                                nLen1--;
                            }
                            ps++;
                            nLen1--;
                        }
                    }

                    if (*pBegin != '\0' && nCount != 0)
                        aryText.Add ((DWORD)CloneTextData (pBegin));
                }
            }

            // 建立数组数据。
            INT nSize = aryText.GetDWordCount () * sizeof (DWORD);
            LPBYTE p = (LPBYTE)MMalloc (sizeof (INT) * 2 + nSize);
            *(LPINT)p = 1;  // 数组维数。
            *(LPINT)(p + sizeof (INT)) = aryText.GetDWordCount ();
            memcpy (p + sizeof (INT) * 2, aryText.GetPtr (), nSize);

            pRetData->m_pAryData = p;  // 返回内容数组。
        }

    ///////////////////

    5、返回复合数据类型数据的命令例子：

        static CMD_INFO s_CmdInfo =
        {
        /*name*/        _T("取打印设置"),
        /*egname*/      _T("GetPrintInf"),
        /*explain*/     _T("返回打印数据源数据时所将使用的设置信息"),
        /*category*/    -1,     // -1 表示为对象的方法。
        /*state*/       NULL,
        /*ret*/         DTP_PRINT_INF,
        /*reserved*/    0,
        /*level*/       LVL_SIMPLE,
        /*bmp inx*/     0,
        /*bmp num*/     0,
        /*ArgCount*/    0,
        /*arg lp*/      NULL,
        };

        // 实现函数
        void fnGetPrintInf (PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
        {
            CUDataSource* pUDataSource = (CUDataSource*)GetWndPtr (pArgInf);

            CMPrintInfo info;
            const CMPrintInfo* pInfo = pUDataSource->m_src.GetPrintInfo ();
            if (pInfo != NULL)
                info.CopyFrom (pInfo);

            INT nPaperType = 0;
            for (INT i = 0; i < sizeof (s_shtaryPaperType) / sizeof (s_shtaryPaperType [0]); i++)
            {
                if (info.m_shtPaperType == s_shtaryPaperType [i])
                {
                    nPaperType = i;
                    break;
                }
            }

            CFreqMem mem;
            mem.AddInt (nPaperType);
            mem.AddInt (info.m_shtOrientation == DMORIENT_LANDSCAPE ? 1 : 0);
            mem.AddInt (info.m_rtMargin.left);
            mem.AddInt (info.m_rtMargin.top);
            mem.AddInt (info.m_rtMargin.right);
            mem.AddInt (info.m_rtMargin.bottom);
            mem.AddInt (info.m_nPageNumPlace);
            mem.AddInt (info.m_nPrintCopies);
            mem.AddInt (info.m_nFirstPageNO);
            mem.AddBool (info.m_blIsPrintIntoFile);
            mem.AddDWord ((DWORD)CloneTextData ((char*)(LPCTSTR)info.m_strPrintIntoFileName));
            mem.AddBool (info.m_blAutoFillLastPage);
            mem.AddBool (info.m_blAutoAddHidedSide );
            mem.AddInt (info.m_nPagePrintMode);
            mem.AddInt (info.m_nPrintRangeMode);
            mem.AddInt (info.m_nBeginIndex);
            mem.AddInt (info.m_nEndIndex);
            mem.AddInt (info.m_nLinesPrePage);
            mem.AddInt (info.GetPrintScale ());

            // 设置返回的复合数据类型数据。
            INT nSize = mem.GetSize ();
            pRetData->m_pCompoundData = MMalloc (nSize);
            memcpy (pRetData->m_pCompoundData, mem.GetPtr (), nSize);
        }

    ///////////////////

    6、返回 _SDT_ALL 数据类型的命令例子：

        // 从字节集转换

        static ARG_INFO s_ArgInfo[] =
        {
            {
            /*name*/       _T("欲转换的字节集"),
            /*explain*/    NULL,
            /*bmp inx*/    0,
            /*bmp num*/    0,
            /*type*/       SDT_BIN,
            /*default*/    0,
            /*state*/      NULL,
            }, {
            /*name*/       _T("欲转换为的数据类型"),
            /*explain*/    _T("参数值可以为以下常量： 1、#字节型； 2、#短整数型； 3、#整数型； "
                      "4、#长整数型； 5、#小数型； 6、#双精度小数型； 7、#逻辑型； 8、#日期时间型； "
                      "9、#子程序指针型； 10、#文本型。转换后的数据将自动进行有效性校验及转换处理"),
            /*bmp inx*/    0,
            /*bmp num*/    0,
            /*type*/       SDT_INT,
            /*default*/    0,
            /*state*/      NULL,
            }
        };

        static CMD_INFO s_CmdInfo =
        {
        /*ccname*/        _T("从字节集转换"),
        /*egname*/        _T("CnvFromBin"),
        /*explain*/       _T("将字节集转换成指定数据类型的数据，返回转换后的结果"),
        /*category*/      10,
        /*state*/         NULL,
        /*ret*/           _SDT_ALL,
        /*reserved*/      0,
        /*level*/         LVL_SIMPLE,
        /*bmp inx*/       0,
        /*bmp num*/       0,
        /*ArgCount*/      2,
        /*arg lp*/        s_ArgInfo,
        },

        // 辅助函数
        INT GetSysDataTypeDataSize (DATA_TYPE dtSysDataType)
        {
            ASSERT (sizeof (DWORD) == 4);

            switch (dtSysDataType)
            {
            case SDT_BYTE:
                ASSERT (sizeof (BYTE) == 1);
                return sizeof (BYTE);
            case SDT_SHORT:
                ASSERT (sizeof (SHORT) == 2);
                return sizeof (SHORT);
            case SDT_BOOL:
                ASSERT (sizeof (BOOL) == 4);
                return sizeof (BOOL);
            case SDT_INT:
                ASSERT (sizeof (INT) == 4);
                return sizeof (INT);
            case SDT_FLOAT:
                ASSERT (sizeof (FLOAT) == 4);
                return sizeof (FLOAT);
            case SDT_SUB_PTR:    // 记录子程序代码的地址指针
                return sizeof (DWORD);
            case SDT_TEXT:    // 文本型和字节集型为一个指针,因此为四个字节.
            case SDT_BIN:
                return sizeof (DWORD);
            case SDT_INT64:
                ASSERT (sizeof (INT64) == 8);
                return sizeof (INT64);
            case SDT_DOUBLE:
                ASSERT (sizeof (DOUBLE) == 8);
                return sizeof (DOUBLE);
            case SDT_DATE_TIME:
                ASSERT (sizeof (DATE) == 8);
                return sizeof (DATE);
            default:
                ASSERT (FALSE);
                return 0;
            }

            return 0;
        }

        // 辅助函数
        void SetMDataValue (PMDATA_INF pRetData, LPBYTE pData, INT nDataSize)
        {
            switch (pRetData->m_dtDataType)
            {
            case SDT_BYTE:
                pRetData->m_byte = *pData;
                break;
            case SDT_SHORT:
                pRetData->m_short = *(SHORT*)pData;
                break;
            case SDT_INT:
                pRetData->m_int = *(INT*)pData;
                break;
            case SDT_INT64:
                pRetData->m_int64 = *(INT64*)pData;
                break;
            case SDT_FLOAT:
                pRetData->m_float = *(FLOAT*)pData;
                break;
            case SDT_DOUBLE:
                pRetData->m_double = *(DOUBLE*)pData;
                break;
            case SDT_BOOL:
                pRetData->m_bool = (*(BOOL*)pData != FALSE);
                break;
            case SDT_DATE_TIME:
                pRetData->m_date = max (MIN_DATE, min (MAX_DATE, *(DATE*)pData));
                break;
            case SDT_SUB_PTR:
                pRetData->m_dwSubCodeAdr = *(LPDWORD)pData;
                break;
            case SDT_TEXT: {
                INT nEndPos = FindByte (pData, nDataSize, 0);
                pRetData->m_pText = CloneTextData ((char*)pData,
                        (nEndPos != -1 ? nEndPos : nDataSize));
                break; }
            case SDT_BIN:
                pRetData->m_pBin = CloneBinData (pData, nDataSize);
                break;
            DEFAULT_FAILD;
            }
        }

        // 命令实现函数
        void fnCnvFromBin (PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
        {
            LPBYTE pData = pArgInf [0].m_pBin + sizeof (INT) * 2;
            INT nDataSize = *(LPINT)(pData - sizeof (INT));

            INT nType = pArgInf [1].m_int;
            if (nType < 1 || nType > 10)
                GReportError ("“欲转换为的数据类型”参数值无效");

            //!!! 如果定义为返回 _SDT_ALL 数据类型数据，则必须设置
            // pRetData->m_dtDataType 为所返回数据的 DATA_TYPE 。
            pRetData->m_dtDataType =
                    nType == 1 ? SDT_BYTE :
                    nType == 2 ? SDT_SHORT :
                    nType == 3 ? SDT_INT :
                    nType == 4 ? SDT_INT64 :
                    nType == 5 ? SDT_FLOAT :
                    nType == 6 ? SDT_DOUBLE :
                    nType == 7 ? SDT_BOOL :
                    nType == 8 ? SDT_DATE_TIME :
                    nType == 9 ? SDT_SUB_PTR :
                    SDT_TEXT;

            DWORD dwbuf [2];
            INT nNeedSize = GetSysDataTypeDataSize (pRetData->m_dtDataType);
            if (nType != 10 && nDataSize < nNeedSize)
            {
                ASSERT (nDataSize < sizeof (dwbuf));
                dwbuf [0] = dwbuf [1] = 0;
                memcpy (dwbuf, pData, nDataSize);
                pData = (LPBYTE)dwbuf;
                nDataSize = nNeedSize;
            }

            SetMDataValue (pRetData, pData, nDataSize);
        }

    ///////////////////