/* 
TSLUIL.cpp : 定义 DLL 应用程序的导出函数。
20161220 修改 窗口构建 的逻辑 去掉 样式默认值
		 窗口添加 getpc 方法 参数 1: 窗口 ;参数2 : 整数 1 设置父窗口,2 设置子窗口
		 添加 visible 方法获得显示属性
20170103 窗口添加 updatewindow 方法--updatewindow
20170105 添加 clipcusor 固定鼠标到指定区域 
		 添加clienttoscreen 计算窗口中的点对于屏幕位置
20170108 修正消息参数lparam ,wparam 传递bug
		 删除废弃的代码
		 为避免冲突修改成员函数名称 create 为construct 
20170109 添加调试错误退出,添加 windowlong 方法
20170112 在construct 函数中判断是否已经初始,如果重复初始化返回错误;
20170113 增加getscrollinfo setscrollinfo方法
20170318 删删除多余代码,保留结构体转换代码
20170322 整理代码,添加注释,回调错误写入log文件
20170328 将主循环写入tsl
20170410 修改添加tslcstructrueobj_的 construct方法,用于构造指针引用不比拷贝内存数据
20170502 添加 _getvalueaddr_ _getvalueaddr2_ 两个方法分别获得结构体对应索引的地址,和对应索引作为指针指向的地址
20170629 添加float类型到转换结构体
20170828 将c代码改写为tsl c中只提供基础的内存操作 和消息分发
20200228 添加多线程功能,并添加线程读写锁
20200302 修改TSL_InterpErrorInfo 线程相关
20220418 整理代windows的代码
20220419 整理gtk代码
		 
*/
//typedef void* (*TTSL_InterpPrepare)(TSL_State* L);
// 依赖头文件
#include "stdafx.h"


#ifdef __LINUX_GTK__
//gtk linker
//libTSSVRAPI.so libTSLInterp.so libTSLPlugin.so
//`pkg-config  --libs gtk + -3.0 `
//输出所有 __attribute__((visibility("default"))) 的函数 
#include <unistd.h>
#include<fcntl.h>
#include <stdio.h>
#include <dlfcn.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <X11/Xlib.h>
extern "C" {
#include<gtk/gtk.h>

}

#else

//tssvrapi.lib
//TSLInterp.lib
//TSLKRNL.lib
//TSLPLUGIN.lib
//comctl32.lib
//gdiplus.lib

//输出函数
//PKG_Init

#include<stdio.h>
#include <windows.h>
#include <objidl.h>
#include <gdiplus.h>
#include<process.h>
#endif 


#include <mutex>
#include <map>
static std::recursive_mutex strmmutex; //线程锁
typedef unsigned char byte;

#ifdef __LINUX_GTK__

//typedef unsigned int size_t;
typedef short WORD;
typedef short SHORT;
typedef unsigned long int __int64;
//typedef struct HANDLE;
//只有64位
typedef __int64 INT_PTR;              
typedef int BOOL;
typedef long LONG;
typedef byte BYTE;
typedef unsigned int DWORD;
typedef float FLOAT;


#endif


extern "C"
{
#include "TSSVRAPI.h"
}
typedef TObject* PTObject; //天软对象
typedef  const TObject * CPTObject;//const 天软对象

#ifdef __LINUX_GTK__
//gtk输出函数
extern "C" {
	__attribute__((visibility("default")))  int  PKG_Init(TSL_State* L, OpenLibProc proc);	
	__attribute__((visibility("default")))  int  tsl_gtk_pipread(INT_PTR hr, char * msg, int ct);
	__attribute__((visibility("default")))  int  tsl_gtk_createprocessa(char * name, char * argv[], char* envp[], INT_PTR & pw);
}
//非external输出函数
extern "C" {

	//GetGtkEventNameOrId
	__attribute__((visibility("hidden")))  INT_PTR  gettslvcleventhandler(const char * fname);
	__attribute__((visibility("hidden")))  int deal_time(void * p);
	__attribute__((visibility("hidden")))  INT_PTR  getnameid(const char * b);
	__attribute__((visibility("hidden")))  gint  dodeleteevents(void * a, const char * b);
	__attribute__((visibility("hidden")))  gint  dotparamseevents(void * a, const char * b, void * p1, void * p2);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_destroy_event(void * a, void * b, void* c);

	__attribute__((visibility("hidden")))  gint  tsl_gtk_delete_event(void * a, void * b);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_wmuser_event(void * a, void * p1, void*p2);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_adj_value_changed_event(void * a, void * b);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_clicked_event(void * a, void * b);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_activate_event(void * a, void * b);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_changed_event(void * a, void * b);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_preedit_changed_event(void * a, void * b, void * c);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_draw_event(void * a, void * b, void * c);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_entry_insert_text(void * a, void * b, int c, int*p, void * gd);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_normal_event_bc(void * a, void * b, void * c);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_normal_event_cb(void * a, void * b, void* c);
	__attribute__((visibility("hidden")))  gint  tsl_gtk_day_select_event(void * a, void * b);
	
	gboolean  tsl_gtk_idl_do(void * dlg);
		
	gpointer * WorkerThreadCall(void *p);
	INT_PTR createathread(void *s)
	{
		if (!g_thread_supported()) g_thread_init(NULL);
		gdk_threads_init();
		GThread*  r = g_thread_create(WorkerThreadCall, s, FALSE, NULL);
		return r;
	}
#define _stricmp strcmp
}


#else

void  WorkerThreadCall(void *p);
INT_PTR createathread(void *s)
{
	return _beginthread(WorkerThreadCall, 4068000, s); //4068
}

#endif

char * LibPath=0;  //tsl库目录
thread_local TSL_InterpErrorInfo * TslExe_error =  TSL_InterpNewErrorInfo(); //tsl获得执行信息结构体
thread_local TSL_State*  GlobalL1;    //界面线程的状态变量
thread_local TObject* callfunctiondata=0;  //远程执行回调
std::map<INT_PTR,char*> ThreadScripts;     //多线程执行脚本缓存
std::map<INT_PTR, void*> ThreadMessageDatas;  //多线程数据缓存
//界面库名
#define TSLMODELNAME  "tslvcl"
//gtk接口库名
#define TSLGTKMODALNAME "ugtkinterface"
#define AEFCLASS "aefclassobj_"

//void * gettslbase(TSL_State * L, TObject * FA, const char * name);

//获得c基础类型的内存大小
//获取指针的长度
int getctypesize(TSL_State* L, TObject* iArgs, int iNum, TObject* Value)
{
	//LRESULT
	//MAKEINTRESOURCE
	//GlobalL1 = L;
	//PWNDCLASSEXA
	//TSL_SetIntPtr(L, Value, sizeof(INT_PTR));
	TSL_SetType(L, Value, TSL_TTABLE);
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "int"), sizeof(int));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "uint"), sizeof(unsigned int));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "char*"), sizeof(char*));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "intptr"), sizeof(INT_PTR));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "SHORT"), sizeof(SHORT));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "BOOL"), sizeof(BOOL));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "char"), sizeof(char));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "double"), sizeof(double));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "short"), sizeof(short));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "ushort"), sizeof(unsigned short));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "long"), sizeof(long));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "ulong"), sizeof(unsigned long));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "LONG"), sizeof(LONG));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "bool"), sizeof(bool));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "byte"), sizeof(byte));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "BYTE"), sizeof(BYTE));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "WORD"), sizeof(WORD));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "DWORD"), sizeof(DWORD));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "word"), sizeof(WORD));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "dword"), sizeof(DWORD));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "float"), sizeof(float));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "FLOAT"), sizeof(FLOAT));
	TSL_SetInt(L, TSL_HashSetItemSZString(L, Value, "pointer"), sizeof(INT_PTR));
	return 1;
}

//tsl对象类
struct tarmyTSLOBJ
{
	PTObject tslobj;
	TSL_State *ML;
	tarmyTSLOBJ(TSL_State *L)
	{
		tslobj = TSL_NewObject();
		ML = L;
	}
	~tarmyTSLOBJ()
	{
		if (tslobj)
		{
			TSL_FreeObjectContent(ML, tslobj);
			TSL_FreeObj(ML, tslobj);
			tslobj = NULL;
		}

	}

};

