static INT_PTR Service_AddEvent(WPARAM wParam, LPARAM lParam)
{
GCEVENT *gce = (GCEVENT*)lParam, save_gce;
GCDEST *gcd = NULL, save_gcd;
TCHAR* pWnd = NULL;
char* pMod = NULL;
BOOL bIsHighlighted = FALSE;
BOOL bRemoveFlag = FALSE;
int iRetVal = GC_EVENT_ERROR;
if ( gce == NULL )
return GC_EVENT_ERROR;
gcd = gce->pDest;
if ( gcd == NULL )
return GC_EVENT_ERROR;
if ( gce->cbSize != SIZEOF_STRUCT_GCEVENT_V1 && gce->cbSize != SIZEOF_STRUCT_GCEVENT_V2 )
return GC_EVENT_WRONGVER;
if ( !IsEventSupported( gcd->iType ) )
return GC_EVENT_ERROR;
EnterCriticalSection(&cs);
#if defined( _UNICODE )
if ( !( gce->dwFlags & GC_UNICODE )) {
save_gce = *gce;
save_gcd = *gce->pDest;
gce->pDest->ptszID = a2tf( gce->pDest->ptszID, gce->dwFlags );
gce->ptszUID = a2tf( gce->ptszUID, gce->dwFlags );
gce->ptszNick = a2tf( gce->ptszNick, gce->dwFlags );
gce->ptszStatus = a2tf( gce->ptszStatus, gce->dwFlags );
gce->ptszText = a2tf( gce->ptszText, gce->dwFlags );
gce->ptszUserInfo = a2tf( gce->ptszUserInfo, gce->dwFlags );
}
#endif
// Do different things according to type of event
switch(gcd->iType) {
case GC_EVENT_ADDGROUP:
{
STATUSINFO* si = SM_AddStatus( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszStatus);
if ( si && gce->dwItemData)
si->hIcon = CopyIcon((HICON)gce->dwItemData);
}
iRetVal = 0;
goto LBL_Exit;
case GC_EVENT_CHUID:
case GC_EVENT_CHANGESESSIONAME:
case GC_EVENT_SETITEMDATA:
case GC_EVENT_GETITEMDATA:
case GC_EVENT_CONTROL:
case GC_EVENT_SETSBTEXT:
case GC_EVENT_ACK:
case GC_EVENT_SENDMESSAGE :
case GC_EVENT_SETSTATUSEX :
iRetVal = DoControl(gce, wParam);
goto LBL_Exit;
case GC_EVENT_SETCONTACTSTATUS:
iRetVal = SM_SetContactStatus( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszUID, (WORD)gce->dwItemData );
goto LBL_Exit;
case GC_EVENT_TOPIC:
{
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if ( si ) {
if ( gce->pszText ) {
replaceStr( &si->ptszTopic, gce->ptszText);
DBWriteContactSettingTString( si->windowData.hContact, si->pszModule , "Topic", RemoveFormatting( si->ptszTopic ));
if ( DBGetContactSettingByte( NULL, "Chat", "TopicOnClist", 0 ))
DBWriteContactSettingTString( si->windowData.hContact, "CList" , "StatusMsg", RemoveFormatting( si->ptszTopic ));
} }
break;
}
case GC_EVENT_ADDSTATUS:
SM_GiveStatus( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszUID, gce->ptszStatus );
break;
case GC_EVENT_REMOVESTATUS:
SM_TakeStatus( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszUID, gce->ptszStatus);
break;
case GC_EVENT_MESSAGE:
case GC_EVENT_ACTION:
if ( !gce->bIsMe && gce->pDest->pszID && gce->pszText ) {
SESSION_INFO* si = SM_FindSession( gce->pDest->ptszID, gce->pDest->pszModule );
if ( si )
if ( IsHighlighted( si, gce->ptszText ))
bIsHighlighted = TRUE;
}
break;
case GC_EVENT_NICK:
SM_ChangeNick( gce->pDest->ptszID, gce->pDest->pszModule, gce);
break;
case GC_EVENT_JOIN:
AddUser(gce);
break;
case GC_EVENT_PART:
case GC_EVENT_QUIT:
case GC_EVENT_KICK:
bRemoveFlag = TRUE;
break;
}
// Decide which window (log) should have the event
if ( gcd->pszID ) {
pWnd = gcd->ptszID;
pMod = gcd->pszModule;
}
else if ( gcd->iType == GC_EVENT_NOTICE || gcd->iType == GC_EVENT_INFORMATION ) {
SESSION_INFO* si = GetActiveSession();
if ( si && !lstrcmpA( si->pszModule, gcd->pszModule )) {
pWnd = si->ptszID;
pMod = si->pszModule;
}
else {
iRetVal = 0;
goto LBL_Exit;
}
}
else {
// Send the event to all windows with a user pszUID. Used for broadcasting QUIT etc
SM_AddEventToAllMatchingUID( gce );
if ( !bRemoveFlag ) {
iRetVal = 0;
goto LBL_Exit;
} }
// add to log
if ( pWnd ) {
SESSION_INFO* si = SM_FindSession(pWnd, pMod);
// fix for IRC's old stuyle mode notifications. Should not affect any other protocol
if ((gce->pDest->iType == GC_EVENT_ADDSTATUS || gce->pDest->iType == GC_EVENT_REMOVESTATUS) && !( gce->dwFlags & GCEF_ADDTOLOG )) {
iRetVal = 0;
goto LBL_Exit;
}
if (gce && gce->pDest->iType == GC_EVENT_JOIN && gce->time == 0) {
iRetVal = 0;
goto LBL_Exit;
}
if (si && (si->bInitDone || gce->pDest->iType == GC_EVENT_TOPIC || (gce->pDest->iType == GC_EVENT_JOIN && gce->bIsMe))) {
if (SM_AddEvent(pWnd, pMod, gce, bIsHighlighted) && si->hWnd) {
SendMessage(si->hWnd, GC_ADDLOG, 0, 0);
}
else if (si->hWnd) {
SendMessage(si->hWnd, GC_REDRAWLOG2, 0, 0);
}
DoSoundsFlashPopupTrayStuff(si, gce, bIsHighlighted, 0);
if ((gce->dwFlags & GCEF_ADDTOLOG) && g_Settings.LoggingEnabled)
LogToFile(si, gce);
}
if ( !bRemoveFlag ) {
iRetVal = 0;
goto LBL_Exit;
} }
if ( bRemoveFlag )
iRetVal = ( SM_RemoveUser( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszUID ) == 0 ) ? 1 : 0;
LBL_Exit:
LeaveCriticalSection(&cs);
#if defined( _UNICODE )
if ( !( gce->dwFlags & GC_UNICODE )) {
mir_free((void*)gce->ptszText );
mir_free((void*)gce->ptszNick );
mir_free((void*)gce->ptszUID );
mir_free((void*)gce->ptszStatus );
mir_free((void*)gce->ptszUserInfo );
mir_free((void*)gce->pDest->ptszID );
*gce = save_gce;
*gce->pDest = save_gcd;
}
#endif
return iRetVal;
}
size_t Printer::doPrint(bool justDoIt)
{/*
if (!::PrintDlg(&_pdlg))
return 0;
*/
const NppGUI & nppGUI = (NppParameters::getInstance())->getNppGUI();
POINT ptPage;
POINT ptDpi;
RECT rectMargins;
RECT rectPhysMargins;
RECT userMargins;
// Get printer resolution
ptDpi.x = GetDeviceCaps(_pdlg.hDC, LOGPIXELSX); // dpi in X direction
ptDpi.y = GetDeviceCaps(_pdlg.hDC, LOGPIXELSY); // dpi in Y direction
// Start by getting the physical page size (in device units).
ptPage.x = GetDeviceCaps(_pdlg.hDC, PHYSICALWIDTH); // device units
ptPage.y = GetDeviceCaps(_pdlg.hDC, PHYSICALHEIGHT); // device units
// Get the dimensions of the unprintable
// part of the page (in device units).
rectPhysMargins.left = GetDeviceCaps(_pdlg.hDC, PHYSICALOFFSETX);
rectPhysMargins.top = GetDeviceCaps(_pdlg.hDC, PHYSICALOFFSETY);
// To get the right and lower unprintable area,
// we take the entire width and height of the paper and
// subtract everything else.
rectPhysMargins.right = ptPage.x // total paper width
- GetDeviceCaps(_pdlg.hDC, HORZRES) // printable width
- rectPhysMargins.left; // left unprintable margin
rectPhysMargins.bottom = ptPage.y // total paper height
- GetDeviceCaps(_pdlg.hDC, VERTRES) // printable height
- rectPhysMargins.top; // right unprintable margin
if (nppGUI._printSettings.isUserMargePresent())
{
userMargins.left = MulDiv(nppGUI._printSettings._marge.left*100, ptDpi.x, 2540);
userMargins.top = MulDiv(nppGUI._printSettings._marge.top*100, ptDpi.y, 2540);
userMargins.right = MulDiv(nppGUI._printSettings._marge.right*100, ptDpi.x, 2540);
userMargins.bottom = MulDiv(nppGUI._printSettings._marge.bottom*100, ptDpi.y, 2540);
rectMargins.left = max(rectPhysMargins.left, userMargins.left);
rectMargins.top = max(rectPhysMargins.top, userMargins.top);
rectMargins.right = max(rectPhysMargins.right, userMargins.right);
rectMargins.bottom = max(rectPhysMargins.bottom, userMargins.bottom);
}
else
{
rectMargins.left = rectPhysMargins.left;
rectMargins.top = rectPhysMargins.top;
rectMargins.right = rectPhysMargins.right;
rectMargins.bottom = rectPhysMargins.bottom;
}
// Convert device coordinates into logical coordinates
DPtoLP(_pdlg.hDC, (LPPOINT)&rectMargins, 2);
DPtoLP(_pdlg.hDC, (LPPOINT)&rectPhysMargins, 2);
// Convert page size to logical units and we're done!
DPtoLP(_pdlg.hDC, &ptPage, 1);
TEXTMETRIC tm;
int fontSize = nppGUI._printSettings._headerFontSize?nppGUI._printSettings._headerFontSize:9;
int fontWeight = nppGUI._printSettings._headerFontStyle & FONTSTYLE_BOLD?FW_BOLD:FW_NORMAL;
int isFontItalic = nppGUI._printSettings._headerFontStyle & FONTSTYLE_ITALIC?TRUE:FALSE;
const TCHAR *fontFace = (nppGUI._printSettings._headerFontName != TEXT(""))?nppGUI._printSettings._headerFontName.c_str():TEXT("Arial");
int headerLineHeight = ::MulDiv(fontSize, ptDpi.y, 72);
//TCHAR toto[10];
//::MessageBox(NULL, itoa(nppGUI._printSettings._headerFontStyle, toto, 10), TEXT("header"), MB_OK);
HFONT fontHeader = ::CreateFont(headerLineHeight,
0, 0, 0,
fontWeight,
isFontItalic,
FALSE,
0, 0, 0,
0, 0, 0,
fontFace);
::SelectObject(_pdlg.hDC, fontHeader);
::GetTextMetrics(_pdlg.hDC, &tm);
headerLineHeight = tm.tmHeight + tm.tmExternalLeading;
fontSize = nppGUI._printSettings._footerFontSize?nppGUI._printSettings._footerFontSize:9;
fontWeight = nppGUI._printSettings._footerFontStyle & FONTSTYLE_BOLD?FW_BOLD:FW_NORMAL;
isFontItalic = nppGUI._printSettings._footerFontStyle & FONTSTYLE_ITALIC?TRUE:FALSE;
fontFace = (nppGUI._printSettings._footerFontName != TEXT(""))?nppGUI._printSettings._footerFontName.c_str():TEXT("Arial");
//::MessageBox(NULL, itoa(nppGUI._printSettings._footerFontStyle, , 10), TEXT("footer"), MB_OK);
int footerLineHeight = ::MulDiv(fontSize, ptDpi.y, 72);
HFONT fontFooter = ::CreateFont(footerLineHeight,
0, 0, 0,
fontWeight,
isFontItalic,
FALSE,
0, 0, 0,
0, 0, 0,
fontFace);
::SelectObject(_pdlg.hDC, fontFooter);
::GetTextMetrics(_pdlg.hDC, &tm);
footerLineHeight = tm.tmHeight + tm.tmExternalLeading;
::GetTextMetrics(_pdlg.hDC, &tm);
int printMarge = tm.tmHeight + tm.tmExternalLeading;
printMarge = printMarge + printMarge / 2;
DOCINFO docInfo;
docInfo.cbSize = sizeof(DOCINFO);
docInfo.lpszDocName = _pSEView->getCurrentBuffer()->getFullPathName();
docInfo.lpszOutput = NULL;
if (::StartDoc(_pdlg.hDC, &docInfo) < 0)
{
MessageBox(NULL, TEXT("Can not start printer document."), 0, MB_OK);
return 0;
}
// By default, we will print all the document
long lengthPrinted = 0;
long lengthDoc = _pSEView->getCurrentDocLen();
long lengthDocMax = lengthDoc;
// In the case that the print dialog was launched and that there's a range of selection
// We print the range of selection
if ((!(_pdlg.Flags & PD_RETURNDEFAULT)) && (_pdlg.Flags & PD_SELECTION))
{
if (_startPos > _endPos)
{
lengthPrinted = _endPos;
lengthDoc = _startPos;
}
else
{
lengthPrinted = _startPos;
lengthDoc = _endPos;
}
if (lengthPrinted < 0)
lengthPrinted = 0;
if (lengthDoc > lengthDocMax)
lengthDoc = lengthDocMax;
}
RangeToFormat frPrint;
frPrint.hdc = _pdlg.hDC;
frPrint.hdcTarget = _pdlg.hDC;
frPrint.rc.left = rectMargins.left - rectPhysMargins.left;
frPrint.rc.top = rectMargins.top - rectPhysMargins.top;
frPrint.rc.right = ptPage.x - rectMargins.right - rectPhysMargins.left;
frPrint.rc.bottom = ptPage.y - rectMargins.bottom - rectPhysMargins.top;
frPrint.rcPage.left = 0;
frPrint.rcPage.top = 0;
frPrint.rcPage.right = ptPage.x - rectPhysMargins.left - rectPhysMargins.right - 1;
frPrint.rcPage.bottom = ptPage.y - rectPhysMargins.top - rectPhysMargins.bottom - 1;
frPrint.rc.top += printMarge;
frPrint.rc.bottom -= printMarge;
frPrint.rc.left += printMarge;
frPrint.rc.right -= printMarge;
const int headerSize = 256;
TCHAR headerL[headerSize] = TEXT("");
TCHAR headerM[headerSize] = TEXT("");
TCHAR headerR[headerSize] = TEXT("");
TCHAR footerL[headerSize] = TEXT("");
TCHAR footerM[headerSize] = TEXT("");
TCHAR footerR[headerSize] = TEXT("");
const TCHAR shortDateVar[] = TEXT("$(SHORT_DATE)");
const TCHAR longDateVar[] = TEXT("$(LONG_DATE)");
const TCHAR timeVar[] = TEXT("$(TIME)");
const int bufferSize = 64;
TCHAR shortDate[bufferSize];
TCHAR longDate[bufferSize];
TCHAR time[bufferSize];
SYSTEMTIME st;
::GetLocalTime(&st);
::GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, shortDate, bufferSize);
::GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, longDate, bufferSize);
::GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, time, bufferSize);
if (nppGUI._printSettings.isHeaderPresent())
{
frPrint.rc.top += headerLineHeight + headerLineHeight / 2;
generic_string headerLeftPart = nppGUI._printSettings._headerLeft;
if (headerLeftPart != TEXT(""))
{
replaceStr(headerLeftPart, shortDateVar, shortDate);
replaceStr(headerLeftPart, longDateVar, longDate);
replaceStr(headerLeftPart, timeVar, time);
expandNppEnvironmentStrs(headerLeftPart.c_str(), headerL, headerSize, _pdlg.hwndOwner);
}
generic_string headerMiddlePart = nppGUI._printSettings._headerMiddle;
if (headerMiddlePart != TEXT(""))
{
replaceStr(headerMiddlePart, shortDateVar, shortDate);
replaceStr(headerMiddlePart, longDateVar, longDate);
replaceStr(headerMiddlePart, timeVar, time);
expandNppEnvironmentStrs(headerMiddlePart.c_str(), headerM, headerSize, _pdlg.hwndOwner);
}
generic_string headerRightPart = nppGUI._printSettings._headerRight;
if (headerRightPart != TEXT(""))
{
replaceStr(headerRightPart, shortDateVar, shortDate);
replaceStr(headerRightPart, longDateVar, longDate);
replaceStr(headerRightPart, timeVar, time);
expandNppEnvironmentStrs(headerRightPart.c_str(), headerR, headerSize, _pdlg.hwndOwner);
}
}
if (nppGUI._printSettings.isFooterPresent())
{
frPrint.rc.bottom -= footerLineHeight + footerLineHeight / 2;
generic_string footerLeftPart = nppGUI._printSettings._footerLeft;
if (footerLeftPart != TEXT(""))
{
replaceStr(footerLeftPart, shortDateVar, shortDate);
replaceStr(footerLeftPart, longDateVar, longDate);
replaceStr(footerLeftPart, timeVar, time);
expandNppEnvironmentStrs(footerLeftPart.c_str(), footerL, headerSize, _pdlg.hwndOwner);
}
generic_string footerMiddlePart = nppGUI._printSettings._footerMiddle;
if (footerMiddlePart != TEXT(""))
{
replaceStr(footerMiddlePart, shortDateVar, shortDate);
replaceStr(footerMiddlePart, longDateVar, longDate);
replaceStr(footerMiddlePart, timeVar, time);
expandNppEnvironmentStrs(footerMiddlePart.c_str(), footerM, headerSize, _pdlg.hwndOwner);
}
generic_string footerRightPart = nppGUI._printSettings._footerRight;
if (footerRightPart != TEXT(""))
{
replaceStr(footerRightPart, shortDateVar, shortDate);
replaceStr(footerRightPart, longDateVar, longDate);
replaceStr(footerRightPart, timeVar, time);
expandNppEnvironmentStrs(footerRightPart.c_str(), footerR, headerSize, _pdlg.hwndOwner);
}
}
bool isShown = _pSEView->hasMarginShowed(ScintillaEditView::_SC_MARGE_LINENUMBER);
if (!nppGUI._printSettings._printLineNumber)
_pSEView->showMargin(ScintillaEditView::_SC_MARGE_LINENUMBER, false);
size_t pageNum = 1;
bool printPage;
const TCHAR pageVar[] = TEXT("$(CURRENT_PRINTING_PAGE)");
while (lengthPrinted < lengthDoc)
{
printPage = (!(_pdlg.Flags & PD_PAGENUMS) ||
(pageNum >= _pdlg.nFromPage) && (pageNum <= _pdlg.nToPage));
if (!justDoIt)
printPage = false;
TCHAR pageString[32];
wsprintf(pageString, TEXT("%0d"), pageNum);
if (printPage)
{
::StartPage(_pdlg.hDC);
if (nppGUI._printSettings.isHeaderPresent())
{
::SelectObject(_pdlg.hDC, fontHeader);
::SetTextColor(_pdlg.hDC, RGB(0, 0, 0));
::SetBkColor(_pdlg.hDC, RGB(255, 255, 255));
UINT oldTASettings = ::SetTextAlign(_pdlg.hDC, TA_BOTTOM);
RECT rcw = {frPrint.rc.left, frPrint.rc.top - headerLineHeight - headerLineHeight / 2,
frPrint.rc.right, frPrint.rc.top - headerLineHeight / 2};
rcw.bottom = rcw.top + headerLineHeight;
SIZE size;
// Left part
if (headerL[0] != '\0')
{
generic_string headerLeft(headerL);
size_t pos = headerLeft.find(pageVar);
if (pos != generic_string::npos)
headerLeft.replace(pos, lstrlen(pageVar), pageString);
::ExtTextOut(_pdlg.hDC, frPrint.rc.left + 5, frPrint.rc.top - headerLineHeight / 2,
ETO_OPAQUE, &rcw, headerLeft.c_str(), static_cast<int>(headerLeft.length()), NULL);
}
// Middle part
if (headerM != '\0')
{
generic_string headerMiddle(headerM);
size_t pos = headerMiddle.find(pageVar);
if (pos != generic_string::npos)
headerMiddle.replace(pos, lstrlen(pageVar), pageString);
::GetTextExtentPoint32(_pdlg.hDC, headerMiddle.c_str(), static_cast<int>(headerMiddle.length()), &size);
::ExtTextOut(_pdlg.hDC, ((frPrint.rc.right - frPrint.rc.left)/2 + frPrint.rc.left) - (size.cx/2), frPrint.rc.top - headerLineHeight / 2,
ETO_CLIPPED, &rcw, headerMiddle.c_str(), static_cast<int>(headerMiddle.length()), NULL);
}
// Right part
if (headerR != '\0')
{
generic_string headerRight(headerR);
size_t pos = headerRight.find(pageVar);
if (pos != generic_string::npos)
headerRight.replace(pos, lstrlen(pageVar), pageString);
::GetTextExtentPoint32(_pdlg.hDC, headerRight.c_str(), static_cast<int>(headerRight.length()), &size);
::ExtTextOut(_pdlg.hDC, frPrint.rc.right - size.cx, frPrint.rc.top - headerLineHeight / 2,
ETO_CLIPPED, &rcw, headerRight.c_str(), static_cast<int>(headerRight.length()), NULL);
}
::SetTextAlign(_pdlg.hDC, oldTASettings);
HPEN pen = ::CreatePen(0, 1, 0x00000000);
HPEN penOld = static_cast<HPEN>(::SelectObject(_pdlg.hDC, pen));
::MoveToEx(_pdlg.hDC, frPrint.rc.left, frPrint.rc.top - headerLineHeight / 4, NULL);
::LineTo(_pdlg.hDC, frPrint.rc.right, frPrint.rc.top - headerLineHeight / 4);
::SelectObject(_pdlg.hDC, penOld);
::DeleteObject(pen);
}
}
frPrint.chrg.cpMin = lengthPrinted;
frPrint.chrg.cpMax = lengthDoc;
_pSEView->execute(SCI_SETPRINTCOLOURMODE, nppGUI._printSettings._printOption);
lengthPrinted = long(_pSEView->execute(SCI_FORMATRANGE, printPage, reinterpret_cast<LPARAM>(&frPrint)));
if (printPage)
{
if (nppGUI._printSettings.isFooterPresent())
{
::SelectObject(_pdlg.hDC, fontFooter);
::SetTextColor(_pdlg.hDC, RGB(0, 0, 0));
::SetBkColor(_pdlg.hDC, RGB(255, 255, 255));
UINT oldta = ::SetTextAlign(_pdlg.hDC, TA_TOP);
RECT rcw = {frPrint.rc.left, frPrint.rc.bottom + footerLineHeight / 2,
frPrint.rc.right, frPrint.rc.bottom + footerLineHeight + footerLineHeight / 2};
SIZE size;
// Left part
if (footerL[0] != '\0')
{
generic_string footerLeft(footerL);
size_t pos = footerLeft.find(pageVar);
if (pos != generic_string::npos)
footerLeft.replace(pos, lstrlen(pageVar), pageString);
::ExtTextOut(_pdlg.hDC, frPrint.rc.left + 5, frPrint.rc.bottom + footerLineHeight / 2,
ETO_OPAQUE, &rcw, footerLeft.c_str(), static_cast<int>(footerLeft.length()), NULL);
}
// Middle part
if (footerM[0] != '\0')
{
generic_string footerMiddle(footerM);
size_t pos = footerMiddle.find(pageVar);
if (pos != generic_string::npos)
footerMiddle.replace(pos, lstrlen(pageVar), pageString);
::GetTextExtentPoint32(_pdlg.hDC, footerMiddle.c_str(), static_cast<int>(footerMiddle.length()), &size);
::ExtTextOut(_pdlg.hDC, ((frPrint.rc.right - frPrint.rc.left)/2 + frPrint.rc.left) - (size.cx/2), frPrint.rc.bottom + footerLineHeight / 2,
ETO_CLIPPED, &rcw, footerMiddle.c_str(), static_cast<int>(footerMiddle.length()), NULL);
}
// Right part
if (footerR[0] != '\0')
{
generic_string footerRight(footerR);
size_t pos = footerRight.find(pageVar);
if (pos != generic_string::npos)
footerRight.replace(pos, lstrlen(pageVar), pageString);
::GetTextExtentPoint32(_pdlg.hDC, footerRight.c_str(), static_cast<int>(footerRight.length()), &size);
::ExtTextOut(_pdlg.hDC, frPrint.rc.right - size.cx, frPrint.rc.bottom + footerLineHeight / 2,
ETO_CLIPPED, &rcw, footerRight.c_str(), static_cast<int>(footerRight.length()), NULL);
}
::SetTextAlign(_pdlg.hDC, oldta);
HPEN pen = ::CreatePen(0, 1, 0x00000000);
HPEN penOld = static_cast<HPEN>(::SelectObject(_pdlg.hDC, pen));
::MoveToEx(_pdlg.hDC, frPrint.rc.left, frPrint.rc.bottom + footerLineHeight / 4, NULL);
::LineTo(_pdlg.hDC, frPrint.rc.right, frPrint.rc.bottom + footerLineHeight / 4);
::SelectObject(_pdlg.hDC, penOld);
::DeleteObject(pen);
}
::EndPage(_pdlg.hDC);
}
pageNum++;
if ((_pdlg.Flags & PD_PAGENUMS) && (pageNum > _pdlg.nToPage))
break;
}
//TCHAR toto[10];
//::MessageBox(NULL, itoa(pageNum, toto, 10), TEXT("page total"), MB_OK);
if (!nppGUI._printSettings._printLineNumber)
_pSEView->showMargin(ScintillaEditView::_SC_MARGE_LINENUMBER, isShown);
_pSEView->execute(SCI_FORMATRANGE, FALSE, 0);
::EndDoc(_pdlg.hDC);
::DeleteDC(_pdlg.hDC);
if (fontHeader)
::DeleteObject(fontHeader);
if (fontFooter)
::DeleteObject(fontFooter);
return (pageNum - 1);
}
static INT_PTR DoControl(GCEVENT * gce, WPARAM wp)
{
if ( gce->pDest->iType == GC_EVENT_CONTROL ) {
switch (wp) {
case WINDOW_HIDDEN:
{
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if (si) {
si->bInitDone = TRUE;
SetActiveSession(si->ptszID, si->pszModule);
if (si->hWnd)
ShowRoom(si, wp, FALSE);
}
}
return 0;
case WINDOW_MINIMIZE:
case WINDOW_MAXIMIZE:
case WINDOW_VISIBLE:
case SESSION_INITDONE:
{
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if (si) {
si->bInitDone = TRUE;
if (wp != SESSION_INITDONE || DBGetContactSettingByte(NULL, "Chat", "PopupOnJoin", 0) == 0)
ShowRoom(si, wp, TRUE);
return 0;
} }
break;
case SESSION_OFFLINE:
SM_SetOffline(gce->pDest->ptszID, gce->pDest->pszModule);
// fall through
case SESSION_ONLINE:
SM_SetStatus( gce->pDest->ptszID, gce->pDest->pszModule, wp==SESSION_ONLINE?ID_STATUS_ONLINE:ID_STATUS_OFFLINE);
break;
case WINDOW_CLEARLOG:
{
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if ( si ) {
LM_RemoveAll(&si->pLog, &si->pLogEnd);
si->iEventCount = 0;
si->LastTime = 0;
}
break;
}
case SESSION_TERMINATE:
return SM_RemoveSession(gce->pDest->ptszID, gce->pDest->pszModule);
}
SM_SendMessage(gce->pDest->ptszID, gce->pDest->pszModule, GC_EVENT_CONTROL + WM_USER + 500, wp, 0);
}
else if (gce->pDest->iType == GC_EVENT_CHUID && gce->pszText)
{
SM_ChangeUID( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszNick, gce->ptszText);
}
else if (gce->pDest->iType == GC_EVENT_CHANGESESSIONAME && gce->pszText)
{
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if ( si ) {
replaceStr( &si->ptszName, gce->ptszText );
if (si->hWnd)
SendMessage(si->hWnd, DM_UPDATETITLEBAR, 0, 0);
}
}
else if (gce->pDest->iType == GC_EVENT_SETITEMDATA) {
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if (si)
si->dwItemData = gce->dwItemData;
}
else if (gce->pDest->iType ==GC_EVENT_GETITEMDATA) {
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if (si) {
gce->dwItemData = si->dwItemData;
return si->dwItemData;
}
return 0;
}
else if (gce->pDest->iType ==GC_EVENT_SETSBTEXT)
{
SESSION_INFO* si = SM_FindSession(gce->pDest->ptszID, gce->pDest->pszModule);
if (si) {
replaceStr( &si->ptszStatusbarText, gce->ptszText );
if ( si->ptszStatusbarText )
DBWriteContactSettingTString(si->windowData.hContact, si->pszModule, "StatusBar", si->ptszStatusbarText);
else
DBWriteContactSettingString(si->windowData.hContact, si->pszModule, "StatusBar", "");
if (si->hWnd)
{
SendMessage(si->hWnd, DM_UPDATESTATUSBAR, 0, 0);
}
}
}
else if (gce->pDest->iType == GC_EVENT_ACK)
{
SM_SendMessage(gce->pDest->ptszID, gce->pDest->pszModule, GC_ACKMESSAGE, 0, 0);
}
else if (gce->pDest->iType == GC_EVENT_SENDMESSAGE && gce->pszText)
{
SM_SendUserMessage( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszText);
}
else if (gce->pDest->iType == GC_EVENT_SETSTATUSEX)
{
SM_SetStatusEx( gce->pDest->ptszID, gce->pDest->pszModule, gce->ptszText, gce->dwItemData);
}
else return 1;
return 0;
}
INT_PTR NetlibHttpSendRequest(WPARAM wParam, LPARAM lParam)
{
NetlibConnection *nlc = (struct NetlibConnection*)wParam;
NETLIBHTTPREQUEST *nlhr = (NETLIBHTTPREQUEST*)lParam;
NETLIBHTTPREQUEST *nlhrReply = NULL;
HttpSecurityContext httpSecurity;
struct ResizableCharBuffer httpRequest = { 0 };
char *szHost = NULL, *szNewUrl = NULL;
char *pszProxyAuthHdr = NULL, *pszAuthHdr = NULL;
int i, doneHostHeader, doneContentLengthHeader, doneProxyAuthHeader, doneAuthHeader;
int bytesSent = 0;
bool lastFirstLineFail = false;
if (nlhr == NULL || nlhr->cbSize != sizeof(NETLIBHTTPREQUEST) || nlhr->szUrl == NULL || nlhr->szUrl[0] == '\0') {
SetLastError(ERROR_INVALID_PARAMETER);
return SOCKET_ERROR;
}
NetlibUser *nlu = nlc->nlu;
if (GetNetlibHandleType(nlu) != NLH_USER) {
SetLastError(ERROR_INVALID_PARAMETER);
return SOCKET_ERROR;
}
int hdrTimeout = (nlhr->timeout) ? nlhr->timeout : HTTPRECVHEADERSTIMEOUT;
const char *pszRequest;
switch (nlhr->requestType) {
case REQUEST_GET: pszRequest = "GET"; break;
case REQUEST_POST: pszRequest = "POST"; break;
case REQUEST_CONNECT: pszRequest = "CONNECT"; break;
case REQUEST_HEAD: pszRequest = "HEAD"; break;
case REQUEST_PUT: pszRequest = "PUT"; break;
case REQUEST_DELETE: pszRequest = "DELETE"; break;
default:
SetLastError(ERROR_INVALID_PARAMETER);
return SOCKET_ERROR;
}
if (!nlc->usingHttpGateway)
if (!NetlibEnterNestedCS(nlc, NLNCS_SEND))
return SOCKET_ERROR;
const char *pszFullUrl = nlhr->szUrl;
const char *pszUrl = NULL;
unsigned complete = false;
int count = 11;
while (--count) {
if (GetNetlibHandleType(nlc) != NLH_CONNECTION) {
nlc = NULL;
bytesSent = SOCKET_ERROR;
break;
}
if (!NetlibReconnect(nlc)) {
bytesSent = SOCKET_ERROR;
break;
}
if (!pszUrl) {
pszUrl = pszFullUrl;
if (nlhr->flags & (NLHRF_SMARTREMOVEHOST | NLHRF_REMOVEHOST | NLHRF_GENERATEHOST)) {
bool usingProxy = nlc->proxyType == PROXYTYPE_HTTP && !(nlhr->flags & NLHRF_SSL);
mir_free(szHost);
szHost = NULL;
const char *ppath, *phost;
phost = strstr(pszUrl, "://");
if (phost == NULL) phost = pszUrl;
else phost += 3;
ppath = strchr(phost, '/');
if (ppath == phost) phost = NULL;
if (nlhr->flags & NLHRF_GENERATEHOST) {
szHost = mir_strdup(phost);
if (ppath && phost) szHost[ppath - phost] = 0;
}
if (nlhr->flags & NLHRF_REMOVEHOST || (nlhr->flags & NLHRF_SMARTREMOVEHOST && !usingProxy))
pszUrl = ppath ? ppath : "/";
if (usingProxy && phost && !nlc->dnsThroughProxy) {
char* tszHost = mir_strdup(phost);
if (ppath && phost) tszHost[ppath - phost] = 0;
char* cln = strchr(tszHost, ':'); if (cln) *cln = 0;
if (inet_addr(tszHost) == INADDR_NONE) {
DWORD ip = DnsLookup(nlu, tszHost);
if (ip && szHost) {
mir_free(szHost);
szHost = (char*)mir_alloc(64);
if (cln) *cln = ':';
mir_snprintf(szHost, 64, "%s%s", inet_ntoa(*(PIN_ADDR)&ip), cln ? cln : "");
}
}
mir_free(tszHost);
}
}
}
if (nlc->proxyAuthNeeded && proxyAuthList.getCount()) {
if (httpSecurity.m_szProvider == NULL && nlc->szProxyServer) {
const char *szAuthMethodNlu = proxyAuthList.find(nlc->szProxyServer);
if (szAuthMethodNlu) {
mir_free(pszProxyAuthHdr);
pszProxyAuthHdr = httpSecurity.Execute(nlc, nlc->szProxyServer, szAuthMethodNlu, "", complete);
}
}
}
nlc->proxyAuthNeeded = false;
AppendToCharBuffer(&httpRequest, "%s %s HTTP/1.%d\r\n", pszRequest, pszUrl, (nlhr->flags & NLHRF_HTTP11) != 0);
//HTTP headers
doneHostHeader = doneContentLengthHeader = doneProxyAuthHeader = doneAuthHeader = 0;
for (i=0; i < nlhr->headersCount; i++) {
NETLIBHTTPHEADER &p = nlhr->headers[i];
if (!mir_strcmpi(p.szName, "Host")) doneHostHeader = 1;
else if (!mir_strcmpi(p.szName, "Content-Length")) doneContentLengthHeader = 1;
else if (!mir_strcmpi(p.szName, "Proxy-Authorization")) doneProxyAuthHeader = 1;
else if (!mir_strcmpi(p.szName, "Authorization")) doneAuthHeader = 1;
else if (!mir_strcmpi(p.szName, "Connection")) continue;
if (p.szValue == NULL) continue;
AppendToCharBuffer(&httpRequest, "%s: %s\r\n", p.szName, p.szValue);
}
if (szHost && !doneHostHeader)
AppendToCharBuffer(&httpRequest, "%s: %s\r\n", "Host", szHost);
if (pszProxyAuthHdr && !doneProxyAuthHeader)
AppendToCharBuffer(&httpRequest, "%s: %s\r\n", "Proxy-Authorization", pszProxyAuthHdr);
if (pszAuthHdr && !doneAuthHeader)
AppendToCharBuffer(&httpRequest, "%s: %s\r\n", "Authorization", pszAuthHdr);
AppendToCharBuffer(&httpRequest, "%s: %s\r\n", "Connection", "Keep-Alive");
AppendToCharBuffer(&httpRequest, "%s: %s\r\n", "Proxy-Connection", "Keep-Alive");
// Add Sticky Headers
if (nlu->szStickyHeaders != NULL)
AppendToCharBuffer(&httpRequest, "%s\r\n", nlu->szStickyHeaders);
//send it
bytesSent = SendHttpRequestAndData(nlc, &httpRequest, nlhr, !doneContentLengthHeader);
if (bytesSent == SOCKET_ERROR)
break;
//ntlm reply
if (doneContentLengthHeader && nlhr->requestType != REQUEST_HEAD)
break;
DWORD fflags = MSG_PEEK | MSG_NODUMP | ((nlhr->flags & NLHRF_NOPROXY) ? MSG_RAW : 0);
DWORD dwTimeOutTime = hdrTimeout < 0 ? -1 : GetTickCount() + hdrTimeout;
if (!HttpPeekFirstResponseLine(nlc, dwTimeOutTime, fflags, &nlhr->resultCode, NULL, NULL)) {
DWORD err = GetLastError();
NetlibLogf(nlu, "%s %d: %s Failed (%u %u)", __FILE__, __LINE__, "HttpPeekFirstResponseLine", err, count);
// connection died while we were waiting
if (GetNetlibHandleType(nlc) != NLH_CONNECTION) {
nlc = NULL;
break;
}
if (err == ERROR_TIMEOUT || err == ERROR_BAD_FORMAT || err == ERROR_BUFFER_OVERFLOW || lastFirstLineFail || nlc->termRequested || nlhr->requestType == REQUEST_CONNECT) {
bytesSent = SOCKET_ERROR;
break;
}
lastFirstLineFail = true;
continue;
}
int resultCode = nlhr->resultCode;
lastFirstLineFail = false;
DWORD hflags = (nlhr->flags & (NLHRF_NODUMP | NLHRF_NODUMPHEADERS | NLHRF_NODUMPSEND) ?
MSG_NODUMP : (nlhr->flags & NLHRF_DUMPPROXY ? MSG_DUMPPROXY : 0)) |
(nlhr->flags & NLHRF_NOPROXY ? MSG_RAW : 0);
DWORD dflags = (nlhr->flags & (NLHRF_NODUMP | NLHRF_NODUMPSEND) ? MSG_NODUMP : MSG_DUMPASTEXT | MSG_DUMPPROXY) |
(nlhr->flags & NLHRF_NOPROXY ? MSG_RAW : 0) | MSG_NODUMP;
if (resultCode == 100)
nlhrReply = (NETLIBHTTPREQUEST*)NetlibHttpRecvHeaders((WPARAM)nlc, hflags);
else if (resultCode == 307 || ((resultCode == 301 || resultCode == 302) && (nlhr->flags & NLHRF_REDIRECT))) { // redirect
pszUrl = NULL;
if (nlhr->requestType == REQUEST_HEAD)
nlhrReply = (NETLIBHTTPREQUEST*)NetlibHttpRecvHeaders((WPARAM)nlc, hflags);
else
nlhrReply = NetlibHttpRecv(nlc, hflags, dflags);
if (nlhrReply) {
char* tmpUrl = NetlibHttpFindHeader(nlhrReply, "Location");
if (tmpUrl) {
size_t rlen = 0;
if (tmpUrl[0] == '/') {
const char *ppath, *phost;
phost = strstr(pszFullUrl, "://");
phost = phost ? phost + 3 : pszFullUrl;
ppath = strchr(phost, '/');
rlen = ppath ? ppath - pszFullUrl : mir_strlen(pszFullUrl);
}
nlc->szNewUrl = (char*)mir_realloc(nlc->szNewUrl, rlen + mir_strlen(tmpUrl) * 3 + 1);
strncpy(nlc->szNewUrl, pszFullUrl, rlen);
mir_strcpy(nlc->szNewUrl + rlen, tmpUrl);
pszFullUrl = nlc->szNewUrl;
pszUrl = NULL;
if (NetlibHttpProcessUrl(nlhr, nlu, nlc, pszFullUrl) == NULL) {
bytesSent = SOCKET_ERROR;
break;
}
}
else {
NetlibHttpSetLastErrorUsingHttpResult(resultCode);
bytesSent = SOCKET_ERROR;
break;
}
}
else {
NetlibHttpSetLastErrorUsingHttpResult(resultCode);
bytesSent = SOCKET_ERROR;
break;
}
}
else if (resultCode == 401 && !doneAuthHeader) { //auth required
if (nlhr->requestType == REQUEST_HEAD)
nlhrReply = (NETLIBHTTPREQUEST*)NetlibHttpRecvHeaders((WPARAM)nlc, hflags);
else
nlhrReply = NetlibHttpRecv(nlc, hflags, dflags);
mir_free(pszAuthHdr); pszAuthHdr = NULL;
if (nlhrReply) {
char *szAuthStr = NULL;
if (!complete) {
szAuthStr = NetlibHttpFindAuthHeader(nlhrReply, "WWW-Authenticate", httpSecurity.m_szProvider);
if (szAuthStr) {
char *szChallenge = strchr(szAuthStr, ' ');
if (!szChallenge || !*lrtrimp(szChallenge))
complete = true;
}
}
if (complete && httpSecurity.m_hNtlmSecurity)
szAuthStr = httpSecurity.TryBasic() ? NetlibHttpFindAuthHeader(nlhrReply, "WWW-Authenticate", "Basic") : NULL;
if (szAuthStr) {
char *szChallenge = strchr(szAuthStr, ' ');
if (szChallenge) { *szChallenge = 0; szChallenge = lrtrimp(szChallenge + 1); }
pszAuthHdr = httpSecurity.Execute(nlc, szHost, szAuthStr, szChallenge, complete);
}
}
if (pszAuthHdr == NULL) {
proxyAuthList.add(szHost, NULL);
NetlibHttpSetLastErrorUsingHttpResult(resultCode);
bytesSent = SOCKET_ERROR;
break;
}
}
else if (resultCode == 407 && !doneProxyAuthHeader) { //proxy auth required
if (nlhr->requestType == REQUEST_HEAD)
nlhrReply = (NETLIBHTTPREQUEST*)NetlibHttpRecvHeaders((WPARAM)nlc, hflags);
else
nlhrReply = NetlibHttpRecv(nlc, hflags, dflags);
mir_free(pszProxyAuthHdr); pszProxyAuthHdr = NULL;
if (nlhrReply) {
char *szAuthStr = NULL;
if (!complete) {
szAuthStr = NetlibHttpFindAuthHeader(nlhrReply, "Proxy-Authenticate", httpSecurity.m_szProvider);
if (szAuthStr) {
char *szChallenge = strchr(szAuthStr, ' ');
if (!szChallenge || !*lrtrimp(szChallenge + 1))
complete = true;
}
}
if (complete && httpSecurity.m_hNtlmSecurity)
szAuthStr = httpSecurity.TryBasic() ? NetlibHttpFindAuthHeader(nlhrReply, "Proxy-Authenticate", "Basic") : NULL;
if (szAuthStr) {
char *szChallenge = strchr(szAuthStr, ' ');
if (szChallenge) { *szChallenge = 0; szChallenge = lrtrimp(szChallenge + 1); }
pszProxyAuthHdr = httpSecurity.Execute(nlc, nlc->szProxyServer, szAuthStr, szChallenge, complete);
}
}
if (pszProxyAuthHdr == NULL) {
proxyAuthList.add(nlc->szProxyServer, NULL);
NetlibHttpSetLastErrorUsingHttpResult(resultCode);
bytesSent = SOCKET_ERROR;
break;
}
}
else break;
if (pszProxyAuthHdr && resultCode != 407 && !doneProxyAuthHeader)
replaceStr(pszProxyAuthHdr, NULL);
if (pszAuthHdr && resultCode != 401 && !doneAuthHeader)
replaceStr(pszAuthHdr, NULL);
if (nlhrReply) {
NetlibHttpFreeRequestStruct(0, (LPARAM)nlhrReply);
nlhrReply = NULL;
}
}
if (count == 0) bytesSent = SOCKET_ERROR;
if (nlhrReply)
NetlibHttpFreeRequestStruct(0, (LPARAM)nlhrReply);
//clean up
mir_free(pszProxyAuthHdr);
mir_free(pszAuthHdr);
mir_free(szHost);
mir_free(szNewUrl);
if (nlc && !nlc->usingHttpGateway)
NetlibLeaveNestedCS(&nlc->ncsSend);
return bytesSent;
}
static INT_PTR CALLBACK ButOrderOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
HWND hTree = GetDlgItem(hwndDlg, IDC_BUTTONORDERTREE);
OrderData *dat = (OrderData*)GetWindowLongPtr(hTree, GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
dat = (OrderData*)malloc( sizeof(OrderData));
SetWindowLongPtr(hTree, GWLP_USERDATA, (LONG_PTR)dat);
dat->dragging = 0;
SetWindowLongPtr(hTree, GWL_STYLE, GetWindowLongPtr(hTree, GWL_STYLE)|TVS_NOHSCROLL);
SetDlgItemInt(hwndDlg, IDC_BUTTHEIGHT, g_ctrl->nButtonHeight, FALSE);
SendDlgItemMessage(hwndDlg, IDC_SPIN_HEIGHT, UDM_SETRANGE, 0, MAKELONG(50,10));
SendDlgItemMessage(hwndDlg, IDC_SPIN_HEIGHT, UDM_SETPOS, 0, MAKELONG(g_ctrl->nButtonHeight,0));
SetDlgItemInt(hwndDlg, IDC_BUTTWIDTH, g_ctrl->nButtonWidth, FALSE);
SendDlgItemMessage(hwndDlg, IDC_SPIN_WIDTH, UDM_SETRANGE, 0, MAKELONG(50,10));
SendDlgItemMessage(hwndDlg, IDC_SPIN_WIDTH, UDM_SETPOS, 0, MAKELONG(g_ctrl->nButtonWidth,0));
SetDlgItemInt(hwndDlg, IDC_BUTTGAP, g_ctrl->nButtonSpace, FALSE);
SendDlgItemMessage(hwndDlg, IDC_SPIN_GAP, UDM_SETRANGE, 0, MAKELONG(20,0));
SendDlgItemMessage(hwndDlg, IDC_SPIN_GAP, UDM_SETPOS, 0, MAKELONG(g_ctrl->nButtonSpace,0));
CheckDlgButton(hwndDlg, IDC_USEFLAT, g_ctrl->bFlatButtons ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_AUTORESIZE, g_ctrl->bAutoSize ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_SINGLELINE, g_ctrl->bSingleLine ? BST_CHECKED : BST_UNCHECKED);
BuildTree(hwndDlg);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENAME), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_EPATH), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_DELLBUTTON), FALSE);
OptionshWnd = hwndDlg;
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == EN_CHANGE && OptionshWnd) {
switch(LOWORD(wParam)) {
case IDC_ENAME: case IDC_EPATH:
break;
default:
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
}
if ((HIWORD(wParam) == BN_CLICKED || HIWORD(wParam) == BN_DBLCLK)) {
int ctrlid = LOWORD(wParam);
//----- Launch buttons -----
if (ctrlid == IDC_BROWSE) {
TCHAR str[MAX_PATH];
OPENFILENAME ofn = {0};
GetDlgItemText(hwndDlg, IDC_EPATH, str, _countof(str));
ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
ofn.hwndOwner = hwndDlg;
ofn.hInstance = NULL;
ofn.lpstrFilter = NULL;
ofn.lpstrFile = str;
ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_EXPLORER;
ofn.nMaxFile = _countof(str);
ofn.nMaxFileTitle = MAX_PATH;
ofn.lpstrDefExt = _T("exe");
if (!GetOpenFileName(&ofn))
break;
SetDlgItemText(hwndDlg, IDC_EPATH, str);
break;
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
if (ctrlid == IDC_LBUTTONSET) {
TVITEM tvi ={0};
tvi.hItem = TreeView_GetSelection(hTree);
if (tvi.hItem == NULL)
break;
tvi.mask = TVIF_PARAM;
TreeView_GetItem(hTree, &tvi);
TopButtonInt* btn = (TopButtonInt*)tvi.lParam;
TCHAR buf [256];
// probably, condition not needs
if (btn->dwFlags & TTBBF_ISLBUTTON) {
if (!(btn->dwFlags & TTBBF_OPTIONAL)) {
// create button
TTBButton ttb = { 0 };
ttb.hIconDn = (HICON)LoadImage(hInst, MAKEINTRESOURCE(IDI_RUN), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
ttb.dwFlags = TTBBF_VISIBLE | TTBBF_ISLBUTTON | TTBBF_INTERNAL | TTBBF_OPTIONAL;
ttb.name = NULL;
ttb.program = NULL;
int id = btn->id;
btn = CreateButton(&ttb);
btn->id = id;
tvi.lParam = (LPARAM)btn;
TreeView_SetItem(hTree, &tvi);
}
GetDlgItemText(hwndDlg, IDC_ENAME, buf, _countof(buf));
replaceStr(btn->pszName, _T2A(buf));
tvi.mask = TVIF_TEXT;
tvi.pszText = buf;
TreeView_SetItem(hTree, &tvi);
GetDlgItemText(hwndDlg, IDC_EPATH, buf, _countof(buf));
replaceStrT(btn->ptszProgram, buf);
}
break;
}
if (ctrlid == IDC_ADDLBUTTON) {
// create button
TTBButton ttb = { 0 };
ttb.hIconDn = (HICON)LoadImage(hInst, MAKEINTRESOURCE(IDI_RUN), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
ttb.dwFlags = TTBBF_VISIBLE | TTBBF_ISLBUTTON | TTBBF_INTERNAL | TTBBF_OPTIONAL;
ttb.name = LPGEN("Default");
ttb.program = _T("Execute Path");
TopButtonInt* b = CreateButton(&ttb);
// get selection for insert
TVITEM tvi = {0};
tvi.hItem = TreeView_GetSelection(hTree);
// insert item
AddLine(hTree, b, tvi.hItem, dat->himlButtonIcons);
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
//----- Separators -----
if (ctrlid == IDC_ADDSEP) {
// create button
TTBButton ttb = { 0 };
ttb.dwFlags = TTBBF_VISIBLE | TTBBF_ISSEPARATOR | TTBBF_INTERNAL | TTBBF_OPTIONAL;
TopButtonInt* b = CreateButton(&ttb);
// get selection for insert
TVITEM tvi = {0};
tvi.hItem = TreeView_GetSelection(hTree);
// insert item
AddLine(hTree, b, tvi.hItem, dat->himlButtonIcons);
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
if (ctrlid == IDC_REMOVEBUTTON) {
TVITEM tvi = {0};
tvi.hItem = TreeView_GetSelection(hTree);
if (tvi.hItem == NULL)
break;
tvi.mask = TVIF_PARAM;
TreeView_GetItem(hTree, &tvi);
TopButtonInt* btn = (TopButtonInt*)tvi.lParam;
// if button enabled for separator and launch only, no need condition
// except possible service button introducing
if (btn->dwFlags & (TTBBF_ISSEPARATOR | TTBBF_ISLBUTTON)) {
// delete if was added in options
if (btn->dwFlags & TTBBF_OPTIONAL)
delete btn;
TreeView_DeleteItem(hTree,tvi.hItem);
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
}
}
break;
case WM_NOTIFY:
switch(((LPNMHDR)lParam)->idFrom) {
case 0:
switch (((LPNMHDR)lParam)->code) {
case PSN_APPLY:
g_ctrl->nButtonHeight = GetDlgItemInt(hwndDlg, IDC_BUTTHEIGHT, NULL, FALSE);
g_ctrl->nButtonWidth = GetDlgItemInt(hwndDlg, IDC_BUTTWIDTH, NULL, FALSE);
g_ctrl->nButtonSpace = GetDlgItemInt(hwndDlg, IDC_BUTTGAP, NULL, FALSE);
g_ctrl->bFlatButtons = (BYTE)IsDlgButtonChecked(hwndDlg, IDC_USEFLAT);
g_ctrl->bAutoSize = (BYTE)IsDlgButtonChecked(hwndDlg, IDC_AUTORESIZE);
g_ctrl->bSingleLine = (BYTE)IsDlgButtonChecked(hwndDlg, IDC_SINGLELINE);
db_set_dw(0, TTB_OPTDIR, "BUTTHEIGHT", g_ctrl->nButtonHeight);
db_set_dw(0, TTB_OPTDIR, "BUTTWIDTH", g_ctrl->nButtonWidth);
db_set_dw(0, TTB_OPTDIR, "BUTTGAP", g_ctrl->nButtonSpace);
db_set_b(0, TTB_OPTDIR, "UseFlatButton", g_ctrl->bFlatButtons);
db_set_b(0, TTB_OPTDIR, "SingleLine", g_ctrl->bSingleLine);
db_set_b(0, TTB_OPTDIR, "AutoSize", g_ctrl->bAutoSize);
SaveTree(hwndDlg);
RecreateWindows();
ArrangeButtons();
}
break;
case IDC_BUTTONORDERTREE:
switch (((LPNMHDR)lParam)->code) {
case TVN_BEGINDRAG:
SetCapture(hwndDlg);
dat->dragging = 1;
dat->hDragItem = ((LPNMTREEVIEW)lParam)->itemNew.hItem;
TreeView_SelectItem(hTree, dat->hDragItem);
break;
case NM_CLICK:
{
TVHITTESTINFO hti;
hti.pt.x = (short)LOWORD(GetMessagePos());
hti.pt.y = (short)HIWORD(GetMessagePos());
ScreenToClient(((LPNMHDR)lParam)->hwndFrom, &hti.pt);
if (TreeView_HitTest(((LPNMHDR)lParam)->hwndFrom, &hti))
if (hti.flags & TVHT_ONITEMSTATEICON) {
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
TreeView_SelectItem(hTree, hti.hItem);
}
}
break;
case TVN_SELCHANGED:
{
HTREEITEM hti = TreeView_GetSelection(hTree);
if (hti == NULL)
break;
TopButtonInt *btn = (TopButtonInt*)((LPNMTREEVIEW)lParam)->itemNew.lParam;
mir_cslock lck(csButtonsHook);
if (btn->dwFlags & TTBBF_ISLBUTTON) {
bool enable = (btn->dwFlags & TTBBF_INTERNAL) !=0;
EnableWindow(GetDlgItem(hwndDlg, IDC_ENAME), enable);
EnableWindow(GetDlgItem(hwndDlg, IDC_EPATH), enable);
EnableWindow(GetDlgItem(hwndDlg, IDC_REMOVEBUTTON), enable);
EnableWindow(GetDlgItem(hwndDlg, IDC_LBUTTONSET), enable);
if (btn->pszName != NULL)
SetDlgItemTextA(hwndDlg, IDC_ENAME, btn->pszName);
else
SetDlgItemTextA(hwndDlg, IDC_ENAME, "");
if (btn->ptszProgram != NULL)
SetDlgItemText(hwndDlg, IDC_EPATH, btn->ptszProgram);
else
SetDlgItemTextA(hwndDlg, IDC_EPATH, "");
}
else {
EnableWindow(GetDlgItem(hwndDlg,IDC_REMOVEBUTTON),
(btn->dwFlags & TTBBF_ISSEPARATOR)?TRUE:FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_ENAME), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_EPATH), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_LBUTTONSET), FALSE);
SetDlgItemTextA(hwndDlg, IDC_ENAME, "");
SetDlgItemTextA(hwndDlg, IDC_EPATH, "");
}
}
}
break;
}
break;
case WM_MOUSEMOVE:
if (dat->dragging) {
TVHITTESTINFO hti;
hti.pt.x = (short)LOWORD(lParam);
hti.pt.y = (short)HIWORD(lParam);
ClientToScreen(hwndDlg, &hti.pt);
ScreenToClient(hTree, &hti.pt);
TreeView_HitTest(hTree, &hti);
if (hti.flags & (TVHT_ONITEM | TVHT_ONITEMRIGHT)) {
HTREEITEM it=hti.hItem;
hti.pt.y -= TreeView_GetItemHeight(hTree)/2;
TreeView_HitTest(hTree, &hti);
if (!(hti.flags&TVHT_ABOVE))
TreeView_SetInsertMark(hTree,hti.hItem,1);
else
TreeView_SetInsertMark(hTree,it,0);
}
else {
if (hti.flags & TVHT_ABOVE) SendMessage(hTree, WM_VSCROLL, MAKEWPARAM(SB_LINEUP, 0), 0);
if (hti.flags & TVHT_BELOW) SendMessage(hTree, WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0), 0);
TreeView_SetInsertMark(hTree, NULL, 0);
}
}
break;
case WM_LBUTTONUP:
if (dat->dragging) {
TreeView_SetInsertMark(hTree, NULL, 0);
dat->dragging = 0;
ReleaseCapture();
TVHITTESTINFO hti;
hti.pt.x = (short)LOWORD(lParam);
hti.pt.y = (short)HIWORD(lParam);
ClientToScreen(hwndDlg, &hti.pt);
ScreenToClient(hTree, &hti.pt);
hti.pt.y -= TreeView_GetItemHeight(hTree)/2;
TreeView_HitTest(hTree, &hti);
if (dat->hDragItem == hti.hItem)
break;
if (hti.flags&TVHT_ABOVE)
hti.hItem=TVI_FIRST;
TVITEM tvi;
tvi.mask = TVIF_HANDLE|TVIF_PARAM;
tvi.hItem = (HTREEITEM) dat->hDragItem;
TreeView_GetItem(hTree, &tvi);
if ( (hti.flags & (TVHT_ONITEM | TVHT_ONITEMRIGHT)) || (hti.hItem==TVI_FIRST)) {
TVINSERTSTRUCT tvis;
TCHAR name[128];
tvis.item.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE;
tvis.item.stateMask = 0xFFFFFFFF;
tvis.item.pszText = name;
tvis.item.cchTextMax = _countof(name);
tvis.item.hItem = dat->hDragItem;
TreeView_GetItem(hTree, &tvis.item);
TreeView_DeleteItem(hTree, dat->hDragItem);
tvis.hParent = NULL;
tvis.hInsertAfter = hti.hItem;
TreeView_SelectItem(hTree, TreeView_InsertItem(hTree, &tvis));
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
}
break;
case WM_DESTROY:
if (dat) {
ImageList_Destroy(dat->himlButtonIcons);
free(dat);
}
OptionshWnd = NULL;
break;
}
return FALSE;
}
string Path::reformatSlash(string pathstr) {
return replaceStr(pathstr, '\\', '/');
}
string Path::formatUnderscore(string filename){
Path *ch = new Path(filename);
string result = replaceStr(ch->removeExtension()->path, '/', '_');
delete ch;
return result;
}
// decrypt string using KeyX, return decoded string as ASCII or NULL
LPSTR __cdecl cpp_decrypt(pCNTX ptr, LPCSTR szEncMsg)
{
ptrA ciphered;
try {
ptr->error = ERROR_SEH;
pSIMDATA p = (pSIMDATA)ptr->pdata;
unsigned clen = (unsigned)strlen(szEncMsg);
if (ptr->features & FEATURES_BASE64)
ciphered = (LPSTR)mir_base64_decode(szEncMsg, &clen);
else
ciphered = base16decode(szEncMsg, &clen);
LPSTR bciphered = ciphered;
BYTE dataflag = 0;
if (ptr->features & FEATURES_GZIP) {
dataflag = *ciphered;
bciphered++; clen--; // cut GZIP flag
}
if (ptr->features & FEATURES_CRC32) {
int len = *(WORD*)bciphered;
bciphered += 2; clen -= 2; // cut CRC32 length
if ((int)clen - CRC32::DIGESTSIZE < len) { // mesage not full
#if defined(_DEBUG) || defined(NETLIB_LOG)
Sent_NetLog("cpp_decrypt: error bad_len");
#endif
ptr->error = ERROR_BAD_LEN;
return NULL;
}
BYTE crc32[CRC32::DIGESTSIZE];
memset(crc32, 0, sizeof(crc32));
CRC32().CalculateDigest(crc32, (PBYTE)(bciphered + CRC32::DIGESTSIZE), len);
if (memcmp(crc32, bciphered, CRC32::DIGESTSIZE)) { // message is bad crc
#if defined(_DEBUG) || defined(NETLIB_LOG)
Sent_NetLog("cpp_decrypt: error bad_crc");
#endif
ptr->error = ERROR_BAD_CRC;
return NULL;
}
bciphered += CRC32::DIGESTSIZE; // cut CRC32 digest
clen = len;
}
string unciphered;
CBC_Mode<AES>::Decryption dec(p->KeyX, Tiger::DIGESTSIZE, IV);
StreamTransformationFilter cbcDecryptor(dec, new StringSink(unciphered));
cbcDecryptor.Put((PBYTE)bciphered, clen);
cbcDecryptor.MessageEnd();
if (dataflag & DATA_GZIP) {
size_t clen2 = clen;
LPSTR res = (LPSTR)cpp_gunzip((PBYTE)unciphered.data(), unciphered.length(), clen2);
replaceStr(ptr->tmp, mir_strndup(res, clen2));
free(res);
}
else replaceStr(ptr->tmp, mir_strdup(unciphered.c_str()));
ptr->error = ERROR_NONE;
return ptr->tmp;
}
catch (...) {
#if defined(_DEBUG) || defined(NETLIB_LOG)
Sent_NetLog("cpp_decrypt: error seh");
#endif
mir_free(ptr->tmp); ptr->tmp = 0;
return NULL;
}
}
string Path::getWindowsPath() {
return replaceStr(path, '/', '\\');
}
void CMsnProto::UpdateStoreCacheKey(ezxml_t bdy)
{
ezxml_t key = ezxml_get(bdy, "soap:Header", 0, "AffinityCacheHeader", 0, "CacheKey", -1);
if (key) replaceStr(storageCacheKey, ezxml_txt(key));
}
void CAimProto::aim_connection_clientlogin(void)
{
pass_ptrA password(getStringA(AIM_KEY_PW));
replaceStr(m_username, ptrA(getStringA(AIM_KEY_SN)));
CMStringA buf;
buf.Format("devId=%s&f=xml&pwd=%s&s=%s", AIM_DEFAULT_CLIENT_KEY, ptrA(mir_urlEncode(password)), ptrA(mir_urlEncode(m_username)));
NETLIBHTTPHEADER headers[] = {
{ "Content-Type", "application/x-www-form-urlencoded; charset=UTF-8" }
};
NETLIBHTTPREQUEST req = { 0 };
req.cbSize = sizeof(req);
req.flags = NLHRF_SSL;
req.requestType = REQUEST_POST;
req.szUrl = AIM_LOGIN_URL;
req.headers = headers;
req.headersCount = _countof(headers);
req.pData = buf.GetBuffer();
req.dataLength = buf.GetLength();
NLHR_PTR resp(CallService(MS_NETLIB_HTTPTRANSACTION, (WPARAM)m_hNetlibUser, (LPARAM)&req));
if (!resp || !resp->dataLength) {
broadcast_status(ID_STATUS_OFFLINE);
return;
}
time_t hosttime;
CMStringA token, secret;
if (!parse_clientlogin_response(resp, headers, token, secret, hosttime)) {
//TODO: handle error
broadcast_status(ID_STATUS_OFFLINE);
mir_free(headers[0].szValue);
return;
}
bool encryption = !getByte(AIM_KEY_DSSL, 0);
CMStringA url;
fill_session_url(url, token, secret, hosttime, password, encryption);
// reuse NETLIBHTTPREQUEST
req.requestType = REQUEST_GET;
req.pData = NULL;
req.flags |= NLHRF_MANUALHOST;
req.dataLength = 0;
req.headersCount = 1;
req.szUrl = url.GetBuffer();
{
NETLIBHTTPHEADER headers2[] = {
{ "Host", "api.oscar.aol.com" },
};
req.headers = headers2;
resp = CallService(MS_NETLIB_HTTPTRANSACTION, (WPARAM)m_hNetlibUser, (LPARAM)&req);
}
if (!resp || !resp->dataLength) {
// TODO: handle error
broadcast_status(ID_STATUS_OFFLINE);
return;
}
CMStringA bos_host, cookie, tls_cert_name; //TODO: find efficient buf size
unsigned short bos_port = 0;
if (!parse_start_socar_session_response(resp->pData, bos_host, bos_port, cookie, tls_cert_name, encryption)) {
// TODO: handle error
broadcast_status(ID_STATUS_OFFLINE);
return;
}
m_hServerConn = aim_connect(bos_host, bos_port, (tls_cert_name[0] && encryption) ? true : false, bos_host);
if (!m_hServerConn) {
// TODO: handle error
broadcast_status(ID_STATUS_OFFLINE);
return;
}
replaceStr(COOKIE, cookie);
COOKIE_LENGTH = (int)mir_strlen(cookie);
ForkThread(&CAimProto::aim_protocol_negotiation, 0);
}
bool CMsnProto::MSN_StoreUpdateProfile(const char* szNick, const char* szStatus, bool lock, bool allowRecurse)
{
char* reqHdr;
ezxml_t tbdy;
ezxml_t xmlp = storeSoapHdr("UpdateProfile", "RoamingIdentityChanged", tbdy, reqHdr);
ezxml_t pro = ezxml_add_child(tbdy, "profile", 0);
ezxml_t node = ezxml_add_child(pro, "ResourceID", 0);
ezxml_set_txt(node, proresid);
ezxml_t expro = ezxml_add_child(pro, "ExpressionProfile", 0);
node = ezxml_add_child(expro, "FreeText", 0);
ezxml_set_txt(node, "Update");
if (szNick)
{
node = ezxml_add_child(expro, "DisplayName", 0);
ezxml_set_txt(node, szNick);
}
if (szStatus)
{
node = ezxml_add_child(expro, "PersonalStatus", 0);
ezxml_set_txt(node, szStatus);
}
node = ezxml_add_child(expro, "Flags", 0);
ezxml_set_txt(node, lock ? "1" : "0");
char* szData = ezxml_toxml(xmlp, true);
ezxml_free(xmlp);
unsigned status = 0;
char *storeUrl = NULL, *tResult = NULL;
for (int k = 4; --k;)
{
mir_free(storeUrl);
storeUrl = GetStoreHost("UpdateProfile");
tResult = getSslResult(&storeUrl, szData, reqHdr, status);
if (tResult == NULL) UpdateStoreHost("UpdateProfile", NULL);
else break;
}
mir_free(reqHdr);
free(szData);
if (tResult != NULL)
{
UpdateStoreHost("UpdateProfile", storeUrl);
if (status == 200)
{
replaceStr(msnLastStatusMsg, szStatus);
MSN_ABUpdateDynamicItem();
}
else if (status == 500 && allowRecurse)
{
ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult));
const char* szErr = ezxml_txt(getSoapFault(xmlm, true));
if (strcmp(szErr, "PassportAuthFail") == 0)
{
MSN_GetPassportAuth();
status = MSN_StoreUpdateProfile(szNick, szStatus, lock, false) ? 200 : 500;
}
ezxml_free(xmlm);
}
}
mir_free(tResult);
mir_free(storeUrl);
return status == 200;
}
bool CMsnProto::MSN_StoreGetProfile(bool allowRecurse)
{
char* reqHdr;
ezxml_t tbdy;
ezxml_t xmlp = storeSoapHdr("GetProfile", "Initial", tbdy, reqHdr);
ezxml_t prohndl = ezxml_add_child(tbdy, "profileHandle", 0);
ezxml_t alias = ezxml_add_child(prohndl, "Alias", 0);
ezxml_t node = ezxml_add_child(alias, "Name", 0);
ezxml_set_txt(node, mycid);
node = ezxml_add_child(alias, "NameSpace", 0);
ezxml_set_txt(node, "MyCidStuff");
node = ezxml_add_child(prohndl, "RelationshipName", 0);
ezxml_set_txt(node, "MyProfile");
ezxml_t proattr = ezxml_add_child(tbdy, "profileAttributes", 0);
node = ezxml_add_child(proattr, "ResourceID", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(proattr, "DateModified", 0);
ezxml_set_txt(node, "true");
ezxml_t exproattr = ezxml_add_child(proattr, "ExpressionProfileAttributes", 0);
node = ezxml_add_child(exproattr, "ResourceID", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "DateModified", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "DisplayName", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "DisplayNameLastModified", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "PersonalStatus", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "PersonalStatusLastModified", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "StaticUserTilePublicURL", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "Photo", 0);
ezxml_set_txt(node, "true");
node = ezxml_add_child(exproattr, "Flags", 0);
ezxml_set_txt(node, "true");
char* szData = ezxml_toxml(xmlp, true);
ezxml_free(xmlp);
unsigned status = 0;
char *storeUrl = NULL, *tResult = NULL;
for (int k = 4; --k;)
{
mir_free(storeUrl);
storeUrl = GetStoreHost("GetProfile");
tResult = getSslResult(&storeUrl, szData, reqHdr, status);
if (tResult == NULL) UpdateStoreHost("GetProfile", NULL);
else break;
}
mir_free(reqHdr);
free(szData);
if (tResult != NULL)
{
if (status == 200)
{
ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult));
ezxml_t body = getSoapResponse(xmlm, "GetProfile");
UpdateStoreHost("GetProfile", body ? storeUrl : NULL);
mir_snprintf(proresid, sizeof(proresid), "%s", ezxml_txt(ezxml_child(body, "ResourceID")));
ezxml_t expr = ezxml_child(body, "ExpressionProfile");
if (expr == NULL)
{
MSN_StoreShareItem(proresid);
MSN_SharingMyProfile();
if (allowRecurse) MSN_StoreGetProfile(false);
}
else
{
const char* szNick = ezxml_txt(ezxml_child(expr, "DisplayName"));
setStringUtf(NULL, "Nick", (char*)szNick);
const char* szStatus = ezxml_txt(ezxml_child(expr, "PersonalStatus"));
replaceStr(msnLastStatusMsg, szStatus);
mir_snprintf(expresid, sizeof(expresid), "%s", ezxml_txt(ezxml_child(expr, "ResourceID")));
ezxml_t photo = ezxml_child(expr, "Photo");
mir_snprintf(photoid, sizeof(photoid), "%s", ezxml_txt(ezxml_child(photo, "ResourceID")));
ezxml_t docstr = ezxml_get(photo, "DocumentStreams", 0, "DocumentStream", -1);
while (docstr)
{
const char *docname = ezxml_txt(ezxml_child(docstr, "DocumentStreamName"));
if (!strcmp(docname, "UserTileStatic"))
{
getMyAvatarFile(ezxml_txt(ezxml_child(docstr, "PreAuthURL")), _T("miranda_avatar.tmp"));
break;
}
docstr = ezxml_next(docstr);
}
}
ezxml_free(xmlm);
}
else if (status == 500 && allowRecurse)
{
ezxml_t xmlm = ezxml_parse_str(tResult, strlen(tResult));
const char* szErr = ezxml_txt(getSoapFault(xmlm, true));
if (strcmp(szErr, "PassportAuthFail") == 0)
{
MSN_GetPassportAuth();
MSN_StoreGetProfile(false);
}
else
{
MSN_StoreCreateProfile();
if (MSN_StoreGetProfile(false)) status = 200;
}
ezxml_free(xmlm);
}
else
UpdateStoreHost("GetProfile", NULL);
}
mir_free(tResult);
mir_free(storeUrl);
return status == 200;
}
void CMsnProto::MSN_SendStatusMessage(const char* msg)
{
if (!msnLoggedIn)
return;
char* msgEnc = HtmlEncode(msg ? msg : "");
size_t sz;
char szMsg[2048];
if (msnCurrentMedia.cbSize == 0) {
sz = mir_snprintf(szMsg, sizeof(szMsg), "<Data><PSM>%s</PSM><CurrentMedia></CurrentMedia><MachineGuid>%s</MachineGuid>"
"<DDP></DDP><SignatureSound></SignatureSound><Scene></Scene><ColorScheme></ColorScheme></Data>",
msgEnc, MyOptions.szMachineGuid);
}
else {
char *szFormatEnc;
if (ServiceExists(MS_LISTENINGTO_GETPARSEDTEXT)) {
LISTENINGTOINFO lti = {0};
lti.cbSize = sizeof(lti);
if (msnCurrentMedia.ptszTitle != NULL) lti.ptszTitle = _T("{0}");
if (msnCurrentMedia.ptszArtist != NULL) lti.ptszArtist = _T("{1}");
if (msnCurrentMedia.ptszAlbum != NULL) lti.ptszAlbum = _T("{2}");
if (msnCurrentMedia.ptszTrack != NULL) lti.ptszTrack = _T("{3}");
if (msnCurrentMedia.ptszYear != NULL) lti.ptszYear = _T("{4}");
if (msnCurrentMedia.ptszGenre != NULL) lti.ptszGenre = _T("{5}");
if (msnCurrentMedia.ptszLength != NULL) lti.ptszLength = _T("{6}");
if (msnCurrentMedia.ptszPlayer != NULL) lti.ptszPlayer = _T("{7}");
if (msnCurrentMedia.ptszType != NULL) lti.ptszType = _T("{8}");
TCHAR *tmp = (TCHAR *)CallService(MS_LISTENINGTO_GETPARSEDTEXT, (WPARAM) _T("%title% - %artist%"), (LPARAM) <i);
szFormatEnc = HtmlEncodeUTF8T(tmp);
mir_free(tmp);
}
else szFormatEnc = HtmlEncodeUTF8T(_T("{0} - {1}"));
char *szArtist = HtmlEncodeUTF8T(msnCurrentMedia.ptszArtist);
char *szAlbum = HtmlEncodeUTF8T(msnCurrentMedia.ptszAlbum);
char *szTitle = HtmlEncodeUTF8T(msnCurrentMedia.ptszTitle);
char *szTrack = HtmlEncodeUTF8T(msnCurrentMedia.ptszTrack);
char *szYear = HtmlEncodeUTF8T(msnCurrentMedia.ptszYear);
char *szGenre = HtmlEncodeUTF8T(msnCurrentMedia.ptszGenre);
char *szLength = HtmlEncodeUTF8T(msnCurrentMedia.ptszLength);
char *szPlayer = HtmlEncodeUTF8T(msnCurrentMedia.ptszPlayer);
char *szType = HtmlEncodeUTF8T(msnCurrentMedia.ptszType);
sz = mir_snprintf(szMsg, sizeof szMsg,
"<Data>"
"<PSM>%s</PSM>"
"<CurrentMedia>%s\\0%s\\01\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0%s\\0\\0</CurrentMedia>"
"<MachineGuid>%s</MachineGuid><DDP></DDP><SignatureSound></SignatureSound><Scene></Scene><ColorScheme></ColorScheme>"
"<DDP></DDP><SignatureSound></SignatureSound><Scene></Scene><ColorScheme></ColorScheme>"
"</Data>",
msgEnc, szPlayer, szType, szFormatEnc, szTitle, szArtist, szAlbum, szTrack, szYear, szGenre,
szLength, szPlayer, szType, MyOptions.szMachineGuid);
mir_free(szArtist);
mir_free(szAlbum);
mir_free(szTitle);
mir_free(szTrack);
mir_free(szYear);
mir_free(szGenre);
mir_free(szLength);
mir_free(szPlayer);
mir_free(szType);
}
mir_free(msgEnc);
if (msnPreviousUUX == NULL || strcmp(msnPreviousUUX, szMsg)) {
replaceStr(msnPreviousUUX, szMsg);
msnNsThread->sendPacket("UUX", "%d\r\n%s", sz, szMsg);
mStatusMsgTS = clock();
}
}
bool startJVM(TCHAR* basedir, TCHAR* appFolder, TCHAR* jar, int argCount, LPTSTR *szArgList) {
TCHAR jvmPath[LAUNCHER_MAXPATH+1] = {0};
JavaVMInitArgs jvmArgs;
JavaVMOption options[MAX_OPTIONS+1];
JVM_CREATE createProc;
JNIEnv* env;
JavaVM* jvm = NULL;
char jarASCII[LAUNCHER_MAXPATH] = {0};
char classpath[LAUNCHER_MAXPATH*2] = {0};
char mainclassASCII[LAUNCHER_MAXPATH] = {0},
appClasspath[LAUNCHER_MAXPATH] = {0};
size_t outlen = 0;
jclass cls;
jmethodID mid;
TCHAR argname[MAX_OPTION_NAME + 1] = {0};
TCHAR argvalue[LAUNCHER_MAXPATH] = {0},
mainclass[LAUNCHER_MAXPATH] = {0};
CHAR argvalueASCII[LAUNCHER_MAXPATH] = {0};
HMODULE msvcrtdll;
bool runtimeBundled;
TCHAR tmpPath[LAUNCHER_MAXPATH] = {0};
TCHAR appid[LAUNCHER_MAXPATH] = {0};
memset(&options, 0, sizeof(JavaVMOption)*(MAX_OPTIONS + 1));
memset(&jvmArgs, 0, sizeof(JavaVMInitArgs));
makeFullFileName(basedir, _T("\\runtime"), tmpPath, sizeof(tmpPath)/sizeof(TCHAR));
runtimeBundled = fileExists(tmpPath);
if (runtimeBundled) {
if (!getJvmPath(basedir, jvmPath, LAUNCHER_MAXPATH)) {
showError(_T("jvm.dll is not found in bundled runtime."), jvmPath);
return false;
}
//make sure msvcr100 is loaded (or we may fail if copy of it is not installed into system)
makeFullFileName(basedir, _T("runtime\\jre\\bin\\msvcr100.dll"), tmpPath, sizeof(tmpPath)/sizeof(TCHAR));
msvcrtdll = ::LoadLibrary(tmpPath);
} else {
if (!getSystemJvmPath(jvmPath, LAUNCHER_MAXPATH)) {
showError(_T("No bundled runtime and can not find system JRE."), jvmPath);
return false;
}
//make sure msvcr100 is loaded (or we may fail if copy of it is not installed into system)
makeFullFileName(basedir, _T("\\bin\\msvcr100.dll"), tmpPath, sizeof(tmpPath)/sizeof(TCHAR));
msvcrtdll = ::LoadLibrary(tmpPath);
}
// Dynamically load the JVM
HMODULE jvmLibHandle = LoadLibrary(jvmPath);
if (jvmLibHandle == NULL) {
DWORD dwErr = GetLastError();
showError(_T("Error loading jvm.dll"), jvmPath);
return false;
}
//convert argument to ASCII string as this is what CreateJVM needs
wcstombs_s(&outlen, jarASCII, LAUNCHER_MAXPATH, jar, (size_t) wcslen(jar) + 1);
strcpy_s(classpath, LAUNCHER_MAXPATH*2, "-Djava.class.path=");
strcat_s(classpath, LAUNCHER_MAXPATH, jarASCII);
if (getConfigValue(basedir, CONFIG_CLASSPATH_KEY, argvalue, LAUNCHER_MAXPATH)) {
size_t inLen = (size_t) wcslen(argvalue);
//convert argument to ASCII string as this is what CreateJVM needs
wcstombs_s(&outlen, argvalueASCII, sizeof(argvalueASCII), argvalue, inLen + 1);
//compress spaces and replaces them with ;
{
char *in = argvalueASCII;
char *out = argvalueASCII;
bool needSemicolon = false;
while (*in != 0) {
if (*in == ' ') {
if (needSemicolon) {
*out = ';';
out++;
needSemicolon = false;
}
} else {
needSemicolon = true;
*out = *in;
out++;
}
in++;
}
*out = 0;
}
if (strlen(argvalueASCII) > 0) {
strcat_s(classpath, LAUNCHER_MAXPATH, ";");
strcat_s(classpath, LAUNCHER_MAXPATH, argvalueASCII);
}
}
// Set up the VM init args
jvmArgs.version = JNI_VERSION_1_2;
options[0].optionString = _strdup(classpath);
int cnt = 1;
if (isDebug) {
options[cnt].optionString = _strdup("vfprintf");
options[cnt].extraInfo = vfprintfHook;
cnt++;
}
//Note: should not try to quote the path. Spaces are fine here
_stprintf_s(argvalue, _T("-Djava.library.path=%s"), appFolder);
wcstombs_s(&outlen, argvalueASCII, sizeof(argvalueASCII),
argvalue, wcslen(argvalue) + 1);
options[cnt].optionString = _strdup(argvalueASCII);
cnt++;
//add app specific JVM parameters
int idx = 1;
int found = 0;
do {
_stprintf_s(argname, MAX_OPTION_NAME, _T("jvmarg.%d"), idx);
found = getConfigValue(basedir, argname, argvalue, LAUNCHER_MAXPATH);
if (found) {
TCHAR* option = replaceStr(argvalue, _T("$APPDIR"), basedir);
char* jvmOption = convertToDupedChar(option);
if (jvmOption != NULL) {
options[cnt].optionString = jvmOption;
cnt++;
}
idx++;
}
} while (found && idx < MAX_OPTIONS);
cnt = addUserOptions(basedir, options, cnt);
jvmArgs.version = 0x00010002;
jvmArgs.options = options;
jvmArgs.nOptions = cnt;
jvmArgs.ignoreUnrecognized = JNI_TRUE;
// Create the JVM
// NB: need to use ASCII string as UNICODE is not supported
createProc = (JVM_CREATE) GetProcAddress(jvmLibHandle, "JNI_CreateJavaVM");
if (createProc == NULL) {
showError(_T("Failed to locate JNI_CreateJavaVM"), jvmPath);
return false;
}
if ((*createProc)(&jvm, &env, &jvmArgs) < 0) {
showError(_T("Failed to create JVM"), jvmPath);
return false;
}
if (!getConfigValue(basedir, CONFIG_MAINCLASS_KEY, mainclass, LAUNCHER_MAXPATH)) {
showError(_T("Package error"), _T("No main class specified. Nothing to launch"));
return false;
} else {
size_t inLen = (size_t) wcslen(mainclass);
//convert argument to ASCII string as this is what CreateJVM needs
wcstombs_s(&outlen, mainclassASCII, sizeof(mainclassASCII), mainclass, inLen + 1);
}
cls = env->FindClass(mainclassASCII);
if (cls != NULL) {
mid = env->GetStaticMethodID(cls, "main", "([Ljava/lang/String;)V");
if (mid != NULL) {
jclass stringClass = env->FindClass("java/lang/String");
//prepare app arguments if any. Skip value at index 0 - this is path to executable ...
//NOTE:
// - what if user run in non-English/UTF-8 locale? do we need to convert args?
// - extend to pass jvm args and debug args (allow them in front, use marker option to separate them?)
int startArgIndex = countNumberOfSystemArguments(argCount, szArgList);
jobjectArray args = env->NewObjectArray(argCount - startArgIndex, stringClass, NULL);
for(int i=startArgIndex; i<argCount; i++) {
size_t inLen = (size_t) wcslen(szArgList[i]);
env->SetObjectArrayElement(args, i-startArgIndex, env->NewString((jchar*)szArgList[i], inLen));
}
env->CallStaticVoidMethod(cls, mid, args);
} else {
showError(_T("no main method in the main class!"), mainclass);
return false;
}
} else {
showError(_T("no main class."), mainclass);
return false;
}
if (env->ExceptionOccurred()) {
showError(_T("Failed due to exception from main class."), mainclass);
env->ExceptionDescribe();
}
// If application main() exits quickly but application is run on some other thread
// (e.g. Swing app performs invokeLater() in main and exits)
// then if we return execution to tWinMain it will exit.
// This will cause process to exit and application will not actually run.
//
// To avoid this we are trying to detach jvm from current thread (java.exe does the same)
// Because we are doing this on the main JVM thread (i.e. one that was used to create JVM)
// this call will spawn "Destroy Java VM" java thread that will shut JVM once there are
// no non-daemon threads running, and then return control here.
// I.e. this will happen when EDT and other app thread will exit.
if (jvm->DetachCurrentThread() != 0) {
showError(_T("Detach failed."), NULL);
}
jvm->DestroyJavaVM();
return true;
}
void TemplateMap::setFilename(const char *_filename)
{
replaceStr(filename, _filename);
Utils::convertPath(filename);
}