public Result_MessageBox_Get Get(ref ThreadP2Ctrl_Message Message)
{
Result_MessageBox_Get res = Result_MessageBox_Get.TIMEOUT;
if (myMutex.WaitOne(3000))
{
if (message_buff.Get(ref Message))
{
if (Message.Message == ThreadP2Ctrl_Message.eMessage.ERROR)
{
res = Result_MessageBox_Get.ERROR;
}
else
{
res = Result_MessageBox_Get.OK;
}
}
else
{
res = Result_MessageBox_Get.EMPTY;
}
myMutex.ReleaseMutex();
}
else
{
//Timeout !
res = Result_MessageBox_Get.TIMEOUT;
}
return res;
}
private void Run(object othdata)
{
ThreadData thdata = (ThreadData)othdata;
ThreadP2Ctrl_MessageBox xThreadP2Ctrl_MessageBox = thdata.m_ThreadP2Ctrl_MessageBox;
ThreadP_Message p_message = new ThreadP_Message(0, ThreadP_Message.eMessage.NONE, null,null);
ThreadP2Ctrl_Message xThreadP2Ctrl_Message = new ThreadP2Ctrl_Message(0, ThreadP2Ctrl_Message.eMessage.START, null,null,null);
xThreadP2Ctrl_MessageBox.Post(xThreadP2Ctrl_Message);
for (;;)
{
switch (message_box.Get(ref p_message))
{
case Result_MessageBox_Get.OK:
switch (p_message.Message)
{
case ThreadP_Message.eMessage.TASK:
ThreadP_Message.delegate_Procedure proc = p_message.Procedure;
object oParam = p_message.ParameterAsObject;
string Err = null;
object oResult = proc(oParam, ref Err);
if (oResult is bool)
{
if (!(bool)oResult)
{
xThreadP2Ctrl_Message.Set(0, ThreadP2Ctrl_Message.eMessage.ERROR, proc, oResult, Err);
}
else
{
xThreadP2Ctrl_Message.Set(0, ThreadP2Ctrl_Message.eMessage.MESSAGE, proc, oResult, Err);
}
}
else
{
xThreadP2Ctrl_Message.Set(0, ThreadP2Ctrl_Message.eMessage.MESSAGE, proc, oResult, Err);
}
xThreadP2Ctrl_MessageBox.Post(xThreadP2Ctrl_Message);
break;
case ThreadP_Message.eMessage.END:
xThreadP2Ctrl_Message.Set(0, ThreadP2Ctrl_Message.eMessage.END, null,null,null);
xThreadP2Ctrl_MessageBox.Post(xThreadP2Ctrl_Message);
return;
}
break;
case Result_MessageBox_Get.TIMEOUT:
break;
}
}
}
public CircularBuffer_ThreadP2Ctrl_Message(int xLength)
{
if (xLength > 0)
{
m_Length = xLength;
m_obuff = new ThreadP2Ctrl_Message[m_Length];
for (int i = 0; i < m_Length; i++)
{
ThreadP2Ctrl_Message mfvi = new ThreadP2Ctrl_Message(0, ThreadP2Ctrl_Message.eMessage.NONE, null,null,null);
m_obuff[i] = mfvi;
}
}
pIn = 0;
pOut = 0;
}
public bool Get(ref ThreadP2Ctrl_Message msg)
{
if (pOut != pIn)
{
msg.Set(m_obuff[pOut].Message_ID,
m_obuff[pOut].Message,
m_obuff[pOut].Procedure,
m_obuff[pOut].oResult,
m_obuff[pOut].ErrorMessage);
m_obuff[pOut].Do_Dispose();
pOut = Next(pOut);
return true;
}
else
{
return false;
}
}
public Result_MessageBox_Post Post(ThreadP2Ctrl_Message Message)
{
Result_MessageBox_Post res = Result_MessageBox_Post.TIMEOUT;
if (myMutex.WaitOne(3000))
{
if (message_buff.PutIn(Message))
{
res = Result_MessageBox_Post.OK;
}
else
{
res = Result_MessageBox_Post.FULL;
}
myMutex.ReleaseMutex();
}
else
{
res = Result_MessageBox_Post.TIMEOUT;
}
return res;
}
public bool End()
{
ThreadP2Ctrl_Message xThreadP2Ctrl_Message_END = new ThreadP2Ctrl_Message(0, ThreadP2Ctrl_Message.eMessage.NONE, null,null,null);
ThreadP_Message ThreadP_message_END = new ThreadP_Message(0, ThreadP_Message.eMessage.END, null,null);
message_box.Post(ThreadP_message_END);
long StartTicks = DateTime.Now.Ticks;
for (;;)
{
if (m_ThreadP2Ctrl_MessageBox.Get(ref xThreadP2Ctrl_Message_END) == Result_MessageBox_Get.OK)
{
if (xThreadP2Ctrl_Message_END.Message == ThreadP2Ctrl_Message.eMessage.END)
{
return true;
}
}
if ((DateTime.Now.Ticks - StartTicks) > 100000000)
{
return false;
}
}
}
public bool PutIn(ThreadP2Ctrl_Message msg)
{
int pInNext = Next(pIn);
if (pInNext == pOut)
{
return false;
}
else
{
m_obuff[pIn].Set(msg.Message_ID,
msg.Message,
msg.Procedure,
msg.oResult,
msg.ErrorMessage
);
pIn = pInNext;
return true;
}
}