//自动销毁的tsl对象
#define AUTOTSLOBJ(tobj,L) \
		tarmyTSLOBJ  (tobj##obj) = tarmyTSLOBJ(L) ;\
		PTObject tobj  = (tobj##obj).tslobj \



/////////代码块定义////////////////
#define Block_TypeClass             1
#define Block_Function              2
#define Block_Statements            4
#define Block_If                    8
#define Block_Else                  16
#define Block_SubCase               32
#define Block_Goto_Label            64
#define Block_Empty_Begin_End       128
#define Block_Try                   256
#define Block_NeedSql               512
#define Block_UnitStruct            1024
#define Block_Propertys             2048
#define Block_Fields                4096

struct BlockForEditor {
	int mType;
	int mBeg;
	int mEnd;
	int mSubs;
	bool mFolded;
	BlockForEditor** mSub;
	void Clear();
};

////////////////////////代码块解析//////导入函数////////////////////////////////
extern "C" {
	void tslL_getfunctions(char*** functions, int* count);
	bool TSL_TokenizeEx2(char* source, bool skiperror, char*** sWords, char*** sUnits, char*** sClasses, char**** sFunctions, int** iLines, int** iBeginEnds, char*** Dependency, BlockForEditor*** retBlocks, int* retBlockCount, int Flags, TSL_InterpErrorInfo* oResult);
	char * TSL_GetLibPath(TSL_State *);
	char * TSL_SetLibPath(TSL_State *, char*);
	void* TSL_InterpPrepare(TSL_State* L);
	void TSL_ClearError();
}
void SetStringsToTObject(TSL_State* L,TObject*obj, char**words)
{
	TSL_SetType(L, obj, TSL_TTABLE);
	int idx = 0;
	char * wd;
	while (true)
	{
		wd = words[idx];
		if (wd == 0) { return; }
		TSL_SetString(L, TSL_HashSetItemInt(L, obj, idx), wd);
		
		idx++;
	}
}
void SetIntsToTOjbect(TSL_State* L, TObject*obj, int*words,int n)
{
	TSL_SetType(L, obj, TSL_TTABLE);
	
	for (int idx=0; idx<n; idx++)
		TSL_SetInt(L, TSL_HashSetItemInt(L, obj, idx), words[idx]);

}
void SetBlkToTObject(TSL_State* L, TObject*obj, BlockForEditor **blks,int ct)
{
	TSL_SetType(L, obj, TSL_TTABLE);
	BlockForEditor *blki;
	TObject *blkisub=0;
	TObject*BLKI = 0;
	for (int i = 0; i < ct; i++)
	{
		BLKI = TSL_HashSetItemInt(L, obj,i);
		TSL_SetType(L, BLKI, TSL_TTABLE);
		blki = blks[i];
		TSL_SetInt(L, TSL_HashSetItemSZString(L, BLKI, "mtype"), blki->mType);
		TSL_SetInt(L, TSL_HashSetItemSZString(L, BLKI, "mbeg"), blki->mBeg);
		TSL_SetInt(L, TSL_HashSetItemSZString(L, BLKI, "mend"), blki->mEnd);
		TSL_SetInt(L, TSL_HashSetItemSZString(L, BLKI, "msubs"), blki->mSubs);
		if (blki->mSubs > 0)
		{
			SetBlkToTObject(L, TSL_HashSetItemSZString(L, BLKI, "msub"), blks[i]->mSub, blki->mSubs);
		}
	
	}
}
void freechar2(char** words)
{
	if (words)
	{
		//char** twd = words;
		int idx = 0;
		char * wd = 0;
		while (true)
		{
			wd = words[idx];
			if (wd == 0) { break; }
			TSL_Free(wd);
			idx++;
		}
		TSL_Free(words);
	}
}
void freechar3(char*** words)
{
	if (words)
	{
		int idx = 0;
		char ** wd = 0;
		while (true)
		{
			wd = words[idx];
			if (wd == 0) { break; }
			freechar2(wd);
			idx++;
		}
		TSL_Free(words);
	}

}
void freeblicks(BlockForEditor** blks,int ct)
{
	for (int i = 0; i < ct; i++)
	{
		freeblicks(blks[i]->mSub, blks[i]->mSubs);
		TSL_Free(blks[i]);
	}
}
int TSL_TokenizeEx_2_(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	int flg = 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 + 256 + 512 + 1024;
	if (iNum < 1) { return false; }
	if (iNum = 2) {
		if (TSL_AsInt(TSL_GetParamRef(L, 1)) >= 0)
		{
			flg = TSL_AsInt(TSL_GetParamRef(L, 1));
		}
	}
	char* source =(char*) TSL_AsString(TSL_GetParamRef(L, 0));
	if (source == 0) { return 0; }
	static TSL_InterpErrorInfo * errResult = TSL_InterpNewErrorInfo();
	char** sword = 0;
	char** sunits = 0;
	char** sclass = 0;
	char *** sfunctions = 0;
	int *ilines = 0;
	int *ibes = 0;
	char ** dep = 0;
	BlockForEditor **blks = 0;
	int blkct = 0;
	
	TSL_TokenizeEx2(source, true, &sword, &sunits, &sclass, &sfunctions, &ilines, &ibes, &dep, &blks, &blkct,flg , errResult);
	//返回结果处理
	TSL_SetType(L, oResult, TSL_TTABLE);
	TObject *rwords = 0;
	TObject *rwords2 = 0;
	if (sword) {
		rwords = TSL_HashSetItemSZString(L, oResult, "words");
		SetStringsToTObject(L, rwords, sword);
		freechar2(sword);
	}

	if (dep) {
		rwords = TSL_HashSetItemSZString(L, oResult, "dep");
		SetStringsToTObject(L, rwords, dep);
		freechar2(dep);
	}
	
	if (sunits)
	{
		rwords = TSL_HashSetItemSZString(L, oResult, "units");
		SetStringsToTObject(L, rwords, sunits);
		freechar2(sunits);
	}
	                 
	if (sclass)
	{
		rwords = TSL_HashSetItemSZString(L, oResult, "class");
		SetStringsToTObject(L, rwords, sclass);
		freechar2(sclass);
	}
	int fcount = 0;
	if (sfunctions)
	{
		char ** fs;
		rwords = TSL_HashSetItemSZString(L, oResult, "functions");
		TSL_SetType(L, rwords, TSL_TTABLE);
		int idx = 0;
		while (true) {
			
			fs = sfunctions[idx];
			if (fs == 0) { break; }
			rwords2 = TSL_HashSetItemInt(L, rwords, idx);
			SetStringsToTObject(L, rwords2, fs);
			idx++;

		}
		fcount = idx;
		freechar3(sfunctions);

	}
	if (ilines)
	{
		rwords = TSL_HashSetItemSZString(L, oResult, "lines");
		SetIntsToTOjbect(L, rwords, ilines, fcount);
		TSL_Free(ilines);
	}
	if (ibes)
	{
		rwords = TSL_HashSetItemSZString(L, oResult, "linebegend");
		int idx = 0;
		TSL_SetType(L, rwords, TSL_TTABLE);
		while (ibes[idx] != -1 || ibes[idx + 1] != -1)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, rwords, idx), ibes[idx]);
			idx ++;
		}
		//SetIntsToTOjbect(L, rwords, ibes, fcount *2);
		TSL_Free(ibes);
	
	}
	if (blkct > 0)
	{
		rwords = TSL_HashSetItemSZString(L, oResult, "blcks");
		SetBlkToTObject(L, rwords, blks, blkct);
		freeblicks(blks, blkct);
	}
	
	//TSL_HashGet(L,oResult,)
	//TSL_SetInt(L, TSL_HashSetItemSZString(L, oResult, "int"), sizeof(int));

	return 1;
}
int tslL_getfunctions_2_(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	char **funs = 0;
	int cnt = 0;
	tslL_getfunctions(&funs, &cnt);
	TSL_SetType(L, oResult, TSL_TTABLE);
	char *f = 0;
	for (int i = 0; i < cnt;i++)
	{
		f = funs[i];
		TSL_SetString(L, TSL_HashSetItemInt(L, oResult, i),f);
		//TSL_Free(f);
		
	}
	return true;
}


//////////////执行tsl//////////////////////////////////////////////

void rawcallerrdo(TSL_State* L) //错误时候的处理
{
	//printf(" \r\n catch err id:%d\r\n",ee);
	//错误信息打印
	TSL_InterpGetLastError(TslExe_error);
	WriteToLog(TslExe_error->mErrMsg);
	printf(TslExe_error->mErrMsg);
	//fflush(stdout);
	TSL_ClearError();
	//TSL_InterpSetRuntimeStop(L, 0);
	exit(1);
}
int calltslfunction_p_int(TSL_State* L, const char* name, INT_PTR* argsin, int ct, void * result)
{

	AUTOTSLOBJ(fn, L);
	TSL_SetString(L, fn, name);

	//AUTOTSLOBJ(args, L);
	//TSL_SetType(L, args, TSL_TTABLE);
	TObject *args = 0;
	if (ct > 0)
	{
		args = TSL_NewObjects(ct);
		for (int i = 0; i < ct; i++)
		{
			//TSL_SetIntPtr(L, TSL_HashSetItemInt(L, args, i), argsin[i]);
			TSL_SetIntPtr(L, TSL_ReadTObjectFromPtr(args, i), argsin[i]);
		}
	}
	int r = 0;
	try
	{
		r = raw_call2(L, fn, args, ct, result);
	}
	catch (...)
	{
		rawcallerrdo(L);
		//TSL_ClearError();
	}
	if (ct > 0)
	{
		TSL_FreeObjs(L, args, ct);
	}

	return r;
}


