//<qmail>
// -----------------------------------------------------------------------------
// CFSMailMessage::SaveMessageL
// -----------------------------------------------------------------------------
EXPORT_C TInt CFSMailMessage::SaveMessageL( MFSMailRequestObserver& aOperationObserver )
{
NM_FUNCTION;
TFSPendingRequest request;
request.iRequestId = 0;
if (CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
request = iRequestHandler->InitAsyncRequestL(GetMessageId().PluginId(),
aOperationObserver);
MFSMailRequestObserver* observer = request.iObserver;
iMessageBufferForAsyncOp.Reset();
iMessageBufferForAsyncOp.AppendL(this);
// It saves only message header - notice that iMessageBufferForAsyncOp ownership is not transferred
// to plugin - array contains 'self' pointer so it should not be destroy by plugin
TRAPD(err, plugin->StoreMessagesL(GetMailBoxId(), iMessageBufferForAsyncOp,
*observer, request.iRequestId));
if(err != KErrNone)
{
iRequestHandler->CompleteRequest(request.iRequestId);
User::Leave(err);
}
}
else
{
User::Leave(KErrNotFound);
}
return request.iRequestId;
}
// <qmail>
// -----------------------------------------------------------------------------
// CFSMailMessage::AddNewAttachmentL
// -----------------------------------------------------------------------------
EXPORT_C TInt CFSMailMessage::AddNewAttachmentL( const TDesC& aFilePath,
MFSMailRequestObserver& aOperationObserver)
{
NM_FUNCTION;
TFSPendingRequest request;
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
// init asynchronous request
request = iRequestHandler->InitAsyncRequestL( GetMessageId().PluginId(),
aOperationObserver );
MFSMailRequestObserver* observer = request.iObserver;
// use recognizer to find out ContentType
RApaLsSession apaSession;
TDataRecognitionResult dataType;
TBufC8<KMaxDataTypeLength> buf;
User::LeaveIfError(apaSession.Connect());
User::LeaveIfError(apaSession.RecognizeData(aFilePath, buf, dataType));
apaSession.Close();
// Create new message part with correct Content-Type
TBuf<KMaxDataTypeLength> contentType;
contentType.Copy(dataType.iDataType.Des());
TRAPD( err, plugin->NewChildPartFromFileL(
GetMailBoxId(),
GetFolderId(),
GetMessageId(),
GetPartId(),
contentType,
aFilePath,
*observer,
request.iRequestId) );
if( err != KErrNone )
{
iRequestHandler->CompleteRequest( request.iRequestId );
User::Leave( err );
}
}
else
{
User::Leave( KErrNotFound );
}
return request.iRequestId;
}
wMessage* freerdp_event_new(UINT16 event_class, UINT16 event_type,
MESSAGE_FREE_FN on_event_free_callback, void* user_data)
{
wMessage* event = NULL;
switch (event_class)
{
case DebugChannel_Class:
event = (wMessage*) malloc(sizeof(wMessage));
ZeroMemory(event, sizeof(wMessage));
break;
case CliprdrChannel_Class:
event = freerdp_cliprdr_event_new(event_type);
break;
case TsmfChannel_Class:
event = freerdp_tsmf_event_new(event_type);
break;
case RailChannel_Class:
event = freerdp_rail_event_new(event_type);
break;
}
if (event)
{
event->wParam = user_data;
event->Free = (void*) on_event_free_callback;
event->id = GetMessageId(event_class, event_type);
}
return event;
}
//--------------------------------------------------------------------------------
bool CFileChangeNotificationContextObj::PostChanges()
{
DWORD nOffset = 0;
for(;;)
{
FILE_NOTIFY_INFORMATION* pOrigInfo = (FILE_NOTIFY_INFORMATION*) (m_pBase + nOffset);
CFileChangeNotificationObj* pInfo = new CFileChangeNotificationObj(pOrigInfo, GetPath());
nOffset += pOrigInfo->NextEntryOffset;
if(pInfo->m_nAction == FILE_ACTION_RENAMED_OLD_NAME)
{
delete m_pPrevRenameObj;
m_pPrevRenameObj = pInfo;
}
else
{
if(pInfo->m_nAction == FILE_ACTION_RENAMED_NEW_NAME)
{
if(m_pPrevRenameObj == NULL)
{
delete pInfo;
return false;
}
pInfo->m_pOldFilename = AllocString(m_pPrevRenameObj->m_pFilename);
delete m_pPrevRenameObj;
m_pPrevRenameObj = NULL;
}
m_pTarget->PostMessage(GetMessageId(), (WPARAM) pInfo);
}
if(pOrigInfo->NextEntryOffset == 0)
return true;
}
}
static LRESULT CALLBACK WindowMessageHookProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static int x = INVALID_VALUE;
static int y = INVALID_VALUE;
static int font_height = INVALID_VALUE;
switch (msg) {
case WM_IME_STARTCOMPOSITION:
case WM_IME_COMPOSITION:
if (x != INVALID_VALUE && y != INVALID_VALUE && font_height != INVALID_VALUE) {
SetInlinePosition(hWnd, x, y, font_height);
}
break;
default:
if (msg == GetMessageId()) {
if (wParam != INVALID_VALUE && lParam != INVALID_VALUE) {
x = (wParam >> 16) & 0xffff;
y = wParam & 0xffff;
font_height = lParam;
}
else {
x = INVALID_VALUE;
y = INVALID_VALUE;
font_height = INVALID_VALUE;
}
}
bool nsMsgHdr::IsParentOf(nsIMsgDBHdr *possibleChild)
{
uint16_t referenceToCheck = 0;
possibleChild->GetNumReferences(&referenceToCheck);
nsAutoCString reference;
nsCString messageId;
GetMessageId(getter_Copies(messageId));
while (referenceToCheck > 0)
{
possibleChild->GetStringReference(referenceToCheck - 1, reference);
if (reference.Equals(messageId))
return true;
// if reference didn't match, check if this ref is for a non-existent
// header. If it is, continue looking at ancestors.
nsCOMPtr <nsIMsgDBHdr> refHdr;
if (!m_mdb)
break;
(void) m_mdb->GetMsgHdrForMessageID(reference.get(), getter_AddRefs(refHdr));
if (refHdr)
break;
referenceToCheck--;
}
return false;
}
// -----------------------------------------------------------------------------
// CFSMailMessage::AddNewAttachmentL
// -----------------------------------------------------------------------------
EXPORT_C CFSMailMessagePart* CFSMailMessage::AddNewAttachmentL( RFile& aFile,
const TDesC8& aMimeType )
{
NM_FUNCTION;
CFSMailMessagePart* newPart(NULL);
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
TBuf<KMaxDataTypeLength> contentType;
if(aMimeType.Length() > 0)
{
// use user given content type
contentType.Copy(aMimeType);
}
else
{
// try to find out content type using recognizers
RApaLsSession apaSession;
TDataRecognitionResult dataType;
User::LeaveIfError(apaSession.Connect());
User::LeaveIfError(apaSession.RecognizeData(aFile, dataType));
apaSession.Close();
contentType.Copy(dataType.iDataType.Des());
}
// get file name
TFileName fileName;
aFile.FullName( fileName );
// get new part from plugin
newPart = plugin->NewChildPartFromFileL( GetMailBoxId(),
GetFolderId(),
GetMessageId(),
GetPartId(),
contentType,
aFile );
if (newPart)
{
CleanupStack::PushL(newPart);
// set attachment name
newPart->SetAttachmentNameL(fileName);
// store new message part
newPart->SaveL();
// set flag
SetFlag(EFSMsgFlag_Attachments);
CleanupStack::Pop(newPart);
}
}
return newPart;
}
//<qmail>
// -----------------------------------------------------------------------------
// CFSMailMessage::SaveMessagePartsL
// -----------------------------------------------------------------------------
EXPORT_C TInt CFSMailMessage::SaveMessagePartsL( MFSMailRequestObserver& aOperationObserver )
{
NM_FUNCTION;
RPointerArray<CFSMailMessagePart> messageParts;
CleanupResetAndDestroyPushL(messageParts);
CFSMailMessagePart *plainTextPart = PlainTextBodyPartL(EDataSourceLocal);
if (plainTextPart)
{
messageParts.AppendL(plainTextPart);
}
CFSMailMessagePart *htmlPart = HtmlBodyPartL(EDataSourceLocal);
if (htmlPart)
{
messageParts.AppendL(htmlPart);
}
TFSPendingRequest request;
request.iRequestId = 0;
if (CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
request = iRequestHandler->InitAsyncRequestL(
GetMessageId().PluginId(), aOperationObserver);
MFSMailRequestObserver* observer = request.iObserver;
// Ownership of parts array is transferred to plugin - it will take care about reseting them
TRAPD(err, plugin->StoreMessagePartsL(messageParts, *observer,
request.iRequestId));
if(err != KErrNone)
{
iRequestHandler->CompleteRequest(request.iRequestId);
User::Leave(err);
}
// message parts array removed from CleanupStack (not destroyed)
CleanupStack::Pop(1, &messageParts);
}
else
{
// message parts array removed from CleanupStack and destroyed
CleanupStack::PopAndDestroy(1, &messageParts);
User::Leave(KErrNotFound);
}
return request.iRequestId;
}
// -----------------------------------------------------------------------------
// CFSMailMessage::SaveMessageL
// -----------------------------------------------------------------------------
EXPORT_C void CFSMailMessage::SaveMessageL()
{
NM_FUNCTION;
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
plugin->StoreMessageL(GetMailBoxId(),*this);
}
}
///////////////////////////////////////////////////////////////////////////////
///@author Ghervase Gabriel
///@brief < operator
///@retval true fragments are <
///@retval false fragments not <
///@param [in] p_rRight - fragment to compare to
///////////////////////////////////////////////////////////////////////////////
bool CFragment::operator<(const CFragment& p_rRight) const
{
if ( (memcmp(GetSrcAddr(), p_rRight.GetSrcAddr(), p_rRight.GetAddressSize()) != 0) ||
GetMessageId() != p_rRight.GetMessageId() )
{ NLOG_ERR ("[Fragment] - Cannot compare fragments belonging to different messages");
return false;
}
return GetFragmentId() < p_rRight.GetFragmentId();
}
// -----------------------------------------------------------------------------
// CFSMailMessage::AddNewAttachmentL
// -----------------------------------------------------------------------------
EXPORT_C CFSMailMessagePart* CFSMailMessage::AddNewAttachmentL( const TDesC& aFilePath,
const TFSMailMsgId /*aInsertBefore*/ )
{
NM_FUNCTION;
CFSMailMessagePart* newPart(NULL);
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
// use recognizer to find out ContentType
RApaLsSession apaSession;
TDataRecognitionResult dataType;
TBufC8<KMaxDataTypeLength> buf;
User::LeaveIfError(apaSession.Connect());
User::LeaveIfError(apaSession.RecognizeData(aFilePath, buf, dataType));
apaSession.Close();
// Create new message part with correct Content-Type
TBuf<KMaxDataTypeLength> contentType;
contentType.Copy(dataType.iDataType.Des());
newPart = plugin->NewChildPartFromFileL( GetMailBoxId(),
GetFolderId(),
GetMessageId(),
GetPartId(),
contentType,
aFilePath );
if (newPart)
{
CleanupStack::PushL(newPart);
// set attachment name
newPart->SetAttachmentNameL(aFilePath);
// store new message part
newPart->SaveL();
// set flag
SetFlag(EFSMsgFlag_Attachments);
CleanupStack::Pop(newPart);
}
}
return newPart;
}
bool nsMsgHdr::IsAncestorOf(nsIMsgDBHdr *possibleChild)
{
const char *references;
nsMsgHdr* curHdr = static_cast<nsMsgHdr*>(possibleChild); // closed system, cast ok
m_mdb->RowCellColumnToConstCharPtr(curHdr->GetMDBRow(), m_mdb->m_referencesColumnToken, &references);
if (!references)
return false;
nsCString messageId;
// should put < > around message id to make strstr strictly match
GetMessageId(getter_Copies(messageId));
return (strstr(references, messageId.get()) != nullptr);
}
nsresult nsMsgHdr::ParseReferences(const char *references)
{
const char *startNextRef = references;
nsAutoCString resultReference;
nsCString messageId;
GetMessageId(getter_Copies(messageId));
while (startNextRef && *startNextRef)
{
startNextRef = GetNextReference(startNextRef, resultReference,
startNextRef == references);
// Don't add self-references.
if (!resultReference.IsEmpty() && !resultReference.Equals(messageId))
m_references.AppendElement(resultReference);
}
return NS_OK;
}
//--------------------------------------------------------------------------------
bool CRegChangeNotificationContextObj::PostChanges()
{
CRegChangeNotificationObj* pInfo = new CRegChangeNotificationObj(m_hKey);
m_pTarget->PostMessage(GetMessageId(), (WPARAM) pInfo);
return true;
}
//--------------------------------------------------------------------------------------------------------------//
void CTracer::TraceMessage(MessageTypeEnum Type, LPCTSTR szSource, LPCTSTR pszMessage, ...)
{
TCHAR szDate[64];
if (0 == ::GetDateFormat(
LOCALE_USER_DEFAULT,
DATE_SHORTDATE,
NULL,
NULL,
szDate,
sizeof(szDate)/sizeof(TCHAR)))
{
szDate[0] = _T('?');
szDate[1] = _T('\0');
}
TCHAR szTime[32];
if (0 == ::GetTimeFormat(
LOCALE_USER_DEFAULT,
LOCALE_NOUSEROVERRIDE,
NULL,
NULL,
szTime,
sizeof(szTime)/sizeof(TCHAR)))
{
szTime[0] = _T('?');
szTime[1] = _T('\0');
}
TCHAR cType;
switch (Type)
{
case enMtInformation:
cType = _T('I');
break;
case enMtWarning:
cType = _T('W');
break;
case enMtError:
cType = _T('E');
break;
default:
cType = _T('?');
}
va_list arglist;
va_start(arglist, pszMessage);
TCHAR szMessage[4096];
_vsntprintf_s(szMessage,sizeof(szMessage), 4096, pszMessage, arglist);
TCHAR szOutputLine[4096];
::wsprintf(
szOutputLine,
_T("[%#04X] %s %s %c %s %s"),
::GetCurrentThreadId(),
szDate,
szTime,
cType,
szMessage, szSource!=NULL?szSource:_T(""));
if (m_Destination & enMdWindow)
{
HWND hWnd = GetWindowHandle();
sMessage Msg;
Msg.szMessage = szMessage;
Msg.szSource = szSource;
if (hWnd) ::SendMessage(hWnd, GetMessageId(), Type, reinterpret_cast<LPARAM>(&Msg));
}
::lstrcat(szOutputLine, _T("\n"));
if (m_Destination & enMdDebug)
::OutputDebugString(szOutputLine);
if (m_Destination & enMdFile)
WriteMessageToFile(szOutputLine);
}
///////////////////////////////////////////////////////////////////////////////
///@author Ghervase Gabriel
///@brief == operator
///@retval true fragments are equal
///@retval false fragments are different
///@param [in] p_rRight - fragment to compare to
///////////////////////////////////////////////////////////////////////////////
bool CFragment::operator==(const CFragment& p_rRight) const
{
return GetSrcAddr() == p_rRight.GetSrcAddr() &&
GetMessageId() == p_rRight.GetMessageId() &&
GetFragmentId() == p_rRight.GetFragmentId();
}
void CallbackParameters::PrintDebug()
{
#if(DEBUG_PARAMS)
Utils::OutputDebug(kInfo, "- Message: %s %d\n", mMessageName ? mMessageName : "<unknown>", GetMessageId());
for(int i = 0; i < mNumParameters; ++i)
{
switch(mVariables[i].mtype)
{
case GM_NULL:
{
EngineFuncs::ConsoleMessage(va(" + Null: %s\n", mDebugNames[i]));
break;
}
case GM_INT:
{
EngineFuncs::ConsoleMessage(va(" + Int: %s, %d\n", mDebugNames[i], mVariables[i].GetInt()));
break;
}
case GM_FLOAT:
{
EngineFuncs::ConsoleMessage(va(" + Float: %s, %f\n", mDebugNames[i], mVariables[i].GetFloat()));
break;
}
case GM_VEC3:
{
float x,y,z;
mVariables[i].GetVector(x,y,z);
EngineFuncs::ConsoleMessage(va(" + Vector: %s, (%f, %f, %f)\n", mDebugNames[i], x,y,z));
break;
}
case GM_ENTITY:
{
EngineFuncs::ConsoleMessage(va(" + Entity: %s, %X\n", mDebugNames[i], mVariables[i].GetEntity()));
break;
}
case GM_STRING:
{
gmStringObject *pStr = mVariables[i].GetStringObjectSafe();
EngineFuncs::ConsoleMessage(va(" + std::string: %s, \"%s\"\n", mDebugNames[i], pStr->GetString()));
break;
}
case GM_TABLE:
{
EngineFuncs::ConsoleMessage(va(" + Table: %s, %X\n", mDebugNames[i], mVariables[i].GetTableObjectSafe()));
break;
}
case GM_FUNCTION:
{
gmFunctionObject *pFunc = mVariables[i].GetFunctionObjectSafe();
EngineFuncs::ConsoleMessage(va(" + Func: %s, %s\n", mDebugNames[i], pFunc->GetDebugName()));
break;
}
default:
{
EngineFuncs::ConsoleMessage(va(" + UserObj: %s, %X\n", mDebugNames[i], mVariables[i]..mvalue..mref));
}
}
}
#endif
}
