extern "C" void x_updatepath (lua_State* L) {
LPRDATA rdPtr = XLuaGlobal::Get().GetStateByState(L)->rdList.front()->rdPtr;
char* drive = (char*) calloc(_MAX_PATH, sizeof(char));
char* dir = (char*) calloc(_MAX_PATH, sizeof(char));
callRunTimeFunction(rdPtr, RFUNCTION_GETFILEINFOS, FILEINFO_DRIVE, (long)drive);
callRunTimeFunction(rdPtr, RFUNCTION_GETFILEINFOS, FILEINFO_DIR, (long)dir);
//rdPtr->rRd->GetApplicationDrive(drive);
//rdPtr->rRd->GetApplicationDirectory(dir);
std::stringstream pstr; pstr << drive << dir << "?.lua;";
std::stringstream cstr; cstr << drive << dir << "?.dll;";
free(drive);
free(dir);
lua_getfield(L, -1, "path");
pstr << lua_tostring(L, -1);
lua_pop(L, 1);
lua_pushstring(L, pstr.str().c_str());
lua_setfield(L, -2, "path");
lua_getfield(L, -1, "cpath");
cstr << lua_tostring(L, -1);
lua_pop(L, 1);
lua_pushstring(L, cstr.str().c_str());
lua_setfield(L, -2, "cpath");
//lua_settop(L, top);
}
// ---------------------
// SetRunObjectTextColor
// ---------------------
// Change the text color of the object.
//
void WINAPI SetRunObjectTextColor(LPRDATA rdPtr, COLORREF rgb)
{
rdPtr->textColor = rgb;
// Redraw object
callRunTimeFunction(rdPtr, RFUNCTION_REDRAW, 0, 0);
}
void XLuaObject::RaisePrint (const std::string& str) {
if (printQueue.size() >= 2000) {
printQueue.pop();
}
printQueue.push(str);
lastPrintString = str;
if (rdPtr == NULL) return;
if (printMode == 0) {
callRunTimeFunction(rdPtr, RFUNCTION_GENERATEEVENT, 2, 0);
//rdPtr->rRd->GenerateEvent(2);
}
else if (printMode == 1) {
callRunTimeFunction(rdPtr, RFUNCTION_PUSHEVENT, 2, 0);
//rdPtr->rRd->PushEvent(2);
}
}
// ---------------
// CreateRunObject
// ---------------
// The routine where the object is actually created
//
short WINAPI DLLExport CreateRunObject(LPRDATA rdPtr, LPEDATA edPtr, fpcob cobPtr)
{
/*
This routine runs when your object is created, as you might have guessed.
It is here that you must transfer any data you need in rdPtr from edPtr,
because after this has finished you cannot access it again!
Also, if you have anything to initialise (e.g. dynamic arrays, surface objects)
you should do it here, and free your resources in DestroyRunObject.
*/
LPRH rhPtr = rdPtr->rHo.hoAdRunHeader;
rdPtr->rHo.hoX = cobPtr->cobX;
rdPtr->rHo.hoY = cobPtr->cobY;
rdPtr->rHo.hoImgWidth = edPtr->nWidth;
rdPtr->rHo.hoImgHeight = edPtr->nHeight;
// Initialize RUNDATA members
rdPtr->textColor = edPtr->textColor;
rdPtr->backColor = edPtr->backColor;
rdPtr->dwAlignFlags = edPtr->dwAlignFlags;
rdPtr->dwFlags = edPtr->dwFlags;
rdPtr->hFont = CreateFontIndirect(&edPtr->textFont);
rdPtr->dwLastChangedLoopNumber = -1;
rdPtr->dwEvtFlags = 0;
// Create control window
DWORD dwStyle = WS_CHILDWINDOW | WS_CLIPSIBLINGS | WS_VISIBLE;
if ((edPtr->dwFlags & SCTRL_BORDER) != 0)
dwStyle |= WS_BORDER;
rdPtr->hWnd = CreateWindowEx(0, _T("EDIT"), NULL, dwStyle,
rdPtr->rHo.hoX - rhPtr->rhWindowX, rdPtr->rHo.hoY - rhPtr->rhWindowY,
rdPtr->rHo.hoImgWidth, rdPtr->rHo.hoImgHeight,
rhPtr->rhHEditWin, NULL, rhPtr->rh4.rh4Instance, NULL);
// Set text & font
if ( rdPtr->hWnd != NULL )
{
// Let MMF subclass window
rdPtr->nWnds = 1;
rdPtr->rHo.hoOffsetToWindows = (short)((LPBYTE)&rdPtr->nWnds - (LPBYTE)rdPtr);
callRunTimeFunction(rdPtr, RFUNCTION_SUBCLASSWINDOW, 0, 0);
// Create background brush
rdPtr->hBrush = NULL;
if ( (rdPtr->dwFlags & SCTRL_SYSTEMCOLORS) == 0 )
rdPtr->hBrush = CreateSolidBrush(rdPtr->backColor);
// Set font
SendMessage(rdPtr->hWnd, WM_SETFONT, (WPARAM)rdPtr->hFont, MAKELONG(TRUE, 0));
// Set Text
SetWindowText(rdPtr->hWnd, edPtr->sText);
}
// No errors
return 0;
}
void XLuaObject::RaiseError (const std::string& str) {
if (errorQueue.size() >= 20) {
errorQueue.pop();
}
errorQueue.push(str);
lastErrorString = str;
if (rdPtr == NULL) return;
if (errMode == 0) {
callRunTimeFunction(rdPtr, RFUNCTION_GENERATEEVENT, 0, 0);
//rdPtr->rRd->GenerateEvent(0);
}
else if (errMode == 1) {
callRunTimeFunction(rdPtr, RFUNCTION_PUSHEVENT, 0, 0);
//rdPtr->rRd->PushEvent(0);
}
}
// ----------------
// HandleRunObject
// ----------------
// Called (if you want) each loop, this routine makes the object live
//
short WINAPI DLLExport HandleRunObject(LPRDATA rdPtr)
{
// If text has been modified, generate a CND_CHANGED condition
if ( (rdPtr->dwEvtFlags & EVTFLAG_CHANGED) != 0 )
{
callRunTimeFunction(rdPtr, RFUNCTION_PUSHEVENTSTOP, CND_CHANGED, 0);
rdPtr->dwEvtFlags &= ~EVTFLAG_CHANGED;
}
return 0;
}
// -------------------
// SetRunObjectFont
// -------------------
// Change the font used by the object.
//
void WINAPI SetRunObjectFont(LPRDATA rdPtr, LOGFONT* pLf, RECT* pRc)
{
HFONT hFont = CreateFontIndirect(pLf);
if ( hFont != NULL )
{
// Change font
if (rdPtr->hFont!=0)
DeleteObject(rdPtr->hFont);
rdPtr->hFont = hFont;
// Redraw object
callRunTimeFunction(rdPtr, RFUNCTION_REDRAW, 0, 0);
}
}
// GenerateEvent: *instantly* generates an event
_inline void GenerateEvent(LPRDATA rdPtr, int EventID)
{ callRunTimeFunction(rdPtr,RFUNCTION_GENERATEEVENT,EventID,0); }
// ----------------
// HandleRunObject
// ----------------
// Called (if you want) each loop, this routine makes the object live
//
short WINAPI DLLExport HandleRunObject(LPRDATA rdPtr)
{
int fixedvalue = 0;
bool finnishedMoving = false;
float step;
for(unsigned int i = 0; i<rdPtr->controlled.size(); i++)
{
fixedvalue = 0;
LPRO object = NULL;
MoveStruct & moved = rdPtr->controlled.at(i);
if(i >= 0 && i < rdPtr->controlled.size())
{
fixedvalue = moved.fixedValue;
object = LproFromFixed(rdPtr,fixedvalue);
}
if( object != NULL )
{
if(moved.timeMode == 0)
{
__int64 currentTime = CurrentTime();
__int64 diff = currentTime - moved.starttime;
step = diff / (float)moved.timespan;
if(diff >= moved.timespan)
finnishedMoving = true;
}
else
{
moved.eventloop_step++;
step = moved.eventloop_step / (float)moved.timespan;
if(moved.eventloop_step >= moved.timespan)
finnishedMoving = true;
}
float easeStep = (float)calculateEasingValue(moved.easingMode,moved.functionA,moved.functionB,step, moved.vars);
object->roHo.hoX = (int)(moved.startX + (moved.destX-moved.startX)*easeStep + 0.5f);
object->roHo.hoY = (int)(moved.startY + (moved.destY-moved.startY)*easeStep + 0.5f);
object->roc.rcChanged = true;
if(finnishedMoving)
{
finnishedMoving = false;
object->roHo.hoX = moved.destX;
object->roHo.hoY = moved.destY;
rdPtr->deleted.push_back(moved);
rdPtr->controlled.erase( rdPtr->controlled.begin() + i );
i--;
}
}
else
{
rdPtr->controlled.erase( rdPtr->controlled.begin() + i );
i--;
}
}
//Trigger the 'Object stopped moving' events
for(unsigned int d=0; d<rdPtr->deleted.size(); ++d)
{
rdPtr->currentMoved = rdPtr->deleted.at(d);
callRunTimeFunction(rdPtr,RFUNCTION_GENERATEEVENT,CND_SPECIFICOBJECTSTOPPED,0);
callRunTimeFunction(rdPtr,RFUNCTION_GENERATEEVENT,CND_ANYOBJECTSTOPPED,0);
}
rdPtr->deleted.clear();
return 0;
}
// ----------------
// HandleRunObject
// ----------------
// Called (if you want) each loop, this routine makes the object live
//
short WINAPI DLLExport HandleRunObject(LPRDATA rdPtr)
{
////////////////////////////
//Main function timer loop//
////////////////////////////
for( int i=0; i<rdPtr->FunctionList.Size();i++ )
{
rdPtr->CurrentFuncIndex = i;
FuncStruct * CurrentStruct = rdPtr->FunctionList.GetItem(i);
if( !CurrentStruct )
return 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//Delete the function if it was marked as successfull or if function is immediate but not asked to loop//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
if( CurrentStruct->DeleteMe == true || (CurrentStruct->ImmediateFunc && !CurrentStruct->ImmediateApproved) )
{
delete [] CurrentStruct->FuncName;
rdPtr->FunctionList.Delete(i);
i = max( i-1, 0);
continue;
}
/////////////////////////////////////////////////////////////////////////////////
//When the time expires, trigger the functions if function is not set to repeat//
/////////////////////////////////////////////////////////////////////////////////
if( CurrentStruct->Time <= 0)
{
bool DeleteMe = true;
// Update the 'Last function name' in the rdPtr structure
delete [] rdPtr->LastFuncName;
int strl = strlen(CurrentStruct->FuncName)+1;
rdPtr->LastFuncName = new char[strl];
strcpy_s( rdPtr->LastFuncName, strl, CurrentStruct->FuncName);
//Handle repeatable functions.
if( CurrentStruct->Repeat > 1 || CurrentStruct->Repeat == -1 )
{
CurrentStruct->Time = CurrentStruct->InitialTime;
CurrentStruct->Repeat = max(CurrentStruct->Repeat-1,-1);
DeleteMe = false;
}
//Trigger the 'On function' events
callRunTimeFunction(rdPtr,RFUNCTION_GENERATEEVENT,0,0);
callRunTimeFunction(rdPtr,RFUNCTION_GENERATEEVENT,1,0);
//Delete the function from the queue
if(DeleteMe && CurrentStruct->WaitForSuccellfull == false)
{
delete [] CurrentStruct->FuncName;
rdPtr->FunctionList.Delete(i);
i = max( i-1, 0);
continue;
}
}
else CurrentStruct->Time--;
}
return 0;
}
// GetStringSpaceOld: gets some string space for an expression to return a string with.
// returns a pointer to your new memory. MMF will automatically free this memory soon after your expression routine finishes
// LIMITED TO 32KB - but compatible with all builds
_inline char* GetStringSpaceOld(LPRDATA rdPtr, int size)
{ return (char *)callRunTimeFunction(rdPtr,RFUNCTION_GETSTRINGSPACE,size,0); }
// ReHandleObject: start calling HandleRunObject() again
_inline void ReHandleObject(LPRDATA rdPtr)
{ callRunTimeFunction(rdPtr,RFUNCTION_REHANDLE,0,0); }
// DestroyObject: destroys your object like the Destroy action (will call DestroyRunObject etc. etc.)
_inline void DestroyObject(LPRDATA rdPtr)
{ callRunTimeFunction(rdPtr,RFUNCTION_DESTROY,0,0); }
// PushEvent: same as GenerateEvent, but the event is only generated at the end of MMF's event loop
_inline void PushEvent(LPRDATA rdPtr, int EventID)
{ callRunTimeFunction(rdPtr,RFUNCTION_PUSHEVENT,EventID,0); }
void JNICALL JVM::MMF2_Funcs_Position(JNIEnv *env, jobject obj, jint x, jint y)
{
callRunTimeFunction(GrabPtr<RD>(env, obj), RFUNCTION_SETPOSITION, x, y);
}
void JNICALL JVM::MMF2_Funcs_Redraw(JNIEnv *env, jobject obj)
{
callRunTimeFunction(GrabPtr<RD>(env, obj), RFUNCTION_REDRAW, 0, 0);
}
void JNICALL JVM::MMF2_Funcs_Rehandle(JNIEnv *env, jobject obj)
{
callRunTimeFunction(GrabPtr<RD>(env, obj), RFUNCTION_REHANDLE, 0, 0);
}
void JNICALL JVM::MMF2_Funcs_TriggerCondition(JNIEnv *env, jobject obj, jobject RunExt, jint ID)
{
callRunTimeFunction(GrabPtr<RD>(env, obj), RFUNCTION_GENERATEEVENT, ID, 0);
}