int TSL_ScriptGo_A(TSL_State* L, const char* Content, TObject* v)
{
	return TSL_ScriptGo(L, Content, v);
}
int TSL_ScriptGo_B(TSL_State* L, const char* Content, TObject* v, const char* t = 0)
{
	int r = TSL_ScriptGo_A(L, Content, v);
	if (r == TSL_ERROR)
	{
		//错误信息打印
		TSL_InterpGetLastError(TslExe_error);
		if (t)
		{
			WriteToLog(t);
		}
		WriteToLog("执行:");
		WriteToLog(Content);
		WriteToLog("\r\n错误信息:");
		WriteToLog(TslExe_error->mErrMsg);
		TSL_ClearError();
	}
	return r;
}



//获取执行脚本
char * FeachThreadScripts(INT_PTR id) 
{
	std::lock_guard<std::recursive_mutex> g(strmmutex);
	char * r = ThreadScripts[id];
	if (r)
	{
		ThreadScripts.erase(id);
	}
	return r;
}
//获取消息对象
int FeachThreadMessagedata(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{
		TObject * ido = TSL_GetParamRef(L, 0);
		INT_PTR id = TSL_AsIntPtr(ido);
		if (id)
		{
			std::lock_guard<std::recursive_mutex> g(strmmutex);
			void * r = ThreadMessageDatas[id];
			if (r)
			{
				ThreadMessageDatas.erase(id);
				TSL_StrmToObj(L, oResult, r);
				TSL_DelStrm(r);
			}
		}
	}
	
	return 1;
}

//保存执行脚本
int SetDataToThreadScripts(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum==1) {
		TObject * ExecStr = TSL_GetParamRef(L, 0);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		char* d = TSL_Strdup(TSL_AsString(ExecStr));
		if (d)
		{
			std::lock_guard<std::recursive_mutex> g(strmmutex);
			INT_PTR id = (INT_PTR)d;
			ThreadScripts[id] = d;
			if (0 == LibPath) {
				LibPath = TSL_Strdup(TSL_GetLibPath(L));
			}
			TSL_SetIntPtr(L, oResult, id);

		}else 
			TSL_SetInt(L, oResult, 0);	
	}else 
		TSL_SetInt(L, oResult, 0);
	return true;

}
//保存消息对象
int SetDataToMessages(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum == 1) {
		TObject * ExecStr = TSL_GetParamRef(L, 0);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		void* d = TSL_ObjToStrm(L,ExecStr);
		if (d)
		{
			std::lock_guard<std::recursive_mutex> g(strmmutex);
			INT_PTR id = (INT_PTR)d;
			ThreadMessageDatas[id] = d;
			TSL_SetIntPtr(L, oResult,id);
		}
		else
			TSL_SetInt(L, oResult, 0);
	}else 
		TSL_SetInt(L, oResult, 0);
	return true;
}


class TWorkerMessageItem
{
public:
	INT_PTR FHandle;
	INT_PTR FMsg;
	INT_PTR FData;
	TWorkerMessageItem * Next;
	TWorkerMessageItem(INT_PTR h = 0, INT_PTR m = 0, INT_PTR d = 0)
	{
		FHandle = h;
		FMsg = m;
		FData = d;
		Next = 0;
	}
};

class TWorkerQueue {
public:
	TWorkerMessageItem * FFirst;
	TWorkerMessageItem * FLast;
	int FItemCount;
	TWorkerQueue()
	{
		FFirst = new TWorkerMessageItem();
		FLast = FFirst;
		FItemCount = 0;
	}
	INT_PTR beginthread(void * id)
	{
		//GThread*  r = g_thread_create(WorkerThreadCall, s, FALSE, NULL);		
		return createathread(id);
	}
	void Add(INT_PTR h = 0, INT_PTR m = 0, INT_PTR d = 0)
	{
		//printf("\r\nmessgequeue count:%d", FItemCount);
		FLast->Next = new TWorkerMessageItem(h, m, d);
		FLast = FLast->Next;
		
		FItemCount++;
		
	}
	void DeleteHandle(INT_PTR h)
	{
		TWorkerMessageItem *r = Feach(h);
		while (r != 0)
		{
			delete r;
			r = Feach(h);
		}
	}
	TWorkerMessageItem * Feach(INT_PTR h)
	{
		TWorkerMessageItem *pit, *it;
		TWorkerMessageItem * r = 0;
		pit = FFirst;
		while (pit)
		{
			it = pit->Next;
			if (it && (h == it->FHandle))
			{
				r = it;
				pit->Next = it->Next;
				if (it->Next == 0)
				{
					FLast = pit;
				}
				
				FItemCount--;
				break;
			}
			pit = it;
		}
		return r;
	}
};
TWorkerQueue GWOKERQUEUE;

int BeginThreadWorker(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{
		std::lock_guard<std::recursive_mutex> g(strmmutex);
		char * d = TSL_DupString( TSL_AsString(TSL_GetParamRef(L, 0)));
		INT_PTR id = (INT_PTR)d;
		ThreadScripts[id] = d;
		if (0 == LibPath) {
			LibPath = TSL_Strdup(TSL_GetLibPath(L));
		}
		GWOKERQUEUE.beginthread(d );
		TSL_SetInt(L, oResult, 1);
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}
int DeletehreadWorkerData(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{
		std::lock_guard<std::recursive_mutex> g(strmmutex);
		INT_PTR h = TSL_AsIntPtr(TSL_GetParamRef(L, 0));
		GWOKERQUEUE.DeleteHandle(h);
		TSL_SetInt(L, oResult, 1);
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}

int FeachThreadWorkerData(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 3)
	{
		TObject * ido = TSL_GetParamRef(L, 0);
		INT_PTR h = TSL_AsIntPtr(ido);
		std::lock_guard<std::recursive_mutex> g(strmmutex);
		TWorkerMessageItem *r = GWOKERQUEUE.Feach(h);
		if (r != 0)
		{
			TSL_SetInt(L, TSL_GetParamRef(L, 1), r->FMsg);
			TSL_StrmToObj(L, TSL_GetParamRef(L, 2),(void *) r->FData);

			TSL_SetInt(L, oResult, 1);
			TSL_DelStrm((void *)r->FData);
			delete r;
		}
		else
		{
			TSL_SetInt(L, oResult, 0);
		}


	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}
int SetThreadWorkerData(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 3)
	{
		std::lock_guard<std::recursive_mutex> g(strmmutex);
		INT_PTR h = TSL_AsIntPtr(TSL_GetParamRef(L, 0));
		INT_PTR msg = TSL_AsIntPtr(TSL_GetParamRef(L, 1));
		void* d = TSL_ObjToStrm(L, TSL_GetParamRef(L, 2));
		GWOKERQUEUE.Add(h, msg,(INT_PTR) d);
		TSL_SetInt(L, oResult, 1);
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}


//远程执行回调
void callback(TSL_State* L, int RecvType, int ChannelId, int ErrNo, char* ErrMsg, TObject* ResultObj, TObject* EnvObj)
{
	if (callfunctiondata == 0)
	{
		callfunctiondata = TSL_NewObject();
		TSL_SetType(L, callfunctiondata, TSL_TTABLE);
	}
	TObject*  callbackobj = TSL_HashSetItemInt(L, callfunctiondata, ChannelId);
	TSL_SetType(L, callbackobj, TSL_TTABLE);
	TSL_SetInt(L, TSL_HashSetItemSZString(L, callbackobj, "RecvType"), RecvType);
	TSL_SetInt(L, TSL_HashSetItemSZString(L, callbackobj, "ChannelId"), ChannelId);
	TSL_SetInt(L, TSL_HashSetItemSZString(L, callbackobj, "ErrNo"), ErrNo);
	if(ErrNo>0) TSL_SetStringEx(L, TSL_HashSetItemSZString(L, callbackobj, "ErrMsg"), ErrMsg, ErrNo);
	else TSL_SetString(L, TSL_HashSetItemSZString(L, callbackobj, "ErrMsg"), ErrMsg);
	if (ResultObj) {
		TObject* o1 = TSL_HashSetItemSZString(L, callbackobj, "ResultObj");
		TSL_DupObject(L, o1, ResultObj, true);
	}
	if (EnvObj) {
		TObject* o2 = TSL_HashSetItemSZString(L, callbackobj, "EnvObj");
		TSL_DupObject(L, o2, EnvObj, true);
	}
	AUTOTSLOBJ(tslgoretv, L);
	INT_PTR pms[1];
	pms[0] = (INT_PTR)ChannelId;
	const char * ss = TSLMODELNAME  "._executecallback_";
	calltslfunction_p_int(L, ss, pms, 1, tslgoretv);
}
//远程执行finaly回调
void finalcallback(TSL_State* L, int ChannelId)
{
	if (callfunctiondata == 0)
	{
		callfunctiondata = TSL_NewObject();
		TSL_SetType(L, callfunctiondata, TSL_TTABLE);
	}
	TSL_SetInt(L, TSL_HashSetItemInt(L, callfunctiondata, ChannelId), 0);
	const char * ss = TSLMODELNAME  "._finalcallback_";
	//TS_EndExecute(ChannelId);
	AUTOTSLOBJ(tslgoretv, L);
	INT_PTR pms[1];
	pms[0] = (INT_PTR)ChannelId;
	calltslfunction_p_int(L, ss, pms, 1, tslgoretv);
}
//远程执行
int TS_SendExecuteAndWaitExcall(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{	//获得消息处理函数的指针
	GlobalL1 = L;
	int ChannelId = 0;
	if (iNum >=6)
	{
		//获得系统消息函数处理的指针
		TObject * ExecStr = TSL_GetParamRef(L, 0);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		TObject * SysParam = TSL_GetParamRef(L, 1);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		TObject * oResult1 = TSL_GetParamRef(L, 2);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		TObject * ExecResult = TSL_GetParamRef(L, 3);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		TObject * ErrObj = TSL_GetParamRef(L, 4);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		TObject * Online = TSL_GetParamRef(L, 5);//TSL_ReadTObjectFromPtr(iArgs, 0);// 
		ChannelId = TS_SendExecuteAndWaitEx(L,TSL_AsString(ExecStr),
					SysParam, oResult1, ExecResult, ErrObj, TSL_AsInt( Online),
				callback, finalcallback);
	}
	TSL_SetInt(L, oResult, ChannelId);
	return 1;
}


//内存管理辅助类
void *  aef_new(TSL_State* L, TObject* iArgs, int iNum)
{
	GlobalL1 = L;
	return (void *)1;
	//return new int;
		//return new TSLCSTRUC();
}
//c结构体析构
void aef_free(TSL_State* L, void* data)
{
	//if (!data) return;
	//delete (int*)data;
}
//c struct 结构体处理函数
bool aef_method(TSL_State* L, TObject* obj, char* Name, TObject** Params, int ParamCount, TObject* Value, BOOL isSet)
{
	PTObject tptr =  (TObject*)TSL_ReadINTPtrFromPtr(Params, 0); //指针
	PTObject tval = (TObject*)TSL_ReadINTPtrFromPtr(Params, 1); //长度或者值
	PTObject tvals = (TObject*)TSL_ReadINTPtrFromPtr(Params, 2); //数组
	if (!TSL_NumberCheck(tptr)) return 0;
	INT_PTR ptr = TSL_AsIntPtr(tptr); //指针
	if (ptr == 0) return 0;
	if (_stricmp(Name, "getstderr1") == 0) //获取结构体数据
	{
		TSL_SetIntPtr(L, Value, (INT_PTR)stderr);
	}
	else
	if (_stricmp(Name, "getstdout1") == 0) //获取结构体数据
	{
		TSL_SetIntPtr(L, Value, (INT_PTR)stdout);
	}else
	if (_stricmp(Name, "getstdin1") == 0) //获取结构体数据
	{
		TSL_SetIntPtr(L, Value, (INT_PTR)stdin);

	}else
	if (_stricmp(Name, "tmalloc") == 0) //获取结构体数据
	{
		//TSL_SetIntPtr(L, Value, (INT_PTR)malloc(ptr));
		TSL_SetIntPtr(L, Value,( INT_PTR)TSL_Malloc(ptr));
	}
	else if (_stricmp(Name, "trealloc") == 0)
	{
		int len = TSL_AsInt(tval);
		if (len < 1) return 0;
		INT_PTR t = (INT_PTR)TSL_Realloc2((void*)ptr, len);
		//INT_PTR t = (INT_PTR)realloc((void*)ptr, len);
		TSL_SetIntPtr(L,Value,t);
	}
	else if(_stricmp(Name, "tfree") == 0)
	{
		//free((void*)ptr);
		TSL_Free((void*)ptr);
	}
	else if (_stricmp(Name, "tmcopy") == 0)
	{
		//memccpy()
		void * ret =memcpy((void*)ptr, (void*)TSL_AsIntPtr(tval), TSL_AsInt(tvals));
		TSL_SetIntPtr(L, Value, (INT_PTR)ret);
	}
	else if (_stricmp(Name, "tmset") == 0)
	{
		int n = TSL_AsInt(tval);
		
		memset((void*)ptr, 0, n);
	}
	else if (_stricmp(Name, "readbyte") == 0)
	{
		byte * v = (byte*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "writebyte") == 0)
	{
		byte *v = (byte*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "readint") == 0)
	{
		int * v = (int*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "readuint") == 0)
	{
		unsigned int * v = (unsigned int*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "writeint") == 0)
	{
		int *v = (int*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "writeuint") == 0)
	{
		unsigned int *v = (unsigned int*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "readfloat") == 0)
	{
		float *v = (float*)ptr;
		TSL_SetReal(L, Value, *v);
	}
	else if (_stricmp(Name, "writefloat") == 0)
	{
		float *v = (float*)ptr;
		*v = TSL_AsDouble(tval);

	}
	else if (_stricmp(Name, "readptr") == 0)
	{
		INT_PTR *v = (INT_PTR*)ptr;
		TSL_SetIntPtr(L, Value, *v);
	}
	else if (_stricmp(Name, "writeptr") == 0)
	{
		INT_PTR *v = (INT_PTR*)ptr;
		*v = TSL_AsIntPtr(tval);
		
	}
	else if (_stricmp(Name, "readdouble") == 0)
	{
		double *v = (double*)ptr;
		TSL_SetReal(L, Value, *v);
	}
	else if (_stricmp(Name, "writedouble") == 0)
	{
		double *v = (double*)ptr;
		*v = TSL_AsDouble(tval);
	}
	else if (_stricmp(Name, "readstr") == 0)
	{
		char *v = (char*)ptr;
		//printf("\r\n--%s", v);
		TSL_SetString(L, Value, v);
	}
	else if (_stricmp(Name, "writestr") == 0)
	{
		char *v = (char*)ptr;
		const char* ps = TSL_AsString(tval);
		int len = strlen(ps);
		memcpy(v, ps, len);
		v[len] = '\0';
	}
	else if  (_stricmp(Name, "readshort") == 0)
	{
		short *v = (short*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "readushort") == 0)
	{
		unsigned short *v = (unsigned short*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "writeshort") == 0)
	{
		short *v = (short*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "writeushort") == 0)
	{
		unsigned short *v = (unsigned short*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "readlong") == 0)
	{
		long *v = (long*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "readulong") == 0)
	{
		unsigned long *v = (unsigned long*)ptr;
		TSL_SetInt(L, Value, *v);
	}
	else if (_stricmp(Name, "writelong") == 0)
	{
		long *v = (long*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "writeulong") == 0)
	{
		unsigned long *v = (unsigned long*)ptr;
		*v = TSL_AsInt(tval);
	}
	else if (_stricmp(Name, "writeints")==0)
	{
		//if (!TSL_NumberCheck(tval)) return 0;
		int *v = (int*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt( TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "writeuints") == 0)
	{
		//if (!TSL_NumberCheck(tval)) return 0;
		unsigned int *v = (unsigned int*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readints") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		int *v = (int*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "readuints") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		unsigned int *v = (unsigned int*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "writedoubles") == 0)
	{
		double *v = (double*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsDouble(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readdoubles") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		double *v = (double*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetReal(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "writebytes") == 0)
	{
		byte *v = (byte*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readbytes") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		byte *v = (byte*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "writeshorts") == 0)
	{
		short *v = (short*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "writeushorts") == 0)
	{
		unsigned short *v = (unsigned short*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readshorts") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		short *v = (short*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "readushorts") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		unsigned short *v = (unsigned short*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "writefloats") == 0)
	{
		float *v = (float*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsDouble(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readfloats") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		float *v = (float*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			TSL_SetReal(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "writeintptrs") == 0)
	{
		INT_PTR *v = (INT_PTR*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsIntPtr(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readintptrs") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		INT_PTR *v = (INT_PTR*)ptr;
		for (int i = 0; i < TSL_AsIntPtr(tval); i++)
		{
			TSL_SetIntPtr(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else if (_stricmp(Name, "writelongs") == 0)
	{
		int *v = (int*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "writeulongs") == 0)
	{
		unsigned int *v = (unsigned int*)ptr;
		for (int i = 0; i < TSL_AsInt(tval); i++)
		{
			*v = TSL_AsInt(TSL_HashGetItemInt(L, tvals, i));
			v++;
		}

	}
	else if (_stricmp(Name, "readintptrs") == 0)
	{
		TSL_SetType(L, Value, TSL_TTABLE);
		int *v = (int*)ptr;
		for (int i = 0; i < TSL_AsIntPtr(tval); i++)
		{
			TSL_SetInt(L, TSL_HashSetItemInt(L, Value, i), *v);
			v++;
		}

	}
	else
	{
		return false;
	}


	return 1;
}

//tslc
const  char *ttslaefclassbuf ;// [1024];


//初始虚基类结构
void  initvirtualbuf()
{
		//tslc
	ttslaefclassbuf = "Type " AEFCLASS " =FackClass\r\n  public  \
								       tmalloc;tfree;tmset;trealloc;\
										getstdin1;getstdout1;getstderr1; \
										readbyte;writebyte;\
									    readint;writeint;\
									    writedouble;readdouble; \
									   writellong;readlong;	\
										writeshort;readshort; \
										writebytes;readbytes;\
										writeshorts;readshorts;\
									End;";

}
//在代码中获得当前的L参数 
int  GetCurrentL(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	TSL_SetIntPtr(L, oResult, (INT_PTR)L);
	return 1;
}//获取对象的指针地址,为消息传递做索引
int setunitname(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	return 1;
	//获得参数对象引用	
	TObject * id = TSL_GetParamRef(L, 0);// TSL_ReadTObjectFromPtr(iArgs, 0);
	if (TSL_StringCheck(id))
	{
		const char * na = TSL_AsString(id);
		int len = strlen(na);
		//strncpy(TSLMODELNAME, na, len);
		//TSLMODELNAME[len] = '\0';
	}
	//TSL_SetString(L, oResult, TSLMODELNAME);
	return 1;
}
int gettslibpath(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//获得参数对象引用	
	if (0 == LibPath) {
		LibPath = TSL_Strdup(TSL_GetLibPath(L));
	}
	TSL_SetString(L, oResult, LibPath);
	return 1;
}
int settslibpath(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//获得参数对象引用	
	if (1 != iNum) { return 0; }
	TObject * lp = TSL_GetParamRef(L, 0);//
	if (false==TSL_StringCheck(lp))
	{
		return 0;
	}
	gettslibpath(L, iArgs, 0, oResult);
	if (0 != LibPath) 
	{
		TSL_Free(LibPath);
	}
	LibPath = TSL_Strdup(TSL_AsString(lp));
	TSL_SetLibPath(L, LibPath);
	return 1;
}
//获得变量地址,该方法已在tsl中用int64替代了	
int getobjaddr(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//获得参数对象引用
	TObject * id = TSL_GetParamRef(L,0);// TSL_ReadTObjectFromPtr(iArgs, 0);
	INT_PTR * idt = (INT_PTR *)id;
	TSL_SetIntPtr(L, oResult, *idt);
	return 1;
}


#ifdef __LINUX_GTK__
///////////////////////linux独有////////////////////////////////////////////////
gpointer * WorkerThreadCall(void *p)
{
	if (!p)
	{
		return 0;
	}
	TSL_State* st = TS_GetGlobalL();

	if (0 != LibPath)
	{
		TSL_SetLibPath(st, LibPath);
	}
	//printf("\r&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%s\n",p);
	AUTOTSLOBJ(tslgoretv, st);
	if (TSL_ScriptGo_B(st, (char *)p, tslgoretv, "\r\nUI Threadworker Call") == TSL_ERROR)
	{
		return 0;
	}
	return 0;
}
int getcurrentdir(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	char buf[MAXNAMLEN];
	getcwd(buf, MAXNAMLEN);
	TSL_SetString(L, oResult, buf);
	return 1;
}
extern "C" {
	int MessageBoxQuit(GtkWidget * w, gpointer d)
	{
		INT_PTR *p = d;
		for (int i = 0; i<4; i++)
		{

			if ((INT_PTR)w == *(p + i))
			{
				if (i == 0)
				{
					gtk_main_quit();
				}
				else
				{
					g_signal_emit_by_name(*(p), "destroy");
				}
				*(p + i) = NULL;
				break;
			}
		}
		return 0;
	}
	void frame_callback(GtkWidget *window, GdkEvent *event, gpointer data)
	{
		int x, y;
		char buf[10];

		x = event->configure.x;
		y = event->configure.y;

		sprintf(buf, "%d,%d", x, y);

		gtk_window_set_title(GTK_WINDOW(window), buf);
	}

}

int tsl_gtk_messagebox_(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//gtk_init(0,0);
	GtkWidget *dialog, *label, *vbox, *hbox, *btn, *pt, *btns[4];
	dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);//gtk_dialog_new();
	gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ALWAYS);
	btns[0] = dialog;
	g_signal_connect(GTK_WIDGET(dialog), "destroy", MessageBoxQuit, btns);
	//gtk_widget_add_events(GTK_WIDGET(dialog),GDK_CONFIGURE);
	//g_signal_connect(G_OBJECT(dialog),"configure-event",G_CALLBACK(frame_callback),NULL);

	// gtk_window_set_type_hint(GTK_WINDOW (dialog),GDK_WINDOW_TYPE_HINT_MENU);
	TObject * id = TSL_GetParamRef(L, 0);
	TObject * idt = TSL_GetParamRef(L, 1);
	pt = TSL_AsIntPtr(TSL_GetParamRef(L, 2));
	if (GTK_IS_WINDOW(pt))
	{
		if (!gtk_widget_is_toplevel(pt))
		{
			pt = gtk_widget_get_toplevel(pt);
		}
		gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
		gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(pt));
	}
	gtk_window_set_title(GTK_WINDOW(dialog), TSL_AsString(idt));
	gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
	//gtk_widget_set_size_request (dialog, 470, 227);
	gtk_widget_realize(dialog);
	label = gtk_label_new(TSL_AsString(id));

	gtk_misc_set_padding(GTK_MISC(label), 10, 10);
	vbox = gtk_vbox_new(FALSE, 5);
	hbox = gtk_hbox_new(FALSE, 10);
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);

	gtk_widget_show(label);
	gtk_container_add(GTK_CONTAINER(dialog), GTK_WIDGET(vbox));
	gtk_widget_show(vbox);
	gtk_widget_show(hbox);

	//TSL_SetInt(L,oResult, gtk_dialog_run (GTK_DIALOG (dialog)));
	gtk_widget_show(dialog);
	TObject * temp = 0;
	for (int idx = 0; idx<3; idx++)
	{
		temp = TSL_GetParamRef(L, 3 + (idx * 2) + 0);
		btn = gtk_button_new_with_label(TSL_AsString(temp));
		btns[idx + 1] = btn;
		temp = TSL_GetParamRef(L, 3 + (idx * 2) + 1);
		//g_signal_connect_after(GTK_WIDGET( btn),"clicked",ClosingDialog,btns);
		g_signal_connect(GTK_WIDGET(btn), "clicked", MessageBoxQuit, btns);
		if (TSL_AsBool(temp))
		{
			gtk_widget_show(btn);
		}
		else
		{

		}
		gtk_box_pack_start(GTK_BOX(hbox), btn, TRUE, TRUE, 0);

	}

	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
	//gtk_grab_add(dialog);
	gtk_main();
	for (int idx = 3; idx >= 0; idx--)
	{
		if (NULL == (btns[idx]))
		{
			TSL_SetInt(L, oResult, idx);
			/* if(idx>0)
			{
			gtk_widget_destroy (dialog);
			}
			*/
			break;
		}

	}
	//gtk_widget_destroy(dialog);
	return 1;
}

//typedef int (*windowProc)(void*);
typedef  void* windowProc;
thread_local void * tsllibmodal = 0;

//GetGtkEventNameOrId
INT_PTR  getnameid(const char * b)
{
	if (GlobalL1 == 0) { return 0; }
	const char * ss = TSLGTKMODALNAME ".GetGtkEventNameOrId";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	AUTOTSLOBJ(fn, GlobalL1);
	
	TObject *args = TSL_NewObjects(1);

	TSL_SetString(GlobalL1, fn, ss);
	TSL_SetString(GlobalL1, TSL_ReadTObjectFromPtr(args, 0), b);

	try
	{
		raw_call2(GlobalL1, fn, args, 1, tslgoretv);
	}
	catch (...)
	{
		//printf(" \r\n try===========3333====+++++=");
		//fflush(stdout);
		rawcallerrdo(GlobalL1);
	}

	TSL_FreeObjs(GlobalL1, args, 1);
	return TSL_AsIntPtr(tslgoretv);
}


gint  dodeleteevents(void * a, const char * b)
{
	if (GlobalL1 == 0) { return 0; }
	const char * tslscript = TSLGTKMODALNAME  "._gtkeventcall_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[3];
	pms[0] = (INT_PTR)a;
	pms[1] = getnameid(b);
	pms[2] = 0;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 3, tslgoretv);
	return TSL_AsBool(tslgoretv);
}
gint  dotparamseevents(void * a, const char * b, void * p1, void * p2)
{
	if (GlobalL1 == 0) { return 0; }
	const char *  tslscript = TSLGTKMODALNAME "._gtkeventcall_" ;
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = (INT_PTR)a;
	pms[1] = getnameid(b);
	pms[2] = (INT_PTR)p1;
	pms[3] = (INT_PTR)p2;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);
	return TSL_AsBool(tslgoretv);
}
gint  tsl_gtk_destroy_event(void * a, void * b, void* c)
{
	if (GlobalL1 == 0) { return 0; }
	const char *  tslscript = TSLGTKMODALNAME "._gtkeventcall_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[3];
	pms[0] = (INT_PTR)a;
	pms[1] = (INT_PTR)b;
	pms[2] = (INT_PTR)c;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 3, tslgoretv);
	return TSL_AsInt(tslgoretv);
}

gint  tsl_gtk_delete_event(void * a, void * b)
{
	return dodeleteevents(a, "delete-event");
}
gint  tsl_gtk_wmuser_event(void * a, void * p1, void*p2)
{
	return dotparamseevents(a, "wm-user", p1, p2);
}
int  tsl_gtk_adj_value_changed_event(void * a, void * b)
{
	return dodeleteevents(a, "value-changed");
}
gint  tsl_gtk_clicked_event(void * a, void * b)
{
	return dodeleteevents(a, "clicked");
}
gint  tsl_gtk_activate_event(void * a, void * b)
{
	return dodeleteevents(a, "activate");
}
gint  tsl_gtk_changed_event(void * a, void * b)
{
	return dodeleteevents(a, "changed");
}
gint  tsl_gtk_preedit_changed_event(void * a, void * b, void * c)
{
	return dotparamseevents(a, "preedit-changed", b, c);
}
gint  tsl_gtk_draw_event(void * a, void * b, void * c)
{
	return dotparamseevents(a, "draw", b, c);
}
gint  tsl_gtk_entry_insert_text(void * a, void * b, int c, int*p, void * gd)
{
	g_object_set_data(a, "widget-event-param-1", p);
	g_object_set_data(a, "widget-event-param--2", gd);
	return dotparamseevents(a, "insert-text", b, c);
}

gint  tsl_gtk_normal_event_bc(void * a, void * b, void * c)
{

	if (GlobalL1 == 0) { return 0; }
	const char *   tslscript = TSLGTKMODALNAME "._gtkeventcall_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[3];
	pms[0] = (INT_PTR)a;
	pms[1] = (INT_PTR)b;
	pms[2] = (INT_PTR)c;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 3, tslgoretv);
	return TSL_AsInt(tslgoretv);


	//获得消息处理函数的指针
}
gint  tsl_gtk_normal_event_cb(void * a, void * b, void* c)
{
	//printf("****call in***\r\n ");
	if (GlobalL1 == 0) { return 0; }
	const char *   tslscript = TSLGTKMODALNAME "._gtkeventcall_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[3];
	pms[0] = (INT_PTR)a;
	pms[1] = (INT_PTR)c;
	pms[2] = (INT_PTR)b;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 3, tslgoretv);
	//return TSL_AsInt(tslgoretv);
	return  (TSL_AsInt(tslgoretv) == 0) ? FALSE : TRUE;

	//获得消息处理函数的指针
}
gint  tsl_gtk_day_select_event(void * a, void * b)
{
	return dodeleteevents(a, "day-selected");

	//获得消息处理函数的指针
}


gboolean  tsl_gtk_idl_do(void * dlg) //do idle
{
	if (GlobalL1 == 0) { return 0; }
	const char *  tslscript = TSLGTKMODALNAME "._gtkidledo_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[1];
	pms[0] = (INT_PTR)0;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 1, tslgoretv);
	//return true;
	return TSL_AsBool(tslgoretv);

}





////////////////////////////////////////
bool gtkcall_2(void * a, void * b)
{
	const char *  tslscript = TSLGTKMODALNAME "._gtkeventcall_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[2];
	pms[0] = (INT_PTR)a;
	pms[1] = (INT_PTR)b;
	//pms[2] = (INT_PTR)c;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 2, tslgoretv);	
	return TSL_AsBool(tslgoretv);
}
bool gtkcall_3(void * a, void * b, void *c)
{
	const char  *  tslscript = TSLGTKMODALNAME "._gtkeventcall_" ;
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[3];
	pms[0] = (INT_PTR)a;
	pms[1] = (INT_PTR)b;
	pms[2] = (INT_PTR)c;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 3, tslgoretv);	
	return TSL_AsBool(tslgoretv);
}

bool gtkcall_4(void * a, void * b, void *c, void*d)
{
	const char *  tslscript= TSLGTKMODALNAME "._gtkeventcall_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = (INT_PTR)a;
	pms[1] = (INT_PTR)b;
	pms[2] = (INT_PTR)c;
	pms[3] = (INT_PTR)d;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);	
	return TSL_AsBool(tslgoretv);

}
int getwinprocptr(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	GlobalL1 = L;
	windowProc prc = (windowProc)deal_time;
	if (iNum == 1)
	{
		//获得系统消息函数处理的指针
		TObject * id = TSL_GetParamRef(L, 0);
		if (TSL_AsInt(id) == 1)
		{
			//prc = deal_time;
		}
		else if (TSL_AsInt(id) == 2)
		{
			prc = (windowProc)deal_time;
		}
		else if (TSL_AsInt(id) == 3)
		{
			//prc = deal_time;
		}
		else if (0x10 == TSL_AsInt(id))
		{
			//prc = deal_time;
		}
		else if (0x11 == TSL_AsInt(id))
		{
			//prc = deal_time;
		}
		else if (0x12 == TSL_AsInt(id))
		{
			//prc = deal_time;
		}
		else if (0x13 == TSL_AsInt(id))
		{
			//prc = deal_time;
		}
		else if (0x14 == TSL_AsInt(id))
		{
			//prc = deal_time;
		}
		else if (0x101 == TSL_AsInt(id))
		{
			//prc = (windowProc)deal_time;
		}
		else if (0x102 == TSL_AsInt(id))
		{
			//prc = (windowProc)deal_time;
		}
		else if (0x103 == TSL_AsInt(id))
		{
			//prc = (windowProc)deal_time;
		}
		else if (0x202 == TSL_AsInt(id))
		{
			prc = (windowProc)gtkcall_2;
		}
		else if (0x203 == TSL_AsInt(id))
		{
			prc = (windowProc)gtkcall_3;
		}
		else if (0x204 == TSL_AsInt(id))
		{
			prc = (windowProc)gtkcall_4;
		}
	}
	TSL_SetIntPtr(L, oResult, (INT_PTR)prc);
	return 1;
}






struct timerstrct {
	int id;
	int flg;
};
int deal_time(void * p)
{
	if (GlobalL1 == 0) { return 0; }
	timerstrct * str = (timerstrct*)p;

	const char *  tslscript= TSLGTKMODALNAME "._gtk_add_time_msg_";
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = 0;
	pms[1] = (INT_PTR)str->flg;
	pms[2] = (INT_PTR)str->id;
	pms[3] = 0x113;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);
	//return TSL_AsIntPtr(tslgoretv);
	return true;
}
INT_PTR  gettslvcleventhandler(const char * fname)
{
	if (_stricmp(fname, "tsl_gtk_wmuser_event") == 0)
	{
		return tsl_gtk_wmuser_event;
	}
	if (_stricmp(fname, "tsl_gtk_destroy_event") == 0)
	{
		return tsl_gtk_destroy_event;
	}
	if (_stricmp(fname, "tsl_gtk_activate_event") == 0)
	{
		return tsl_gtk_activate_event;
	}
	if (_stricmp(fname, "tsl_gtk_clicked_event") == 0)
	{
		return tsl_gtk_clicked_event;
	}
	if (_stricmp(fname, "tsl_gtk_adj_value_changed_event") == 0)
	{
		return tsl_gtk_adj_value_changed_event;
	}
	if (_stricmp(fname, "tsl_gtk_delete_event") == 0)
	{
		return tsl_gtk_delete_event;
	}
				
	if (_stricmp(fname, "tsl_gtk_day_select_event") == 0)
	{
		return tsl_gtk_day_select_event;
	}
					
						
	if (_stricmp(fname, "tsl_gtk_changed_event") == 0)
	{
		return tsl_gtk_changed_event;
	}

	if (_stricmp(fname, "tsl_gtk_preedit_changed_event") == 0)
	{
		return tsl_gtk_preedit_changed_event;
	}
	if (_stricmp(fname, "dodeleteevents") == 0)
	{
		return dodeleteevents;
	}
	if (_stricmp(fname, "tsl_gtk_normal_event_cb") == 0)
	{
		return tsl_gtk_normal_event_cb;
	}
	if (_stricmp(fname, "tsl_gtk_normal_event_bc") == 0)
	{
		return tsl_gtk_normal_event_bc;
	}	
	return 0;
}


int  tsl_gtk_createprocessa(char * name, char * argv[], char* envp[], INT_PTR & pw)
{
	int fid[2], r;
	pipe(fid);
	pid_t pid = fork();
	if (pid == 0)
	{
		close(fid[0]);
		dup2(fid[1], 1);
		close(fid[1]);
		/*
		char *argv[] = {"/home/json/tslvcllinux/tsl_linux/TSL","/home/json/tslvcllinux/tsl_linux/script/vcldesigner.tsl","-libpath","/home/json/tslvcllinux/tsl_linux/designer/",NULL};
		char argg = "/home/json/tslvcllinux/tsl_linux/TSL /home/json/tslvcllinux/tsl_linux/script/vcldesigner.tsl -libpath  /home/json/tslvcllinux/tsl_linux/designer/\0\0";
		char * envp[] = {"LD_LIBRARY_PATH=/home/json/tslvcllinux/tsl_linux/","DISPLAY=:0", NULL};
		*/
		//char *argv[] = {"/home/json/tslvcllinux/tsl_linux/TSL","/home/json/tslvcllinux/tsl_linux/script/techo.tsl","-libpath","/home/json/tslvcllinux/tsl_linux/designer/",NULL};

		r = execve(name, argv, envp);
		_exit(r);

		//execl("/home/json/tslvcllinux/tsl_linux/TSL",argg);
	}
	else
		if (pid>0)
		{
			pw = fid[0];
			close(fid[1]);
			int flag = fcntl(fid[0], F_GETFL);
			fcntl(fid[0], F_SETFL, flag | O_NONBLOCK);
			return pid;
		}
		else
		{
			return -1;
		}
	return r;
}
int tslvclgetventhandler(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{
		
		INT_PTR ret = gettslvcleventhandler(TSL_AsString(TSL_GetParamRef(L, 0)));
		TSL_SetIntPtr(L, oResult, ret);
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}
int tsl_gtk_execsystem(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{

		int ret = system(TSL_AsString(TSL_GetParamRef(L, 0)));
		TSL_SetIntPtr(L, oResult, ret);
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}
int  tsl_gtk_color_selection_property(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//获得消息处理函数的指针
	if (iNum = 1)
	{

		GtkColorSelectionDialog *cdlg = (GtkColorSelectionDialog *)TSL_AsIntPtr(TSL_GetParamRef(L, 0));
		TSL_SetIntPtr(L, oResult, cdlg->priv);
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
	
}
int  tsl_gtk_idle_interface(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//获得消息处理函数的指针
	if (iNum = 1)
	{
		TSL_SetIntPtr(L, oResult, g_idle_add(tsl_gtk_idl_do, TSL_AsIntPtr(TSL_GetParamRef(L, 0))));
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;

}
int  tsl_gtk_closehandle(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{
		TSL_SetIntPtr(L, oResult, close( TSL_AsIntPtr(TSL_GetParamRef(L, 0))));
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}
int  tsl_gtk_pipread(INT_PTR hr, char * msg, int ct)
{
	int r = read(hr, msg, ct);
	if (r>0)
	{
		msg[r] = '\0';
	}
	return r;
}

int  tsl_gtk_waitpid(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	//int  tsl_gtk_waitpid(INT_PTR  id, int &s)
	//return waitpid(id,&s,0);
	return 1;
}

int  tsl_gtk_kill(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 2)
	{
		TSL_SetIntPtr(L, oResult, kill(TSL_AsInt(TSL_GetParamRef(L, 0)), TSL_AsInt(TSL_GetParamRef(L, 1))));
	}
	else
	{
		TSL_SetInt(L, oResult, 0);
	}
	return 1;
}

int  __xinitthreads__(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	TSL_SetInt(L, oResult, XInitThreads());
	return 1;
}

void pkginit(TSL_State* L)
{
	//对话框
	tslL_register(L, "tsl_gtk_messagebox_", tsl_gtk_messagebox_);
	tslL_register(L, "gettslvcleventhandler", tslvclgetventhandler);
	tslL_register(L, "tsl_gtk_execsystem", tsl_gtk_execsystem);
	tslL_register(L, "tsl_gtk_color_selection_property", tsl_gtk_color_selection_property);
	tslL_register(L, "tsl_gtk_idle_interface", tsl_gtk_idle_interface);
	tslL_register(L, "tsl_gtk_closehandle", tsl_gtk_closehandle);
	tslL_register(L, "__xinitthreads__", __xinitthreads__);
	tslL_register(L, "tsl_gtk_kill", tsl_gtk_kill);
	tslL_register(L, "tsl_gtk_waitpid", tsl_gtk_waitpid);
	gtk_init(0, 0);
}


#else
//////////////////////////////////////////////////////////////////////////////////////////////
//消息分发处理函数
LRESULT CALLBACK TWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	//天软脚本字符串
	//return DefWindowProcA(hwnd,message,wparam,lparam);
	//char  tslscript[512];
	const char  *tslscript=TSLMODELNAME "._timeproc_";
	if (GlobalL1 == 0) return 0;

	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = (INT_PTR)hwnd;
	pms[1] = (INT_PTR)message;
	pms[2] = (INT_PTR)wparam;
	pms[3] = (INT_PTR)lparam;

	if ((hwnd == NULL) && (message == 275))//没有窗口的计时器
	{
		tslscript = TSLMODELNAME "._timeproc_";

		calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);
	}
	else
	{
		tslscript = TSLMODELNAME "._twinproc_";
		calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);
	}
	return TSL_AsIntPtr(tslgoretv);

}
//定时器消息分发
LRESULT CALLBACK TimeProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	//天软脚本字符串
	//return DefWindowProcA(hwnd,message,wparam,lparam);
	char *ss = 0;
	const char *  tslscript = TSLMODELNAME "._timeproc_" ;
	if (GlobalL1 == 0) return 0;
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = (INT_PTR)hwnd;
	pms[1] = (INT_PTR)message;
	pms[2] = (INT_PTR)wparam;
	pms[3] = (INT_PTR)lparam;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);
	return TSL_AsIntPtr(tslgoretv);


}
LRESULT CALLBACK TWndProc2(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	//天软脚本字符串
	//return DefWindowProcA(hwnd,message,wparam,lparam);
	const char * tslscript= TSLMODELNAME "._tduiproc_";;
	if (GlobalL1 == 0) return 0;
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = (INT_PTR)hwnd;
	pms[1] = (INT_PTR)message;
	pms[2] = (INT_PTR)wparam;
	pms[3] = (INT_PTR)lparam;
	calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);


	return TSL_AsIntPtr(tslgoretv);


}
LRESULT CALLBACK _GetMsgProc_(UINT message, WPARAM wparam, LPARAM lparam, char * name)
{
	//hooke字符串
	//return DefWindowProcA(hwnd,message,wparam,lparam);
	const char * ss = TSLMODELNAME "._GetMsgProc_%s" ;
	char  tslscript[512];
	if (GlobalL1 == 0) return 0;
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[3];
	pms[0] = (INT_PTR)message;
	pms[1] = (INT_PTR)wparam;
	pms[2] = (INT_PTR)lparam;
	sprintf(tslscript, ss,  name);
	calltslfunction_p_int(GlobalL1, tslscript, pms, 3, tslgoretv);
	return TSL_AsIntPtr(tslgoretv);

}
LRESULT CALLBACK _GetMsgProc_a(UINT message, WPARAM wparam, LPARAM lparam)
{
	return _GetMsgProc_(message, wparam, lparam, "a");
}
LRESULT CALLBACK _GetMsgProc_b(UINT message, WPARAM wparam, LPARAM lparam)
{
	return _GetMsgProc_(message, wparam, lparam, "b");
}
LRESULT CALLBACK _GetMsgProc_c(UINT message, WPARAM wparam, LPARAM lparam)
{
	return _GetMsgProc_(message, wparam, lparam, "c");
}

LRESULT CALLBACK _MessgeHookBase_(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam, char * name)
{
	//hooke字符串
	//return DefWindowProcA(hwnd,message,wparam,lparam);


	const char * ss = TSLMODELNAME "._MessgeHook_%s";
	char  tslscript[512];
	if (GlobalL1 == 0) return 0;
	AUTOTSLOBJ(tslgoretv, GlobalL1);
	INT_PTR pms[4];
	pms[0] = (INT_PTR)hwnd;
	pms[1] = (INT_PTR)message;
	pms[2] = (INT_PTR)wparam;
	pms[3] = (INT_PTR)lparam;
	sprintf(tslscript, ss, name);
	calltslfunction_p_int(GlobalL1, tslscript, pms, 4, tslgoretv);
	return TSL_AsIntPtr(tslgoretv);


}
LRESULT CALLBACK _MessgeHook_(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	return _MessgeHookBase_(hwnd, message, wparam, lparam, "");
}
LRESULT CALLBACK _MessgeHook_a(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	return _MessgeHookBase_(hwnd, message, wparam, lparam, "a");
}
LRESULT CALLBACK _MessgeHook_b(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	return _MessgeHookBase_(hwnd, message, wparam, lparam, "b");
}
LRESULT CALLBACK _MessgeHook_c(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	return _MessgeHookBase_(hwnd, message, wparam, lparam, "c");
}
LRESULT CALLBACK _MessgeHook_d(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
	return _MessgeHookBase_(hwnd, message, wparam, lparam, "d");
}

//事件函数指针类型
typedef LRESULT(CALLBACK *windowProc)(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);


//获得winproc函数地址
int getwinprocptr(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{	//获得消息处理函数的指针
	GlobalL1 = L;
	windowProc prc = TWndProc;
	if (iNum ==1) 
	{
		//获得系统消息函数处理的指针
		TObject * id = TSL_GetParamRef(L, 0); 
		if (TSL_AsInt(id) == 1)
		{
			prc = DefWindowProcA;
		}
		else if (TSL_AsInt(id) == 2)
		{
			prc = TimeProc;
		}
		else if (TSL_AsInt(id) == 3)
		{
			prc = TWndProc2;
		}
		else if (0x10 == TSL_AsInt(id))
		{
			prc = _MessgeHook_;
		}
		else if (0x11 == TSL_AsInt(id))
		{
			prc = _MessgeHook_a;
		}
		else if (0x12 == TSL_AsInt(id))
		{
			prc = _MessgeHook_b;
		}
		else if (0x13 == TSL_AsInt(id))
		{
			prc = _MessgeHook_c;
		}
		else if (0x14 == TSL_AsInt(id))
		{
			prc = _MessgeHook_d;
		}
		else if (0x101 == TSL_AsInt(id))
		{
			prc = (windowProc)_GetMsgProc_a;
		}
		else if (0x102 == TSL_AsInt(id))
		{
			prc = (windowProc)_GetMsgProc_b;
		}
		else if (0x103 == TSL_AsInt(id))
		{
			prc = (windowProc)_GetMsgProc_c;
		}
	}
	TSL_SetIntPtr(L, oResult, (INT_PTR)*prc);
	return 1;
}


int getcurrentdir(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	char buf[MAX_PATH];
	int n = GetCurrentDirectoryA(MAX_PATH, buf);
	buf[n] = '\0';
	TSL_SetString(L, oResult, buf);
	return 1;
}

//线程启动回调
void  WorkerThreadCall(void *p)
{
	if (!p)
	{
		//return 0;
	}
	TSL_State* st = TS_GetGlobalL();

	if (0 != LibPath)
	{

		TSL_SetLibPath(st, LibPath);
	}
	AUTOTSLOBJ(tslgoretv, st);
	CoInitializeEx(NULL, COINIT_MULTITHREADED | COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
	char * d = ThreadScripts[(INT_PTR)p];
	ThreadScripts.erase((INT_PTR)p);
	if (TSL_ScriptGo_B(st, d, tslgoretv, "\r\nUI Threadworker Call") == TSL_ERROR)
	{
		//return 0;
	}
	TSL_Free(p); //处理删除 //delete p;
}
//图片编码辅助函数,gdi+用到 
int GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
{
	UINT  num = 0;          // number of image encoders
	UINT  size = 0;         // size of the image encoder array in bytes
	using namespace Gdiplus;
	ImageCodecInfo* pImageCodecInfo = NULL;
	GetImageEncodersSize(&num, &size);
	if (size == 0)
		return -1;  // Failure

	pImageCodecInfo = (ImageCodecInfo*)(malloc(size));
	if (pImageCodecInfo == NULL)
		return -1;  // Failure

	GetImageEncoders(num, size, pImageCodecInfo);

	for (UINT j = 0; j < num; ++j)
	{
		if (wcscmp(pImageCodecInfo[j].MimeType, format) == 0)
		{
			*pClsid = pImageCodecInfo[j].Clsid;
			free(pImageCodecInfo);
			return j;  // Success
		}
	}

	free(pImageCodecInfo);
	return -1;  // Failure
}
//图片流辅助函数
int tuicloseistream(IStream * s)
{
	if (s)
	{
		try
		{
			return s->Release();
		}
		catch (...)
		{
			return 1;
		}

	}
	return -1;
}

int tslvclGetEncoderClsid(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 2)
	{
		int ret = GetEncoderClsid((const WCHAR *)TSL_AsString(TSL_GetParamRef(L, 0)), (CLSID*)TSL_AsIntPtr(TSL_GetParamRef(L, 1)));
		TSL_SetInt(L, oResult, ret);
	}
	else
	{
		TSL_SetInt(L, oResult, -1);
	}
	return 1;
}
int tslvclcloseistream(TSL_State* L, TObject* iArgs, int iNum, TObject* oResult)
{
	if (iNum = 1)
	{
		IStream * s = (IStream *)TSL_AsIntPtr(TSL_GetParamRef(L, 0));
		int r = tuicloseistream(s);
		TSL_SetInt(L, oResult, r);
	}
	else
	{
		TSL_SetInt(L, oResult, -1);
	}
	return 1;
}
void pkginit(TSL_State* L)
{
	/*INITCOMMONCONTROLSEX iccx;
	iccx.dwSize = sizeof(INITCOMMONCONTROLSEX);
	iccx.dwICC = ICC_LINK_CLASS;
	int rot = InitCommonControlsEx(&iccx);
	printf("\r\n============%d====\r\n",rot);*/
	tslL_register(L, "tslvclgetencoderclsid", tslvclGetEncoderClsid);
	tslL_register(L, "tslvclcloseistream", tslvclcloseistream);
}



#endif
//信息注册
int  PKG_Init(TSL_State* L, OpenLibProc proc)
{
	initvirtualbuf();
	TAnyMan* tslaef = TSL_NewAnyMan(AEFCLASS, aef_new, aef_free, aef_method, NULL, NULL);
	TSL_RegisterAnyMan(AEFCLASS, tslaef);

	//获得变量addr实现索引
	tslL_register(L, "gettslvariableptr", getobjaddr);
	//tslL_register(L, "setcallbackunitname", setunitname);
	//获得消息处理函数指针
	tslL_register(L, "getwinprocptr", getwinprocptr);

	//获得对应c语言基础数据类型的大小
	tslL_register(L, "getctypesize", getctypesize);
	//远程执行
	tslL_register(L, "ts_sendexecuteandwaitexcall", TS_SendExecuteAndWaitExcall);
	//获得数据

	tslL_register(L, "getcurrenttslstate", GetCurrentL);
	//线程执行
	tslL_register(L, "uisetdatatothreadscripts", SetDataToThreadScripts);
	tslL_register(L, "uisetdatatomessage", SetDataToMessages);
	tslL_register(L, "uifeachthreadmessage", FeachThreadMessagedata);

	tslL_register(L, "uisetthreadworkerdata", SetThreadWorkerData);
	tslL_register(L, "uifeachthreadworkerdata", FeachThreadWorkerData);
	tslL_register(L, "uideleteworkerdata", DeletehreadWorkerData);
	tslL_register(L, "uibeginthreadworker", BeginThreadWorker);
	//分词和系统函数获取
	tslL_register(L, "tsl_tokenizeex_2_", TSL_TokenizeEx_2_);
	tslL_register(L, "tsll_getfunctions_2_", tslL_getfunctions_2_);
	tslL_register(L, "tsl_getlibpath_", gettslibpath);
	tslL_register(L, "tsl_setlibpath_", settslibpath);

	// 系统相关
	tslL_register(L, "tsl_getcurrentdir_", getcurrentdir);

	pkginit(L);

	return TSL_OK;
}