void Autoanswer(HANDLE hContact)
{
switch ( pluginCurrentStatus )
{
case ID_STATUS_AWAY:
case ID_STATUS_DND:
case ID_STATUS_NA:
case ID_STATUS_OCCUPIED:
case ID_STATUS_ONTHEPHONE:
case ID_STATUS_OUTTOLUNCH:
{
CString msg;
if ( pluginStatusMessage.Lookup( pluginCurrentStatus, msg ) )
{
// Отсылка сообщения отправителю
CString answer (TranslateT ("Auto-reply"));
answer += _T(":\r\n");
answer += msg;
DWORD foo;
SendContactMessage( hContact, answer, foo );
// Добавление сообщения
DBEVENTINFO ei = {};
ei.cbSize = sizeof (DBEVENTINFO);
ei.szModule = modname;
ei.timestamp = time();
ei.flags = DBEF_SENT;
ei.eventType = EVENTTYPE_MESSAGE;
ei.cbBlob = (DWORD)answer.GetLength () + 1;
ei.pBlob = (PBYTE) (LPCTSTR) answer;
CallServiceSync( MS_DB_EVENT_ADD, (WPARAM)hContact, (LPARAM)&ei );
}
}
break;
}
}
bool ChatAddGroup(LPCTSTR szSession, LPCTSTR szGroup)
{
GCDEST gcdest =
{
modname,
(LPSTR)szSession,
GC_EVENT_ADDGROUP
};
GCEVENT gce =
{
sizeof( GCEVENT ),
&gcdest,
NULL,
NULL,
NULL,
(LPCSTR)szGroup,
NULL,
FALSE,
0,
0,
NULL
};
return ( CallServiceSync( MS_GC_EVENT, 0, (LPARAM)&gce ) == 0 );
}
static void KickUser (MCONTACT hContact, GCHOOK *gch)
{
char *ptr;
EnterCriticalSection(&m_GCMutex);
if (SkypeSend ("ALTER CHAT "STR" KICK "STR, gch->pDest->ptszID, gch->ptszUID)!=-1) {
if (ptr=SkypeRcv("ALTER CHAT KICK", 2000)) {
if (strncmp(ptr, "ERROR", 5)) {
GCDEST gcd = { SKYPE_PROTONAME, gch->pDest->ptszID, GC_EVENT_KICK };
GCEVENT gce = { sizeof(gce), &gcd };
gce.time = (DWORD)time(NULL);
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszUID = gch->ptszUID;
CONTACTINFO ci = {0};
ci.cbSize = sizeof(ci);
ci.szProto = SKYPE_PROTONAME;
ci.dwFlag = CNF_DISPLAY | CNF_TCHAR;
ci.hContact = hContact;
if (hContact && !CallService(MS_CONTACT_GETCONTACTINFO,0,(LPARAM)&ci)) gce.ptszNick=ci.pszVal;
else gce.ptszNick=gce.ptszUID;
DBVARIANT dbv;
if (!db_get_ts(NULL, SKYPE_PROTONAME, "Nick", &dbv)) {
gce.ptszStatus = dbv.ptszVal;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
RemChatContact (GetChat(gcd.ptszID), gch->ptszUID);
db_free(&dbv);
}
if (ci.pszVal) mir_free (ci.pszVal);
}
free (ptr);
}
}
LeaveCriticalSection(&m_GCMutex);
}
bool ChatMessage(LPCTSTR szSession, LPCTSTR szFrom, LPCTSTR szMessage)
{
GCDEST gcdest =
{
modname,
(LPSTR)szSession,
GC_EVENT_MESSAGE
};
GCEVENT gce =
{
sizeof( GCEVENT ),
&gcdest,
(LPCSTR)szMessage,
(LPCSTR)szFrom,
(LPCSTR)szFrom,
NULL,
NULL,
FALSE,
0,
0,
time()
};
return ( CallServiceSync( MS_GC_EVENT, 0, (LPARAM)&gce ) == 0 );
}
void ShowInfoMessage(BYTE flags,const char *pszTitle,const char *pszTextFmt,...)
{
char szText[256]; /* max for systray */
MSGBOXPARAMSA *mbp;
va_list va;
va_start(va,pszTextFmt);
mir_vsnprintf(szText,SIZEOF(szText),pszTextFmt,va);
va_end(va);
if (ServiceExists(MS_CLIST_SYSTRAY_NOTIFY)) {
MIRANDASYSTRAYNOTIFY msn;
msn.cbSize=sizeof(msn);
msn.szProto=NULL;
msn.szInfoTitle=(char*)pszTitle;
msn.szInfo=(char*)szText;
msn.uTimeout=30000; /* max timeout */
msn.dwInfoFlags=flags;
if (!CallServiceSync(MS_CLIST_SYSTRAY_NOTIFY,0,(LPARAM)&msn))
return; /* success */
}
mbp=(MSGBOXPARAMSA*)mir_calloc(sizeof(*mbp));
if (mbp==NULL) return;
mbp->cbSize=sizeof(*mbp);
mbp->lpszCaption=mir_strdup(pszTitle);
mbp->lpszText=mir_strdup(szText);
mbp->dwStyle=MB_OK|MB_SETFOREGROUND|MB_TASKMODAL;
mbp->dwLanguageId=LANGIDFROMLCID((LCID)CallService(MS_LANGPACK_GETLOCALE,0,0));
switch(flags&NIIF_ICON_MASK) {
case NIIF_INFO: mbp->dwStyle|=MB_ICONINFORMATION; break;
case NIIF_WARNING: mbp->dwStyle|=MB_ICONWARNING; break;
case NIIF_ERROR: mbp->dwStyle|=MB_ICONERROR;
}
mir_forkthread(MessageBoxIndirectFree, mbp);
}
void WhatsAppProto::onGetParticipants(const std::string &gjid, const std::vector<string> &participants)
{
mir_cslock lck(m_csChats);
WAChatInfo *pInfo = m_chats[gjid];
if (pInfo == NULL)
return;
pInfo->bActive = true;
for (size_t i = 0; i < participants.size(); i++) {
std::string curr = participants[i];
ptrT ujid(str2t(curr)), nick(GetChatUserNick(curr));
bool bIsOwner = !mir_tstrcmp(ujid, pInfo->tszOwner);
GCDEST gcd = { m_szModuleName, pInfo->tszJid, GC_EVENT_JOIN };
GCEVENT gce = { sizeof(gce), &gcd };
gce.ptszNick = nick;
gce.ptszUID = utils::removeA(ujid);
gce.ptszStatus = (bIsOwner) ? _T("Owners") : _T("Members");
CallServiceSync(MS_GC_EVENT, NULL, (LPARAM)&gce);
}
}
LRESULT CALLBACK PopupDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_COMMAND:
if (HIWORD(wParam) == STN_CLICKED) {
g_clistApi.pfnRemoveEvent(PUGetContact(hWnd), 0);
CallServiceSync("BuddyExpectator/actionReturned", PUGetContact(hWnd), 0);
PUDeletePopup(hWnd);
}
break;
case WM_CONTEXTMENU:
g_clistApi.pfnRemoveEvent(PUGetContact(hWnd), 0);
setLastSeen(PUGetContact(hWnd));
PUDeletePopup(hWnd);
break;
case UM_FREEPLUGINDATA:
if (options.iShowEvent == 0)
setLastSeen(PUGetContact(hWnd));
return TRUE;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
void FacebookProto::UpdateNotificationsChatRoom(facebook_notification *notification) {
if (!getBool(FACEBOOK_KEY_NOTIFICATIONS_CHATROOM, DEFAULT_NOTIFICATIONS_CHATROOM))
return;
std::stringstream text;
text << notification->text << "\n\n" << PrepareUrl(notification->link);
std::string message = text.str();
utils::text::replace_all(&message, "%", "%%");
ptrT idT(mir_tstrdup(_T(FACEBOOK_NOTIFICATIONS_CHATROOM)));
ptrT messageT(mir_a2t_cp(message.c_str(), CP_UTF8));
GCDEST gcd = { m_szModuleName, _T(FACEBOOK_NOTIFICATIONS_CHATROOM), GC_EVENT_MESSAGE };
GCEVENT gce = { sizeof(gce), &gcd };
gce.ptszText = messageT;
gce.time = notification->time ? notification->time : ::time(NULL);
gce.bIsMe = false;
gce.dwFlags |= GCEF_ADDTOLOG;
gce.ptszNick = TranslateT("Notifications");
gce.ptszUID = idT;
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
}
LRESULT CALLBACK PopupDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_COMMAND:
case WM_CONTEXTMENU:
{
CVkSendMsgParam *pd = (CVkSendMsgParam *)PUGetPluginData(hwnd);
if (pd != NULL && pd->hContact != NULL)
CallServiceSync(MS_MSG_SENDMESSAGE, (WPARAM)pd->hContact, 0);
PUDeletePopup(hwnd);
}
break;
case UM_FREEPLUGINDATA:
{
CVkSendMsgParam *pd = (CVkSendMsgParam *)PUGetPluginData(hwnd);
delete pd;
}
return FALSE;
default:
break;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}
int CVkProto::OnModulesLoaded(WPARAM, LPARAM)
{
// Chats
GCREGISTER gcr = { sizeof(gcr) };
gcr.ptszDispName = m_tszUserName;
gcr.pszModule = m_szModuleName;
gcr.nColors = _countof(sttColors);
gcr.pColors = sttColors;
CallServiceSync(MS_GC_REGISTER, NULL, (LPARAM)&gcr);
CreateProtoService(PS_LEAVECHAT, &CVkProto::OnLeaveChat);
CreateProtoService(PS_JOINCHAT, &CVkProto::OnJoinChat);
HookProtoEvent(ME_GC_EVENT, &CVkProto::OnChatEvent);
HookProtoEvent(ME_GC_BUILDMENU, &CVkProto::OnGcMenuHook);
// Other hooks
HookProtoEvent(ME_MSG_WINDOWEVENT, &CVkProto::OnProcessSrmmEvent);
HookProtoEvent(ME_DB_EVENT_MARKED_READ, &CVkProto::OnDbEventRead);
HookProtoEvent(ME_DB_CONTACT_SETTINGCHANGED, &CVkProto::OnDbSettingChanged);
//Sounds
SkinAddNewSoundExT("VKNewsFeed", m_tszUserName, LPGENT("VKontakte newsfeed & notification event"));
InitPopups();
InitMenus();
return 0;
}
bool ChatOffline(LPCTSTR szSession)
{
GCDEST gcdest =
{
modname,
(LPSTR)szSession,
GC_EVENT_CONTROL
};
GCEVENT gce =
{
sizeof( GCEVENT ),
&gcdest,
NULL,
NULL,
NULL,
NULL,
NULL,
FALSE,
0,
0,
NULL
};
return ( CallServiceSync( MS_GC_EVENT, SESSION_OFFLINE, (LPARAM)&gce ) == 0 );
}
void sipe_backend_chat_close(struct sipe_backend_chat_session *backend_session)
{
SIPPROTO *pr;
GCEVENT gce = {0};
GCDEST gcd = {0};
struct sipe_chat_session *session;
if (!backend_session)
{
SIPE_DEBUG_WARNING_NOFORMAT("Attempted to close NULL backend_session");
return;
}
pr = backend_session->pr;
gce.cbSize = sizeof(gce);
gce.pDest = &gcd;
gcd.pszModule = pr->proto.m_szModuleName;
gcd.pszID = backend_session->conv;
gcd.iType = GC_EVENT_CONTROL;
session = (struct sipe_chat_session*)CallServiceSync( MS_GC_EVENT, SESSION_TERMINATE, (LPARAM)&gce );
}
void FacebookProto::AddChat(const char *id, const TCHAR *tname)
{
ptrT tid(mir_a2t(id));
// Create the group chat session
GCSESSION gcw = { sizeof(gcw) };
gcw.iType = GCW_PRIVMESS;
gcw.ptszID = tid;
gcw.pszModule = m_szModuleName;
gcw.ptszName = tname;
CallServiceSync(MS_GC_NEWSESSION, 0, (LPARAM)&gcw);
// Send setting events
GCDEST gcd = { m_szModuleName, tid, GC_EVENT_ADDGROUP };
GCEVENT gce = { sizeof(gce), &gcd };
// Create a user statuses
gce.ptszStatus = TranslateT("Myself");
CallServiceSync(MS_GC_EVENT, NULL, reinterpret_cast<LPARAM>(&gce));
gce.ptszStatus = TranslateT("Friend");
CallServiceSync(MS_GC_EVENT, NULL, reinterpret_cast<LPARAM>(&gce));
gce.ptszStatus = TranslateT("User");
CallServiceSync(MS_GC_EVENT, NULL, reinterpret_cast<LPARAM>(&gce));
// Finish initialization
gcd.iType = GC_EVENT_CONTROL;
gce.time = ::time(NULL);
gce.pDest = &gcd;
bool hideChats = getBool(FACEBOOK_KEY_HIDE_CHATS, DEFAULT_HIDE_CHATS);
// Add self contact
AddChatContact(id, facy.self_.user_id.c_str(), facy.self_.real_name.c_str());
CallServiceSync(MS_GC_EVENT, (hideChats ? WINDOW_HIDDEN : SESSION_INITDONE), reinterpret_cast<LPARAM>(&gce));
CallServiceSync(MS_GC_EVENT, SESSION_ONLINE, reinterpret_cast<LPARAM>(&gce));
}
void CAimProto::chat_start(const char* id, unsigned short exchange)
{
TCHAR* idt = mir_a2t(id);
GCSESSION gcw = {0};
gcw.cbSize = sizeof(gcw);
gcw.dwFlags = GC_TCHAR;
gcw.iType = GCW_CHATROOM;
gcw.pszModule = m_szModuleName;
gcw.ptszName = idt;
gcw.ptszID = idt;
CallServiceSync(MS_GC_NEWSESSION, 0, (LPARAM)&gcw);
GCDEST gcd = { m_szModuleName, { NULL }, GC_EVENT_ADDGROUP };
gcd.ptszID = idt;
GCEVENT gce = {0};
gce.cbSize = sizeof(gce);
gce.dwFlags = GC_TCHAR;
gce.pDest = &gcd;
gce.ptszStatus = TranslateT("Me");
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
gcd.iType = GC_EVENT_ADDGROUP;
gce.ptszStatus = TranslateT("Others");
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
gcd.iType = GC_EVENT_CONTROL;
CallServiceSync(MS_GC_EVENT, SESSION_INITDONE, (LPARAM)&gce);
CallServiceSync(MS_GC_EVENT, SESSION_ONLINE, (LPARAM)&gce);
CallServiceSync(MS_GC_EVENT, WINDOW_VISIBLE, (LPARAM)&gce);
setWord(find_chat_contact(id), "Exchange", exchange);
mir_free(idt);
}
int CMimAPI::TypingMessage(WPARAM hContact, LPARAM mode)
{
int issplit = 1, foundWin = 0, preTyping = 0;
BOOL fShowOnClist = TRUE;
HWND hwnd = M.FindWindow(hContact);
MCONTACT hMeta = db_mc_getMeta(hContact);
if (hMeta) {
if (!hwnd)
hwnd = M.FindWindow(hMeta);
hContact = hMeta;
}
if (hwnd && M.GetByte(SRMSGMOD, SRMSGSET_SHOWTYPING, SRMSGDEFSET_SHOWTYPING))
preTyping = SendMessage(hwnd, DM_TYPING, 0, mode);
if (hwnd && IsWindowVisible(hwnd))
foundWin = MessageWindowOpened(0, (LPARAM)hwnd);
else
foundWin = 0;
TContainerData *pContainer = NULL;
if (hwnd) {
SendMessage(hwnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer);
if (pContainer == NULL) // should never happen
return 0;
}
if (M.GetByte(SRMSGMOD, SRMSGSET_SHOWTYPINGCLIST, SRMSGDEFSET_SHOWTYPINGCLIST)) {
if (!hwnd && !M.GetByte(SRMSGMOD, SRMSGSET_SHOWTYPINGNOWINOPEN, 1))
fShowOnClist = false;
if (hwnd && !M.GetByte(SRMSGMOD, SRMSGSET_SHOWTYPINGWINOPEN, 1))
fShowOnClist = false;
}
else fShowOnClist = false;
if ((!foundWin || !(pContainer->dwFlags & CNT_NOSOUND)) && preTyping != (mode != 0))
SkinPlaySound(mode ? "TNStart" : "TNStop");
if (M.GetByte(SRMSGMOD, "ShowTypingPopup", 0)) {
BOOL fShow = false;
int iMode = M.GetByte("MTN_PopupMode", 0);
switch (iMode) {
case 0:
fShow = true;
break;
case 1:
if (!foundWin || !(pContainer && pContainer->hwndActive == hwnd && GetForegroundWindow() == pContainer->hwnd))
fShow = true;
break;
case 2:
if (hwnd == 0)
fShow = true;
else {
if (PluginConfig.m_HideOnClose) {
TContainerData *pContainer = 0;
SendMessage(hwnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer);
if (pContainer && pContainer->fHidden)
fShow = true;
}
}
break;
}
if (fShow)
TN_TypingMessage(hContact, mode);
}
if (mode) {
TCHAR szTip[256];
mir_sntprintf(szTip, SIZEOF(szTip), TranslateT("%s is typing a message"), pcli->pfnGetContactDisplayName(hContact, 0));
if (fShowOnClist && ServiceExists(MS_CLIST_SYSTRAY_NOTIFY) && M.GetByte(SRMSGMOD, "ShowTypingBalloon", 0)) {
MIRANDASYSTRAYNOTIFY tn;
tn.szProto = NULL;
tn.cbSize = sizeof(tn);
tn.tszInfoTitle = TranslateT("Typing Notification");
tn.tszInfo = szTip;
tn.dwInfoFlags = NIIF_INFO | NIIF_INTERN_UNICODE;
tn.uTimeout = 1000 * 4;
CallService(MS_CLIST_SYSTRAY_NOTIFY, 0, (LPARAM)&tn);
}
if (fShowOnClist) {
CLISTEVENT cle = { sizeof(cle) };
cle.hContact = hContact;
cle.hDbEvent = (HANDLE)1;
cle.flags = CLEF_ONLYAFEW | CLEF_TCHAR;
cle.hIcon = PluginConfig.g_buttonBarIcons[ICON_DEFAULT_TYPING];
cle.pszService = "SRMsg/TypingMessage";
cle.ptszTooltip = szTip;
CallServiceSync(MS_CLIST_REMOVEEVENT, hContact, 1);
CallServiceSync(MS_CLIST_ADDEVENT, hContact, (LPARAM)&cle);
}
}
return 0;
}
static INT_PTR CALLBACK gg_gc_openconfdlg(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch(message)
{
case WM_INITDIALOG:
{
CLCINFOITEM cii = {0};
HANDLE hMetaContactsEvent;
SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
Window_SetIcon_IcoLib(hwndDlg, GetIconHandle(IDI_CONFERENCE));
gg_gc_resetclistopts(GetDlgItem(hwndDlg, IDC_CLIST));
// Hook MetaContacts event (if available)
hMetaContactsEvent = HookEventMessage(ME_MC_SUBCONTACTSCHANGED, hwndDlg, HM_SUBCONTACTSCHANGED);
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)hMetaContactsEvent);
}
return TRUE;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDOK:
{
HWND hwndList = GetDlgItem(hwndDlg, IDC_CLIST);
GGPROTO* gg = (GGPROTO*)GetWindowLongPtr(hwndDlg, DWLP_USER);
int count = 0, i = 0;
// Check if connected
if (!gg->isonline())
{
MessageBox(NULL,
TranslateT("You have to be connected to open new conference."),
gg->m_tszUserName, MB_OK | MB_ICONSTOP);
}
else if (hwndList && (count = gg_gc_countcheckmarks(hwndList)) >= 2)
{
// Create new participiants table
TCHAR* chat;
uin_t* participants = (uin_t*)calloc(count, sizeof(uin_t));
gg->debugLogA("gg_gc_openconfdlg(): WM_COMMAND IDOK Opening new conference for %d contacts.", count);
for (MCONTACT hContact = db_find_first(); hContact && i < count; hContact = db_find_next(hContact)) {
HANDLE hItem = (HANDLE)SendMessage(hwndList, CLM_FINDCONTACT, hContact, 0);
if (hItem && SendMessage(hwndList, CLM_GETCHECKMARK, (WPARAM)hItem, 0)) {
MCONTACT hMetaContact = gg_getsubcontact(gg, hContact); // MetaContacts support
participants[i++] = db_get_dw(hMetaContact ? hMetaContact : hContact, gg->m_szModuleName, GG_KEY_UIN, 0);
}
}
if (count > i) i = count;
chat = gg->gc_getchat(0, participants, count);
if (chat)
{
GCDEST gcd = { gg->m_szModuleName, chat, GC_EVENT_CONTROL };
GCEVENT gce = { sizeof(gce), &gcd };
CallServiceSync(MS_GC_EVENT, WINDOW_VISIBLE, (LPARAM)&gce);
}
free(participants);
}
}
// fall through
case IDCANCEL:
DestroyWindow(hwndDlg);
break;
}
break;
}
case WM_NOTIFY:
{
switch(((NMHDR*)lParam)->idFrom)
{
case IDC_CLIST:
{
switch(((NMHDR*)lParam)->code)
{
case CLN_OPTIONSCHANGED:
gg_gc_resetclistopts(GetDlgItem(hwndDlg, IDC_CLIST));
break;
case CLN_NEWCONTACT:
case CLN_CONTACTMOVED:
case CLN_LISTREBUILT:
{
char* szProto;
uin_t uin;
GGPROTO* gg = (GGPROTO*)GetWindowLongPtr(hwndDlg, DWLP_USER);
if (!gg) break;
// Delete non-gg contacts
for (MCONTACT hContact = db_find_first(); hContact; hContact = db_find_next(hContact)) {
MCONTACT hItem = (MCONTACT)SendDlgItemMessage(hwndDlg, IDC_CLIST, CLM_FINDCONTACT, hContact, 0);
if (hItem) {
MCONTACT hMetaContact = gg_getsubcontact(gg, hContact); // MetaContacts support
if (hMetaContact) {
szProto = gg->m_szModuleName;
uin = (uin_t)gg->getDword(hMetaContact, GG_KEY_UIN, 0);
}
else {
szProto = GetContactProto(hContact);
uin = (uin_t)gg->getDword(hContact, GG_KEY_UIN, 0);
}
if (szProto == NULL || mir_strcmp(szProto, gg->m_szModuleName) || !uin || uin == gg->getDword(GG_KEY_UIN, 0))
SendDlgItemMessage(hwndDlg, IDC_CLIST, CLM_DELETEITEM, (WPARAM)hItem, 0);
}
}
}
break;
case CLN_CHECKCHANGED:
EnableWindow(GetDlgItem(hwndDlg, IDOK), gg_gc_countcheckmarks(GetDlgItem(hwndDlg, IDC_CLIST)) >= 2);
break;
}
break;
}
}
break;
}
case HM_SUBCONTACTSCHANGED:
{
HWND hwndList = GetDlgItem(hwndDlg, IDC_CLIST);
SendMessage(hwndList, CLM_AUTOREBUILD, 0, 0);
EnableWindow(GetDlgItem(hwndDlg, IDOK), gg_gc_countcheckmarks(hwndList) >= 2);
break;
}
case WM_CLOSE:
DestroyWindow(hwndDlg);
break;
case WM_DESTROY:
{
HANDLE hMetaContactsEvent = (HANDLE)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
if (hMetaContactsEvent)
UnhookEvent(hMetaContactsEvent);
Window_FreeIcon_IcoLib(hwndDlg);
break;
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////
// This is main groupchat initialization routine
//
TCHAR* GGPROTO::gc_getchat(uin_t sender, uin_t *recipients, int recipients_count)
{
list_t l;
GGGC *chat;
TCHAR id[32];
uin_t uin;
DBVARIANT dbv;
GCDEST gcd = { m_szModuleName, 0, GC_EVENT_ADDGROUP };
GCEVENT gce = { sizeof(gce), &gcd };
debugLogA("gc_getchat(): Count %d.", recipients_count);
if (!recipients) return NULL;
// Look for existing chat
for(l = chats; l; l = l->next)
{
chat = (GGGC *)l->data;
if (!chat) continue;
if (chat->recipients_count == recipients_count + (sender ? 1 : 0))
{
int i, j, found = 0, sok = (sender == 0);
if (!sok) {
for (i = 0; i < chat->recipients_count; i++) {
if (sender == chat->recipients[i])
{
sok = 1;
break;
}
}
}
if (sok)
for(i = 0; i < chat->recipients_count; i++)
for(j = 0; j < recipients_count; j++)
if (recipients[j] == chat->recipients[i]) found++;
// Found all recipients
if (found == recipients_count)
{
if (chat->ignore)
debugLog(_T("gc_getchat(): Ignoring existing id %s, size %d."), chat->id, chat->recipients_count);
else
debugLog(_T("gc_getchat(): Returning existing id %s, size %d."), chat->id, chat->recipients_count);
return !(chat->ignore) ? chat->id : NULL;
}
}
}
// Make new uin list to chat mapping
chat = (GGGC *)malloc(sizeof(GGGC));
UIN2IDT(gc_id ++, chat->id);
chat->ignore = FALSE;
// Check groupchat policy (new) / only for incoming
if (sender)
{
int unknown = (getcontact(sender, 0, 0, NULL) == NULL),
unknownSender = unknown;
for(int i = 0; i < recipients_count; i++)
if (!getcontact(recipients[i], 0, 0, NULL))
unknown ++;
if ((getWord(GG_KEY_GC_POLICY_DEFAULT, GG_KEYDEF_GC_POLICY_DEFAULT) == 2) ||
(getWord(GG_KEY_GC_POLICY_TOTAL, GG_KEYDEF_GC_POLICY_TOTAL) == 2 &&
recipients_count >= getWord(GG_KEY_GC_COUNT_TOTAL, GG_KEYDEF_GC_COUNT_TOTAL)) ||
(getWord(GG_KEY_GC_POLICY_UNKNOWN, GG_KEYDEF_GC_POLICY_UNKNOWN) == 2 &&
unknown >= getWord(GG_KEY_GC_COUNT_UNKNOWN, GG_KEYDEF_GC_COUNT_UNKNOWN)))
chat->ignore = TRUE;
if (!chat->ignore && ((getWord(GG_KEY_GC_POLICY_DEFAULT, GG_KEYDEF_GC_POLICY_DEFAULT) == 1) ||
(getWord(GG_KEY_GC_POLICY_TOTAL, GG_KEYDEF_GC_POLICY_TOTAL) == 1 &&
recipients_count >= getWord(GG_KEY_GC_COUNT_TOTAL, GG_KEYDEF_GC_COUNT_TOTAL)) ||
(getWord(GG_KEY_GC_POLICY_UNKNOWN, GG_KEYDEF_GC_POLICY_UNKNOWN) == 1 &&
unknown >= getWord(GG_KEY_GC_COUNT_UNKNOWN, GG_KEYDEF_GC_COUNT_UNKNOWN))))
{
TCHAR *senderName = unknownSender ?
TranslateT("Unknown") : pcli->pfnGetContactDisplayName(getcontact(sender, 0, 0, NULL), 0);
TCHAR error[256];
mir_sntprintf(error, TranslateT("%s has initiated conference with %d participants (%d unknowns).\nDo you want to participate?"),
senderName, recipients_count + 1, unknown);
chat->ignore = MessageBox(NULL, error, m_tszUserName, MB_OKCANCEL | MB_ICONEXCLAMATION) != IDOK;
}
if (chat->ignore)
{
// Copy recipient list
chat->recipients_count = recipients_count + 1;
chat->recipients = (uin_t *)calloc(chat->recipients_count, sizeof(uin_t));
int i = 0;
for(; i < recipients_count; i++)
chat->recipients[i] = recipients[i];
if (sender) chat->recipients[i] = sender;
debugLog(_T("gc_getchat(): Ignoring new chat %s, count %d."), chat->id, chat->recipients_count);
list_add(&chats, chat, 0);
return NULL;
}
}
// Create new chat window
TCHAR status[256];
TCHAR *senderName;
if (sender)
{
senderName = pcli->pfnGetContactDisplayName(getcontact(sender, 1, 0, NULL), 0);
mir_sntprintf(status, TranslateT("%s initiated the conference.") , senderName);
}
else
{
senderName = NULL;
mir_sntprintf(status, TranslateT("This is my own conference."));
}
GCSESSION gcwindow = { sizeof(gcwindow) };
gcwindow.iType = GCW_CHATROOM;
gcwindow.pszModule = m_szModuleName;
gcwindow.ptszName = sender ? senderName : TranslateT("Conference");
gcwindow.ptszID = chat->id;
gcwindow.dwItemData = (UINT_PTR)chat;
gcwindow.ptszStatusbarText = status;
// Here we put nice new hash sign
TCHAR *name = (TCHAR*)calloc(mir_tstrlen(gcwindow.ptszName) + 2, sizeof(TCHAR));
*name = '#'; mir_tstrcpy(name + 1, gcwindow.ptszName);
gcwindow.ptszName = name;
// Create new room
if (CallServiceSync(MS_GC_NEWSESSION, 0, (LPARAM) &gcwindow)) {
debugLog(_T("gc_getchat(): Cannot create new chat window %s."), chat->id);
free(name);
free(chat);
return NULL;
}
free(name);
gcd.ptszID = chat->id;
gce.ptszUID = id;
gce.dwFlags = GCEF_ADDTOLOG;
gce.time = 0;
// Add normal group
gce.ptszStatus = TranslateT("Participants");
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
gcd.iType = GC_EVENT_JOIN;
// Add myself
if (uin = getDword(GG_KEY_UIN, 0))
{
UIN2IDT(uin, id);
TCHAR* nickT;
if (!getTString(GG_KEY_NICK, &dbv)) {
nickT = mir_tstrdup(dbv.ptszVal);
db_free(&dbv);
} else {
nickT = mir_tstrdup(TranslateT("Me"));
}
gce.ptszNick = nickT;
gce.bIsMe = 1;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
mir_free(nickT);
debugLog(_T("gc_getchat(): Myself %s: %s (%s) to the list..."), gce.ptszUID, gce.ptszNick, gce.ptszStatus);
}
else debugLogA("gc_getchat(): Myself adding failed with uin %d !!!", uin);
// Copy recipient list
chat->recipients_count = recipients_count + (sender ? 1 : 0);
chat->recipients = (uin_t *)calloc(chat->recipients_count, sizeof(uin_t));
int i;
for(i = 0; i < recipients_count; i++)
chat->recipients[i] = recipients[i];
if (sender) chat->recipients[i] = sender;
// Add contacts
for(i = 0; i < chat->recipients_count; i++) {
MCONTACT hContact = getcontact(chat->recipients[i], 1, 0, NULL);
UIN2IDT(chat->recipients[i], id);
if (hContact && (name = pcli->pfnGetContactDisplayName(hContact, 0)) != NULL)
gce.ptszNick = name;
else
gce.ptszNick = TranslateT("'Unknown'");
gce.bIsMe = 0;
gce.dwFlags = 0;
debugLog(_T("gc_getchat(): Added %s: %s (%s) to the list..."), gce.ptszUID, gce.ptszNick, gce.ptszStatus);
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
}
gcd.iType = GC_EVENT_CONTROL;
CallServiceSync(MS_GC_EVENT, SESSION_INITDONE, (LPARAM)&gce);
CallServiceSync(MS_GC_EVENT, SESSION_ONLINE, (LPARAM)&gce);
debugLog(_T("gc_getchat(): Returning new chat window %s, count %d."), chat->id, chat->recipients_count);
list_add(&chats, chat, 0);
return chat->id;
}
int GGPROTO::gc_event(WPARAM, LPARAM lParam)
{
GCHOOK *gch = (GCHOOK *)lParam;
GGGC *chat = NULL;
uin_t uin;
// Check if we got our protocol, and fields are set
if (!gch
|| !gch->pDest
|| !gch->pDest->ptszID
|| !gch->pDest->pszModule
|| mir_strcmpi(gch->pDest->pszModule, m_szModuleName)
|| !(uin = getDword(GG_KEY_UIN, 0))
|| !(chat = gc_lookup(gch->pDest->ptszID)))
return 0;
// Window terminated (Miranda exit)
if (gch->pDest->iType == SESSION_TERMINATE)
{
debugLog(_T("gc_event(): Terminating chat %x, id %s from chat window..."), chat, gch->pDest->ptszID);
// Destroy chat entry
free(chat->recipients);
list_remove(&chats, chat, 1);
// Remove contact from contact list (duh!) should be done by chat.dll !!
for (MCONTACT hContact = db_find_first(); hContact; ) {
MCONTACT hNext = db_find_next(hContact);
DBVARIANT dbv;
if (!getTString(hContact, "ChatRoomID", &dbv)) {
if (dbv.ptszVal && !mir_tstrcmp(gch->pDest->ptszID, dbv.ptszVal))
CallService(MS_DB_CONTACT_DELETE, hContact, 0);
db_free(&dbv);
}
hContact = hNext;
}
return 1;
}
// Message typed / send only if online
if (isonline() && (gch->pDest->iType == GC_USER_MESSAGE) && gch->ptszText) {
TCHAR id[32];
UIN2IDT(uin, id);
DBVARIANT dbv;
GCDEST gcd = { m_szModuleName, gch->pDest->ptszID, GC_EVENT_MESSAGE };
GCEVENT gce = { sizeof(gce), &gcd };
gce.ptszUID = id;
gce.ptszText = gch->ptszText;
TCHAR* nickT;
if (!getTString(GG_KEY_NICK, &dbv)){
nickT = mir_tstrdup(dbv.ptszVal);
db_free(&dbv);
}
else nickT = mir_tstrdup(TranslateT("Me"));
gce.ptszNick = nickT;
// Get rid of CRLF at back
int lc = (int)mir_tstrlen(gch->ptszText) - 1;
while(lc >= 0 && (gch->ptszText[lc] == '\n' || gch->ptszText[lc] == '\r'))
gch->ptszText[lc --] = 0;
gce.time = time(NULL);
gce.bIsMe = 1;
gce.dwFlags = GCEF_ADDTOLOG;
debugLog(_T("gc_event(): Sending conference message to room %s, \"%s\"."), gch->pDest->ptszID, gch->ptszText);
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
mir_free(nickT);
T2Utf pszText_utf8(gch->ptszText);
gg_EnterCriticalSection(&sess_mutex, "gc_event", 57, "sess_mutex", 1);
gg_send_message_confer(sess, GG_CLASS_CHAT, chat->recipients_count, chat->recipients, pszText_utf8);
gg_LeaveCriticalSection(&sess_mutex, "gc_event", 57, 1, "sess_mutex", 1);
return 1;
}
// Privmessage selected
if (gch->pDest->iType == GC_USER_PRIVMESS)
{
MCONTACT hContact = NULL;
if ((uin = _ttoi(gch->ptszUID)) && (hContact = getcontact(uin, 1, 0, NULL)))
CallService(MS_MSG_SENDMESSAGE, hContact, 0);
}
debugLog(_T("gc_event(): Unhandled event %d, chat %x, uin %d, text \"%s\"."), gch->pDest->iType, chat, uin, gch->ptszText);
return 0;
}
void CMsnProto::MSN_ChatStart(ezxml_t xmli)
{
if (!mir_strcmp(xmli->txt, "thread"))
return;
// If Chat ID already exists, don'T create a new one
const char *pszID = ezxml_txt(ezxml_child(xmli, "id"));
GCThreadData* info = MSN_GetThreadByChatId(_A2T(pszID));
if (info == NULL) {
info = new GCThreadData;
{
mir_cslock lck(m_csThreads);
m_arGCThreads.insert(info);
}
MSN_ChatInit(info, pszID, ezxml_txt(ezxml_get(xmli, "properties", 0, "topic", -1)));
MSN_StartStopTyping(info, false);
}
else {
GCDEST gcd = { m_szModuleName, info->mChatID, GC_EVENT_CONTROL };
GCEVENT gce = { sizeof(gce), &gcd };
CallServiceSync(MS_GC_EVENT, SESSION_ONLINE, (LPARAM)&gce);
}
const char *pszCreator = ezxml_txt(ezxml_get(xmli, "properties", 0, "creator", -1));
for (ezxml_t memb = ezxml_get(xmli, "members", 0, "member", -1); memb != NULL; memb = ezxml_next(memb)) {
const char *mri = ezxml_txt(ezxml_child(memb, "mri"));
const char *role = ezxml_txt(ezxml_child(memb, "role"));
GCUserItem *gcu = NULL;
for (int j = 0; j < info->mJoinedContacts.getCount(); j++) {
if (!mir_strcmp(info->mJoinedContacts[j]->WLID, mri)) {
gcu = info->mJoinedContacts[j];
break;
}
}
if (!gcu) {
gcu = new GCUserItem;
info->mJoinedContacts.insert(gcu);
strncpy(gcu->WLID, mri, sizeof(gcu->WLID));
}
mir_tstrcpy(gcu->role, _A2T(role));
if (pszCreator && !mir_strcmp(mri, pszCreator)) info->mCreator = gcu;
char* szEmail, *szNet;
parseWLID(NEWSTR_ALLOCA(mri), &szNet, &szEmail, NULL);
if (!mir_strcmpi(szEmail, GetMyUsername(atoi(szNet))))
info->mMe = gcu;
gcu->btag = 1;
}
// Remove contacts not on list (not tagged)
for (int j = 0; j < info->mJoinedContacts.getCount(); j++) {
if (!info->mJoinedContacts[j]->btag) {
info->mJoinedContacts.remove(j);
j--;
}
else info->mJoinedContacts[j]->btag = 0;
}
}
int CMsnProto::MSN_GCEventHook(WPARAM, LPARAM lParam)
{
GCHOOK *gch = (GCHOOK*)lParam;
if (!gch)
return 1;
if (_stricmp(gch->pDest->pszModule, m_szModuleName)) return 0;
switch (gch->pDest->iType) {
case GC_SESSION_TERMINATE:
{
GCThreadData* thread = MSN_GetThreadByChatId(gch->pDest->ptszID);
if (thread != NULL) {
m_arGCThreads.remove(thread);
for (int i = 0; i < thread->mJoinedContacts.getCount(); i++)
delete thread->mJoinedContacts[i];
delete thread;
}
}
break;
case GC_USER_MESSAGE:
if (gch->ptszText && gch->ptszText[0]) {
GCThreadData* thread = MSN_GetThreadByChatId(gch->pDest->ptszID);
if (thread) {
TCHAR* pszMsg = UnEscapeChatTags(NEWTSTR_ALLOCA(gch->ptszText));
rtrimt(pszMsg); // remove the ending linebreak
msnNsThread->sendMessage('N', thread->szEmail, thread->netId, UTF8(pszMsg), 0);
DBVARIANT dbv;
int bError = getTString("Nick", &dbv);
GCDEST gcd = { m_szModuleName, gch->pDest->ptszID, GC_EVENT_MESSAGE };
GCEVENT gce = { sizeof(gce), &gcd };
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = bError ? _T("") : dbv.ptszVal;
gce.ptszUID = mir_a2t(MyOptions.szEmail);
gce.time = time(NULL);
gce.ptszText = gch->ptszText;
gce.bIsMe = TRUE;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
mir_free((void*)gce.ptszUID);
if (!bError)
db_free(&dbv);
}
}
break;
case GC_USER_CHANMGR:
DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_CHATROOM_INVITE), NULL, DlgInviteToChat,
LPARAM(new InviteChatParam(gch->pDest->ptszID, NULL, this)));
break;
case GC_USER_PRIVMESS:
{
char *email = mir_t2a(gch->ptszUID);
MCONTACT hContact = MSN_HContactFromEmail(email);
CallService(MS_MSG_SENDMESSAGE, hContact, 0);
mir_free(email);
}
break;
case GC_USER_LOGMENU:
switch (gch->dwData) {
case 10:
DialogBoxParam(g_hInst, MAKEINTRESOURCE(IDD_CHATROOM_INVITE), NULL, DlgInviteToChat,
LPARAM(new InviteChatParam(gch->pDest->ptszID, NULL, this)));
break;
case 20:
MSN_KillChatSession(gch->pDest->ptszID);
break;
}
break;
case GC_USER_NICKLISTMENU:
MCONTACT hContact = MSN_HContactFromEmail(_T2A(gch->ptszUID));
switch (gch->dwData) {
case 10:
CallService(MS_USERINFO_SHOWDIALOG, hContact, 0);
break;
case 20:
CallService(MS_HISTORY_SHOWCONTACTHISTORY, hContact, 0);
break;
case 30:
MSN_Kickuser(gch);
break;
case 110:
MSN_KillChatSession(gch->pDest->ptszID);
break;
case 40:
const TCHAR *pszRole = MSN_GCGetRole(MSN_GetThreadByChatId(gch->pDest->ptszID), _T2A(gch->ptszUID));
MSN_Promoteuser(gch, (pszRole && !mir_tstrcmp(pszRole, _T("admin"))) ? "user" : "admin");
break;
}
break;
}
return 0;
}
static void DlgUpdateSilent(void *lParam)
{
OBJLIST<FILEINFO> &UpdateFiles = *(OBJLIST<FILEINFO> *)lParam;
if (UpdateFiles.getCount() == 0) {
delete &UpdateFiles;
return;
}
// 1) If we need to escalate priviledges, launch a stub
if (!PrepareEscalation()) {
delete &UpdateFiles;
return;
}
AutoHandle pipe(hPipe);
//create needed folders after escalating priviledges. Folders creates when we actually install updates
TCHAR tszFileTemp[MAX_PATH], tszFileBack[MAX_PATH];
mir_sntprintf(tszFileBack, SIZEOF(tszFileBack), _T("%s\\Backups"), tszRoot);
SafeCreateDirectory(tszFileBack);
mir_sntprintf(tszFileTemp, SIZEOF(tszFileTemp), _T("%s\\Temp"), tszRoot);
SafeCreateDirectory(tszFileTemp);
// 2) Download all plugins
HANDLE nlc = NULL;
// Count all updates that have been enabled
int count = 0;
for (int i = 0; i < UpdateFiles.getCount(); i++) {
if (UpdateFiles[i].bEnabled && !UpdateFiles[i].bDeleteOnly) {
// download update
FILEURL *pFileUrl = &UpdateFiles[i].File;
if (!DownloadFile(pFileUrl, nlc)) {
// interrupt update as we require all components to be updated
Netlib_CloseHandle(nlc);
SkinPlaySound("updatefailed");
delete &UpdateFiles;
return;
}
count++;
}
}
Netlib_CloseHandle(nlc);
// All available updates have been disabled
if (count == 0) {
delete &UpdateFiles;
return;
}
// 3) Unpack all zips
VARST tszMirandaPath(_T("%miranda_path%"));
for (int i = 0; i < UpdateFiles.getCount(); i++) {
FILEINFO& p = UpdateFiles[i];
if (p.bEnabled) {
if (p.bDeleteOnly) {
// we need only to backup the old file
TCHAR *ptszRelPath = p.tszNewName + _tcslen(tszMirandaPath) + 1, tszBackFile[MAX_PATH];
mir_sntprintf(tszBackFile, SIZEOF(tszBackFile), _T("%s\\%s"), tszFileBack, ptszRelPath);
BackupFile(p.tszNewName, tszBackFile);
}
else {
// if file name differs, we also need to backup the old file here
// otherwise it would be replaced by unzip
if (_tcsicmp(p.tszOldName, p.tszNewName)) {
TCHAR tszSrcPath[MAX_PATH], tszBackFile[MAX_PATH];
mir_sntprintf(tszSrcPath, SIZEOF(tszSrcPath), _T("%s\\%s"), tszMirandaPath, p.tszOldName);
mir_sntprintf(tszBackFile, SIZEOF(tszBackFile), _T("%s\\%s"), tszFileBack, p.tszOldName);
BackupFile(tszSrcPath, tszBackFile);
}
// remove .zip after successful update
if (unzip(p.File.tszDiskPath, tszMirandaPath, tszFileBack, true))
SafeDeleteFile(p.File.tszDiskPath);
}
}
}
delete &UpdateFiles;
SkinPlaySound("updatecompleted");
#if MIRANDA_VER < 0x0A00
// 4) Change title of clist
ptrT title = db_get_tsa(NULL, "CList", "TitleText");
if (!_tcsicmp(title, _T("Miranda IM")))
db_set_ts(NULL, "CList", "TitleText", _T("Miranda NG"));
#endif
opts.bForceRedownload = false;
db_unset(NULL, MODNAME, DB_SETTING_REDOWNLOAD);
db_set_b(NULL, MODNAME, DB_SETTING_RESTART_COUNT, 5);
db_set_b(NULL, MODNAME, DB_SETTING_NEED_RESTART, 1);
// 5) Prepare Restart
TCHAR tszTitle[100];
mir_sntprintf(tszTitle, SIZEOF(tszTitle), TranslateT("%d component(s) was updated"), count);
if (ServiceExists(MS_POPUP_ADDPOPUPT) && db_get_b(NULL, "Popup", "ModuleIsEnabled", 1)) {
ShowPopup(tszTitle,TranslateT("You need to restart your Miranda to apply installed updates."),POPUP_TYPE_MSG);
} else {
bool notified = false;
if (ServiceExists(MS_CLIST_SYSTRAY_NOTIFY)) {
MIRANDASYSTRAYNOTIFY err;
err.szProto = MODULEA;
err.cbSize = sizeof(err);
err.dwInfoFlags = NIIF_INTERN_UNICODE | NIIF_INFO;
err.tszInfoTitle = tszTitle;
err.tszInfo = TranslateT("You need to restart your Miranda to apply installed updates.");
err.uTimeout = 30000;
notified = !CallService(MS_CLIST_SYSTRAY_NOTIFY, 0, (LPARAM)&err);
}
if (!notified) {
// Error, let's try to show MessageBox as last way to inform user about successful update
TCHAR tszText[200];
mir_sntprintf(tszText, SIZEOF(tszText), _T("%s\n\n%s"), TranslateT("You need to restart your Miranda to apply installed updates."), TranslateT("Would you like to restart it now?"));
if (MessageBox(NULL, tszText, tszTitle, MB_ICONINFORMATION | MB_YESNO) == IDYES)
#if MIRANDA_VER >= 0x0A00
CallServiceSync(MS_SYSTEM_RESTART, db_get_b(NULL, MODNAME, "RestartCurrentProfile", 1) ? 1 : 0, 0);
#else
CallFunctionAsync(RestartMe, 0);
#endif
}
}
}
static INT_PTR CALLBACK LogDlgProc(HWND hwndDlg,UINT message,WPARAM wParam,LPARAM lParam)
{
LOGWIN *dat = (LOGWIN*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch(message) {
case WM_INITDIALOG:
{
dat = (LOGWIN*)lParam;
dat->hwnd = hwndDlg;
dat->Scroll = 1;
dat->Paused = 0;
dat->hList = GetDlgItem(hwndDlg, IDC_LIST);
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)dat);
mir_subclassWindow(dat->hList, SubclassProc);
// init buttons
for(int i = 0; i < SIZEOF(ctrls); i++) {
HWND hwnd = GetDlgItem(hwndDlg,ctrls[i].control);
SendMessage(hwnd, ctrls[i].type, 0, 0);
SendMessage(hwnd, BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[i+ICON_FIRST]);
SendMessage(hwnd, BUTTONADDTOOLTIP,(WPARAM)TranslateTS(ctrls[i].tooltip), BATF_TCHAR);
}
CheckDlgButton(hwndDlg, IDC_SCROLL, dat->Scroll ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(hwndDlg,IDC_SCROLL,BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[(dat->Scroll?ICON_SCROLL:ICON_NOSCROLL)]);
if (gSingleMode) {
ShowWindow(GetDlgItem(hwndDlg, IDC_PAUSEALL), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_STARTALL), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CLOSE), SW_HIDE);
}
// init listview
LVITEM lvi = {0};
LVCOLUMN sLC;
//ListView_SetUnicodeFormat(dat->hList, TRUE);
ListView_SetImageList(dat->hList, gImg, LVSIL_SMALL);
sLC.mask = LVCF_FMT | LVCF_WIDTH;
sLC.fmt = LVCFMT_LEFT;
sLC.cx = 630;
ListView_InsertColumn(dat->hList, 0, &sLC);
ListView_SetExtendedListViewStyle(dat->hList, LVS_EX_FULLROWSELECT);
lvi.mask = LVIF_TEXT;
if (gIcons) {
lvi.mask |= LVIF_IMAGE;
lvi.iImage = IMG_INFO;
}
lvi.pszText = TranslateT("*** Console started ***");
ListView_InsertItem(dat->hList, &lvi);
SendMessage(hwndDlg, WM_SIZE, 0, 0);
}
break;
case HM_DUMP:
if (!lParam) break;
if (dat && !dat->Paused) {
LVITEM lvi = {0};
int last = 0x7fffffff;
TCHAR szBreak;
DWORD len, tmplen;
DWORD wraplen = gWrapLen;
TCHAR *str = ((DUMPMSG*)lParam)->szMsg;
lvi.iItem = 0x7fffffff;
str = _tcstok(str, _T("\n"));
if (gIcons && str != NULL) {
lvi.mask = LVIF_TEXT | LVIF_IMAGE;
if (_tcsstr(str, _T("Data received"))) {
if (gSeparator) ListView_InsertItem(dat->hList, &lvi);
lvi.iImage = IMG_IN;
}
else if (_tcsstr(str, _T("Data sent"))) {
if (gSeparator) ListView_InsertItem(dat->hList, &lvi);
lvi.iImage = IMG_OUT;
}
else {
if (gSeparator && dat->newline) {
ListView_InsertItem(dat->hList, &lvi);
dat->newline = 0;
}
lvi.iImage = IMG_INFO;
}
}
else lvi.mask = LVIF_TEXT;
while (str != NULL) {
lvi.pszText = &str[0];
tmplen = len = (DWORD)_tcslen(lvi.pszText);
while(len > wraplen) {
szBreak = lvi.pszText[wraplen];
lvi.pszText[wraplen] = 0;
last = ListView_InsertItem(dat->hList, &lvi);
lvi.pszText[wraplen] = szBreak;
len -= wraplen;
lvi.pszText = &str[0] + tmplen - len;
dat->newline = 1;
lvi.iImage = IMG_EMPTY;
}
if (len && lvi.pszText[len-1] == '\r')
lvi.pszText[len-1] = 0;
last = ListView_InsertItem(dat->hList, &lvi);
str = _tcstok(NULL, _T("\n"));
if (str) dat->newline = 1;
lvi.iImage = IMG_EMPTY;
}
if ( gVisible && dat == pActive && dat->Scroll == 1 )
ListView_EnsureVisible(dat->hList, last, FALSE);
if (last > gLimit) {
int idx = last - gLimit + gLimit/4; // leave only 75% of LIMIT
while (idx >= 0) {
ListView_DeleteItem(dat->hList, idx);
idx--;
}
}
}
mir_free((DUMPMSG*)lParam);
return TRUE;
case WM_SIZE:
{
UTILRESIZEDIALOG urd = { sizeof(urd) };
urd.hInstance = hInst;
urd.hwndDlg = hwndDlg;
urd.lpTemplate = MAKEINTRESOURCEA(IDD_LOG);
urd.pfnResizer = LogResize;
SetWindowPos(hwndDlg, HWND_TOP, rcTabs.left, rcTabs.top, rcTabs.right - rcTabs.left, rcTabs.bottom - rcTabs.top, SWP_SHOWWINDOW);
CallService(MS_UTILS_RESIZEDIALOG, 0, (LPARAM)&urd);
}
break;
case WM_COMMAND:
if (!dat)
break;
switch(LOWORD(wParam)) {
case IDC_PAUSE:
{
LVITEM lvi = {0};
dat->Paused = !(dat->Paused);
lvi.mask = LVIF_TEXT | LVIF_IMAGE;
lvi.iImage = IMG_INFO;
lvi.iItem = 0x7FFFFFFF;
lvi.pszText = (dat->Paused) ? TranslateT("*** Console paused ***") : TranslateT("*** Console resumed ***");
ListView_InsertItem(dat->hList, &lvi);
CheckDlgButton(hwndDlg, IDC_PAUSE, (dat->Paused) ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(hwndDlg,IDC_PAUSE,BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[((dat->Paused)?ICON_PAUSED:ICON_STARTED)]);
break;
}
case IDC_SCROLL:
dat->Scroll = !(dat->Scroll);
CheckDlgButton(hwndDlg, IDC_SCROLL, (dat->Scroll) ? BST_CHECKED : BST_UNCHECKED);
SendDlgItemMessage(hwndDlg,IDC_SCROLL,BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[((dat->Scroll)?ICON_SCROLL:ICON_NOSCROLL)]);
break;
case IDC_COPY:
{
int idx = 0;
TCHAR szText[128];
TCHAR *src, *dst, *buf;
int flags = LVNI_BELOW;
int count = ListView_GetSelectedCount(dat->hList);
if (count)
flags |= LVNI_SELECTED;
else
count = ListView_GetItemCount(dat->hList);
dst = buf = (TCHAR*)malloc((count*(sizeof(szText)+1)+1)*sizeof(TCHAR));
if (!buf) break;
while ((idx = ListView_GetNextItem(dat->hList, idx, flags)) > 0)
{
ListView_GetItemText(dat->hList, idx, 0, szText, SIZEOF(szText)-1);
src = szText;
while (*dst++ = *src++);
dst--;
*dst++ = '\r';
*dst++ = '\n';
*dst = 0;
}
if (dst - buf > 0 && OpenClipboard(hwndDlg)) {
EmptyClipboard();
HGLOBAL hClipboardData = GlobalAlloc(GMEM_DDESHARE, (dst-buf+1)*sizeof(TCHAR));
if (hClipboardData) {
TCHAR *pchData = (TCHAR*)GlobalLock(hClipboardData);
_tcscpy(pchData, buf);
GlobalUnlock(hClipboardData);
SetClipboardData(CF_UNICODETEXT,hClipboardData);
}
CloseClipboard();
}
free(buf);
break;
}
case IDC_DELETE:
{
int idx = 0;
int count = ListView_GetSelectedCount(dat->hList);
if ( !count ) break;
if ( count == ListView_GetItemCount(dat->hList)) {
LVITEM lvi = {0};
ListView_DeleteAllItems(dat->hList);
lvi.mask = LVIF_TEXT | LVIF_IMAGE;
lvi.iImage = IMG_INFO;
lvi.pszText = TranslateT("*** Console cleared ***");
ListView_InsertItem(dat->hList, &lvi);
dat->newline = 0;
break;
}
while ((idx = ListView_GetNextItem(dat->hList, idx, LVNI_BELOW|LVNI_SELECTED)) > 0)
{
ListView_DeleteItem(dat->hList, idx);
idx--;
}
}
break;
case IDC_SAVE:
{
TCHAR szFile[MAX_PATH];
if (!Openfile(szFile, ListView_GetSelectedCount(dat->hList))) break;
FILE *fp = _tfopen(szFile, _T("wt"));
if (fp) {
int idx = 0;
TCHAR szText[128];
int flags = LVNI_BELOW;
if (ListView_GetSelectedCount(dat->hList))
flags |= LVNI_SELECTED;
while ((idx = ListView_GetNextItem(dat->hList, idx, flags)) > 0)
{
ListView_GetItemText(dat->hList, idx, 0, szText, SIZEOF(szText));
_ftprintf(fp, _T("%s\n"), szText);
}
fclose(fp);
}
break;
}
case IDC_OPTIONS:
CallServiceSync(MS_NETLIB_LOGWIN,0,0);
break;
case IDC_STARTALL:
SendMessage(hwndConsole, HM_PAUSEALL, 0, 0);
break;
case IDC_PAUSEALL:
SendMessage(hwndConsole, HM_PAUSEALL, 0, 1);
break;
case IDC_CLOSE:
if (tabCount > 1)
SendMessage(hwndDlg, WM_CLOSE, 0, 0);
break;
}
break;
case WM_CLOSE:
DestroyWindow(hwndDlg);
break;
case WM_DESTROY:
SendMessage(hwndConsole, HM_REMOVE, 0, (LPARAM)dat);
break;
}
return FALSE;
}
int CMsnProto::MSN_GCEventHook(WPARAM, LPARAM lParam)
{
GCHOOK *gch = (GCHOOK*) lParam;
if (!gch)
return 1;
if (_stricmp(gch->pDest->pszModule, m_szModuleName)) return 0;
switch (gch->pDest->iType)
{
case GC_SESSION_TERMINATE:
{
ThreadData* thread = MSN_GetThreadByChatId(gch->pDest->ptszID);
if (thread != NULL)
thread->sendTerminate();
break;
}
case GC_USER_MESSAGE:
if (gch->ptszText && gch->ptszText[0])
{
ThreadData* thread = MSN_GetThreadByChatId(gch->pDest->ptszID);
if (thread)
{
rtrim(gch->ptszText); // remove the ending linebreak
TCHAR* pszMsg = UnEscapeChatTags(NEWTSTR_ALLOCA(gch->ptszText));
thread->sendMessage('N', NULL, NETID_MSN, UTF8(pszMsg), 0);
DBVARIANT dbv;
int bError = getTString("Nick", &dbv);
GCDEST gcd = { m_szModuleName, { NULL }, GC_EVENT_MESSAGE };
gcd.ptszID = gch->pDest->ptszID;
GCEVENT gce = {0};
gce.cbSize = sizeof(GCEVENT);
gce.dwFlags = GC_TCHAR | GCEF_ADDTOLOG;
gce.pDest = &gcd;
gce.ptszNick = bError ? _T("") : dbv.ptszVal;
gce.ptszUID = mir_a2t(MyOptions.szEmail);
gce.time = time(NULL);
gce.ptszText = gch->ptszText;
gce.bIsMe = TRUE;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
mir_free((void*)gce.ptszUID);
if (!bError)
MSN_FreeVariant(&dbv);
}
}
break;
case GC_USER_CHANMGR:
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_CHATROOM_INVITE), NULL, DlgInviteToChat,
LPARAM(new InviteChatParam(gch->pDest->ptszID, NULL, this)));
break;
case GC_USER_PRIVMESS:
{
char *email = mir_t2a(gch->ptszUID);
HANDLE hContact = MSN_HContactFromEmail(email);
MSN_CallService(MS_MSG_SENDMESSAGE, (WPARAM)hContact, 0);
mir_free(email);
break;
}
case GC_USER_LOGMENU:
switch(gch->dwData)
{
case 10:
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_CHATROOM_INVITE), NULL, DlgInviteToChat,
LPARAM(new InviteChatParam(gch->pDest->ptszID, NULL, this)));
break;
case 20:
MSN_KillChatSession(gch->pDest->ptszID);
break;
}
break;
case GC_USER_NICKLISTMENU:
{
char *email = mir_t2a(gch->ptszUID);
HANDLE hContact = MSN_HContactFromEmail(email);
mir_free(email);
switch(gch->dwData)
{
case 10:
MSN_CallService(MS_USERINFO_SHOWDIALOG, (WPARAM)hContact, 0);
break;
case 20:
MSN_CallService(MS_HISTORY_SHOWCONTACTHISTORY, (WPARAM)hContact, 0);
break;
case 110:
MSN_KillChatSession(gch->pDest->ptszID);
break;
}
break;
}
/* haven't implemented in chat.dll
case GC_USER_TYPNOTIFY:
{
int chatID = atoi(p);
ThreadData* thread = MSN_GetThreadByContact((HANDLE)-chatID);
for (int j=0; j < thread->mJoinedCount; j++)
{
if ((long)thread->mJoinedContacts[j] > 0)
CallService(MS_PROTO_SELFISTYPING, (WPARAM) thread->mJoinedContacts[j], (LPARAM) PROTOTYPE_SELFTYPING_ON);
}
break;
}
*/
}
return 0;
}
struct sipe_backend_chat_session *sipe_backend_chat_create(struct sipe_core_public *sipe_public,
struct sipe_chat_session *session,
const gchar *title,
const gchar *nick)
{
SIPPROTO *pr = sipe_public->backend_private;
GCSESSION gs;
GCDEST gcd = {0};
GCEVENT gce = {0};
gchar *id = g_strdup(title); /* FIXME: Generate ID */
struct sipe_backend_chat_session *conv = g_new0(struct sipe_backend_chat_session,1);
gs.cbSize = sizeof(gs);
gs.iType = GCW_CHATROOM;
gs.pszModule = pr->proto.m_szModuleName;
gs.pszName = title;
gs.pszID = id;
gs.pszStatusbarText = NULL;
gs.dwFlags = 0;
gs.dwItemData = (DWORD)session;
if (CallServiceSync( MS_GC_NEWSESSION, 0, (LPARAM)&gs ))
{
SIPE_DEBUG_ERROR("Failed to create chat session <%d> <%s>", id, title);
}
gcd.pszModule = pr->proto.m_szModuleName;
gcd.pszID = id;
gce.cbSize = sizeof(gce);
gce.pDest = &gcd;
gcd.iType = GC_EVENT_ADDGROUP;
gce.pszStatus = "Normal";
if (CallService( MS_GC_EVENT, 0, (LPARAM)&gce ))
{
SIPE_DEBUG_WARNING_NOFORMAT("Failed to add normal status to chat session");
}
gce.pszStatus = "Presenter";
if (CallService( MS_GC_EVENT, 0, (LPARAM)&gce ))
{
SIPE_DEBUG_WARNING_NOFORMAT("Failed to add presenter status to chat session");
}
gcd.iType = GC_EVENT_CONTROL;
if (CallServiceSync( MS_GC_EVENT, SESSION_INITDONE, (LPARAM)&gce ))
{
SIPE_DEBUG_WARNING_NOFORMAT("Failed to initdone chat session");
}
if (CallServiceSync( MS_GC_EVENT, SESSION_ONLINE, (LPARAM)&gce ))
{
SIPE_DEBUG_ERROR_NOFORMAT("Failed to set chat session online");
}
conv->conv = id;
conv->pr = pr;
return conv;
}
void PasteIt(MCONTACT hContact, int mode)
{
PasteToWeb* pasteToWeb = pasteToWebs[Options::instance->defWeb];
if(mode == FROM_CLIPBOARD)
{
pasteToWeb->FromClipboard();
}
else if(mode == FROM_FILE)
{
std::wstring file = GetFile();
if(file.length() > 0)
{
pasteToWeb->FromFile(file);
}
else return;
}
else return;
if(pasteToWeb->szFileLink[0] == 0 && pasteToWeb->error != NULL)
{
MessageBox(NULL, pasteToWeb->error, TranslateT("Error"), MB_OK | MB_ICONERROR);
}
else if(hContact != NULL && pasteToWeb->szFileLink[0] != 0)
{
char *szProto = GetContactProto(hContact);
if (szProto && (INT_PTR)szProto != CALLSERVICE_NOTFOUND)
{
BOOL isChat = db_get_b(hContact, szProto, "ChatRoom", 0);
if(Options::instance->autoSend)
{
if(!isChat)
{
DBEVENTINFO dbei = {0};
dbei.cbSize = sizeof(dbei);
dbei.eventType = EVENTTYPE_MESSAGE;
dbei.flags = DBEF_SENT;
dbei.szModule = szProto;
dbei.timestamp = (DWORD)time(NULL);
dbei.cbBlob = (DWORD)strlen(pasteToWeb->szFileLink) + 1;
dbei.pBlob = (PBYTE)pasteToWeb->szFileLink;
db_event_add(hContact, &dbei);
CallContactService(hContact, PSS_MESSAGE, 0, (LPARAM)pasteToWeb->szFileLink);
}
else
{
// PSS_MESSAGE is not compatible with chat rooms
// there are no simple method to send text to all users
// in chat room.
// Next step is to get all protocol sessions and find
// one with correct hContact
GC_INFO gci = {0};
GCDEST gcd = { szProto, NULL, GC_EVENT_SENDMESSAGE };
GCEVENT gce = { sizeof(gce), &gcd };
int cnt = (int)CallService(MS_GC_GETSESSIONCOUNT, 0, (LPARAM)szProto);
for (int i = 0; i < cnt ; i++ )
{
gci.iItem = i;
gci.pszModule = szProto;
gci.Flags = GCF_BYINDEX | GCF_HCONTACT | GCF_ID;
CallService(MS_GC_GETINFO, 0, (LPARAM)&gci);
if (gci.hContact == hContact)
{
// In this place session was finded, gci.pszID contains
// session ID, but it is in unicode or ascii format,
// depends on protocol wersion
gcd.ptszID = gci.pszID;
gce.bIsMe = TRUE;
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszText = mir_a2u_cp(pasteToWeb->szFileLink, CP_ACP);
gce.time = time(NULL);
CallService(MS_GC_EVENT, 0, (LPARAM)(GCEVENT *) &gce);
mir_free((void*)gce.ptszText);
break;
}
}
}
// Send message to focus window
CallServiceSync(MS_MSG_SENDMESSAGE, hContact, 0);
}
else
{
if(isChat)
{
// MS_MSG_SENDMESSAGE in incompatible with chat rooms,
// because it sends text to IDC_MESSAGE window,
// but in chat rooms is only IDC_CHAT_MESSAGE window.
// contactWindows map contains all opened hContact
// with assaigned to them chat windows.
// This map is prepared in ME_MSG_WINDOWEVENT event.
std::map<MCONTACT, HWND>::iterator it = contactWindows->find(hContact);
if(it != contactWindows->end())
{
// it->second is imput window, so now I can send to them
// new text. Afterr all is sended MS_MSG_SENDMESSAGE
// to focus window.
SendMessage(it->second, EM_SETSEL, -1, SendMessage(it->second, WM_GETTEXTLENGTH, 0, 0));
SendMessageA(it->second, EM_REPLACESEL, FALSE, (LPARAM)pasteToWeb->szFileLink);
CallServiceSync(MS_MSG_SENDMESSAGE, hContact, NULL);
}
else
{
// If window do not exist, maybe it is not chat
CallServiceSync(MS_MSG_SENDMESSAGE, hContact, (LPARAM)pasteToWeb->szFileLink);
}
}
else
{
CallServiceSync(MS_MSG_SENDMESSAGE, hContact, (LPARAM)pasteToWeb->szFileLink);
}
}
}
}
}
static INT_PTR Proto_ChainRecv(WPARAM wParam,LPARAM lParam)
{
/* this will switch threads just like before */
return CallServiceSync(MS_PROTO_CHAINRECV "ThreadSafe",wParam,lParam);
}
int CMimAPI::MessageEventAdded(WPARAM hContact, LPARAM lParam)
{
TCHAR szName[CONTAINER_NAMELEN + 1];
HANDLE hDbEvent = (HANDLE)lParam;
DBEVENTINFO dbei = { sizeof(dbei) };
db_event_get(hDbEvent, &dbei);
HWND hwnd = M.FindWindow(hContact);
if (hwnd == NULL)
hwnd = M.FindWindow(db_event_getContact(hDbEvent));
BOOL isCustomEvent = IsCustomEvent(dbei.eventType);
BOOL isShownCustomEvent = DbEventIsForMsgWindow(&dbei);
if (dbei.markedRead() || (isCustomEvent && !isShownCustomEvent))
return 0;
CallServiceSync(MS_CLIST_REMOVEEVENT, hContact, 1);
bool bAllowAutoCreate = false;
bool bAutoPopup = M.GetByte(SRMSGSET_AUTOPOPUP, SRMSGDEFSET_AUTOPOPUP) != 0;
bool bAutoCreate = M.GetByte("autotabs", 1) != 0;
bool bAutoContainer = M.GetByte("autocontainer", 1) != 0;
DWORD dwStatusMask = M.GetDword("autopopupmask", -1);
if (hwnd) {
TContainerData *pTargetContainer = 0;
SendMessage(hwnd, DM_QUERYCONTAINER, 0, (LPARAM)&pTargetContainer);
if (pTargetContainer == NULL || !PluginConfig.m_HideOnClose || IsWindowVisible(pTargetContainer->hwnd))
return 0;
WINDOWPLACEMENT wp = { 0 };
wp.length = sizeof(wp);
GetWindowPlacement(pTargetContainer->hwnd, &wp);
GetContainerNameForContact(hContact, szName, CONTAINER_NAMELEN);
if (bAutoPopup || bAutoCreate) {
if (bAutoPopup) {
if (wp.showCmd == SW_SHOWMAXIMIZED)
ShowWindow(pTargetContainer->hwnd, SW_SHOWMAXIMIZED);
else
ShowWindow(pTargetContainer->hwnd, SW_SHOWNOACTIVATE);
return 0;
}
TContainerData *pContainer = FindContainerByName(szName);
if (pContainer != NULL) {
if (bAutoContainer) {
ShowWindow(pTargetContainer->hwnd, SW_SHOWMINNOACTIVE);
return 0;
}
goto nowindowcreate;
}
else if (bAutoContainer) {
ShowWindow(pTargetContainer->hwnd, SW_SHOWMINNOACTIVE);
return 0;
}
}
}
else {
switch (dbei.eventType) {
case EVENTTYPE_AUTHREQUEST:
case EVENTTYPE_ADDED:
return 0;
case EVENTTYPE_FILE:
tabSRMM_ShowPopup(hContact, hDbEvent, dbei.eventType, 0, 0, 0, dbei.szModule, 0);
return 0;
}
}
// if no window is open, we are not interested in anything else but unread message events
// new message
if (!nen_options.iNoSounds)
SkinPlaySound("AlertMsg");
if (nen_options.iNoAutoPopup)
goto nowindowcreate;
GetContainerNameForContact(hContact, szName, CONTAINER_NAMELEN);
if (dwStatusMask == -1)
bAllowAutoCreate = true;
else {
char *szProto = GetContactProto(hContact);
if (szProto && !strcmp(szProto, META_PROTO))
szProto = GetContactProto(db_mc_getSrmmSub(hContact));
if (szProto) {
DWORD dwStatus = (DWORD)CallProtoService(szProto, PS_GETSTATUS, 0, 0);
if (dwStatus == 0 || dwStatus <= ID_STATUS_OFFLINE || ((1 << (dwStatus - ID_STATUS_ONLINE)) & dwStatusMask)) // should never happen, but...
bAllowAutoCreate = true;
}
}
if (bAllowAutoCreate && (bAutoPopup || bAutoCreate)) {
if (bAutoPopup) {
TContainerData *pContainer = FindContainerByName(szName);
if (pContainer == NULL)
pContainer = CreateContainer(szName, FALSE, hContact);
if (pContainer)
CreateNewTabForContact(pContainer, hContact, 0, NULL, TRUE, TRUE, FALSE, 0);
return 0;
}
bool bActivate = false, bPopup = M.GetByte("cpopup", 0) != 0;
TContainerData *pContainer = FindContainerByName(szName);
if (pContainer != NULL) {
if (M.GetByte("limittabs", 0) && !wcsncmp(pContainer->szName, L"default", 6)) {
if ((pContainer = FindMatchingContainer(L"default", hContact)) != NULL) {
CreateNewTabForContact(pContainer, hContact, 0, NULL, bActivate, bPopup, TRUE, hDbEvent);
return 0;
}
}
else {
CreateNewTabForContact(pContainer, hContact, 0, NULL, bActivate, bPopup, TRUE, hDbEvent);
return 0;
}
}
if (bAutoContainer) {
if ((pContainer = CreateContainer(szName, CNT_CREATEFLAG_MINIMIZED, hContact)) != NULL) { // 2 means create minimized, don't popup...
CreateNewTabForContact(pContainer, hContact, 0, NULL, bActivate, bPopup, TRUE, hDbEvent);
SendMessageW(pContainer->hwnd, WM_SIZE, 0, 0);
}
return 0;
}
}
// for tray support, we add the event to the tray menu. otherwise we send it back to
// the contact list for flashing
nowindowcreate:
if (!(dbei.flags & DBEF_READ)) {
UpdateTrayMenu(0, 0, dbei.szModule, NULL, hContact, 1);
if (!nen_options.bTraySupport) {
TCHAR toolTip[256], *contactName;
CLISTEVENT cle = { sizeof(cle) };
cle.hContact = hContact;
cle.hDbEvent = hDbEvent;
cle.flags = CLEF_TCHAR;
cle.hIcon = LoadSkinnedIcon(SKINICON_EVENT_MESSAGE);
cle.pszService = "SRMsg/ReadMessage";
contactName = pcli->pfnGetContactDisplayName(hContact, 0);
mir_sntprintf(toolTip, SIZEOF(toolTip), TranslateT("Message from %s"), contactName);
cle.ptszTooltip = toolTip;
CallService(MS_CLIST_ADDEVENT, 0, (LPARAM)&cle);
}
tabSRMM_ShowPopup(hContact, hDbEvent, dbei.eventType, 0, 0, 0, dbei.szModule, 0);
}
return 0;
}
void CMsnProto::MSN_GCProcessThreadActivity(ezxml_t xmli, const TCHAR *mChatID)
{
if (!mir_strcmp(xmli->name, "topicupdate")) {
ezxml_t initiator = ezxml_child(xmli, "initiator");
GCDEST gcd = { m_szModuleName, mChatID, GC_EVENT_TOPIC};
GCEVENT gce = { sizeof(gce), &gcd };
gce.dwFlags = GCEF_ADDTOLOG;
gce.time = MsnTSToUnixtime(ezxml_txt(ezxml_child(xmli, "eventtime")));
gce.ptszUID = initiator?mir_a2t(initiator->txt):NULL;
MCONTACT hContInitiator = MSN_HContactFromEmail(initiator->txt);
gce.ptszNick = GetContactNameT(hContInitiator);
gce.ptszText = mir_a2t(ezxml_txt(ezxml_child(xmli, "value")));
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
mir_free((TCHAR*)gce.ptszUID);
mir_free((TCHAR*)gce.ptszText);
}
else if (ezxml_t target = ezxml_child(xmli, "target")) {
MCONTACT hContInitiator = NULL;
GCDEST gcd = { m_szModuleName, mChatID, 0};
GCEVENT gce = { sizeof(gce), &gcd };
gce.dwFlags = GCEF_ADDTOLOG;
if (!mir_strcmp(xmli->name, "deletemember")) {
gcd.iType = GC_EVENT_PART;
if (ezxml_t initiator = ezxml_child(xmli, "initiator")) {
if (mir_strcmp(initiator->txt, target->txt)) {
hContInitiator = MSN_HContactFromEmail(initiator->txt);
gce.ptszStatus = GetContactNameT(hContInitiator);
gcd.iType = GC_EVENT_KICK;
}
}
}
else if (!mir_strcmp(xmli->name, "addmember")) {
gcd.iType = GC_EVENT_JOIN;
}
else if (!mir_strcmp(xmli->name, "roleupdate")) {
gcd.iType = GC_EVENT_ADDSTATUS;
if (ezxml_t initiator = ezxml_child(xmli, "initiator")) {
hContInitiator = MSN_HContactFromEmail(initiator->txt);
gce.ptszText= GetContactNameT(hContInitiator);
}
gce.ptszStatus = _T("admin");
}
if (gcd.iType) {
gce.time = MsnTSToUnixtime(ezxml_txt(ezxml_child(xmli, "eventtime")));
const char *pszTarget = NULL;
while (target) {
switch (gcd.iType) {
case GC_EVENT_JOIN:
gce.ptszStatus = MSN_GCGetRole(MSN_GetThreadByChatId(mChatID), target->txt);
// ..fall through.. //
case GC_EVENT_KICK:
case GC_EVENT_PART:
pszTarget = target->txt;
break;
case GC_EVENT_ADDSTATUS:
case GC_EVENT_REMOVESTATUS:
gcd.iType = mir_strcmp(ezxml_txt(ezxml_child(target, "role")), "admin") == 0 ? GC_EVENT_ADDSTATUS : GC_EVENT_REMOVESTATUS;
pszTarget = ezxml_txt(ezxml_child(target, "id"));
break;
}
char *szEmail, *szNet;
parseWLID(NEWSTR_ALLOCA(pszTarget), &szNet, &szEmail, NULL);
gce.bIsMe = !mir_strcmpi(szEmail, GetMyUsername(atoi(szNet)));
gce.ptszUID = mir_a2t(pszTarget);
MCONTACT hContTarget = MSN_HContactFromEmail(pszTarget);
gce.ptszNick = GetContactNameT(hContTarget);
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
mir_free((TCHAR*)gce.ptszUID);
if ((gcd.iType == GC_EVENT_PART || gcd.iType == GC_EVENT_KICK) && gce.bIsMe) {
GCDEST gcd2 = { m_szModuleName, mChatID, GC_EVENT_CONTROL };
GCEVENT gce2 = { sizeof(gce2), &gcd2 };
CallServiceSync(MS_GC_EVENT, SESSION_OFFLINE, (LPARAM)&gce2);
break;
}
target = ezxml_next(target);
}
}
}
}
static void ApplyUpdates(void *param)
{
HWND hDlg = (HWND)param;
OBJLIST<FILEINFO> &todo = *(OBJLIST<FILEINFO> *)GetWindowLongPtr(hDlg, GWLP_USERDATA);
if (todo.getCount() == 0) {
return;
}
// 1) If we need to escalate priviledges, launch a stub
if (!PrepareEscalation()) {
PostMessage(hDlg, WM_CLOSE, 0, 0);
return;
}
AutoHandle pipe(hPipe);
HWND hwndList = GetDlgItem(hDlg, IDC_LIST_UPDATES);
//create needed folders after escalating priviledges. Folders creates when we actually install updates
TCHAR tszFileTemp[MAX_PATH], tszFileBack[MAX_PATH];
mir_sntprintf(tszFileBack, SIZEOF(tszFileBack), _T("%s\\Backups"), tszRoot);
SafeCreateDirectory(tszFileBack);
mir_sntprintf(tszFileTemp, SIZEOF(tszFileTemp), _T("%s\\Temp"), tszRoot);
SafeCreateDirectory(tszFileTemp);
// 2) Download all plugins
HANDLE nlc = NULL;
for (int i=0; i < todo.getCount(); i++) {
ListView_EnsureVisible(hwndList, i, FALSE);
if (!todo[i].bEnabled) {
SetStringText(hwndList, i, TranslateT("Skipped."));
}
else if (todo[i].bDeleteOnly) {
SetStringText(hwndList, i, TranslateT("Will be deleted!"));
}
else {
// download update
SetStringText(hwndList, i, TranslateT("Downloading..."));
FILEURL *pFileUrl = &todo[i].File;
if (!DownloadFile(pFileUrl, nlc)) {
SetStringText(hwndList, i, TranslateT("Failed!"));
// interrupt update as we require all components to be updated
Netlib_CloseHandle(nlc);
PostMessage(hDlg, UM_ERROR, 0, 0);
SkinPlaySound("updatefailed");
return;
}
SetStringText(hwndList, i, TranslateT("Succeeded."));
}
}
Netlib_CloseHandle(nlc);
// 3) Unpack all zips
VARST tszMirandaPath(_T("%miranda_path%"));
for (int i = 0; i < todo.getCount(); i++) {
FILEINFO& p = todo[i];
if (p.bEnabled) {
if (p.bDeleteOnly) {
// we need only to backup the old file
TCHAR *ptszRelPath = p.tszNewName + _tcslen(tszMirandaPath) + 1, tszBackFile[MAX_PATH];
mir_sntprintf(tszBackFile, SIZEOF(tszBackFile), _T("%s\\%s"), tszFileBack, ptszRelPath);
BackupFile(p.tszNewName, tszBackFile);
}
else {
// if file name differs, we also need to backup the old file here
// otherwise it would be replaced by unzip
if ( _tcsicmp(p.tszOldName, p.tszNewName)) {
TCHAR tszSrcPath[MAX_PATH], tszBackFile[MAX_PATH];
mir_sntprintf(tszSrcPath, SIZEOF(tszSrcPath), _T("%s\\%s"), tszMirandaPath, p.tszOldName);
mir_sntprintf(tszBackFile, SIZEOF(tszBackFile), _T("%s\\%s"), tszFileBack, p.tszOldName);
BackupFile(tszSrcPath, tszBackFile);
}
if ( unzip(p.File.tszDiskPath, tszMirandaPath, tszFileBack,true))
SafeDeleteFile(p.File.tszDiskPath); // remove .zip after successful update
}
}
}
SkinPlaySound("updatecompleted");
#if MIRANDA_VER < 0x0A00
// 4) Change title of clist
ptrT title = db_get_tsa(NULL, "CList", "TitleText");
if (!_tcsicmp(title, _T("Miranda IM")))
db_set_ts(NULL, "CList", "TitleText", _T("Miranda NG"));
#endif
opts.bForceRedownload = false;
db_unset(NULL, MODNAME, DB_SETTING_REDOWNLOAD);
db_set_b(NULL, MODNAME, DB_SETTING_RESTART_COUNT, 5);
// 5) Prepare Restart
int rc = MessageBox(hDlg, TranslateT("Update complete. Press Yes to restart Miranda now or No to postpone a restart until the exit."), TranslateT("Plugin Updater"), MB_YESNO | MB_ICONQUESTION);
PostMessage(hDlg, WM_CLOSE, 0, 0);
if (rc == IDYES)
#if MIRANDA_VER >= 0x0A00
CallServiceSync(MS_SYSTEM_RESTART, db_get_b(NULL, MODNAME, "RestartCurrentProfile", 1) ? 1 : 0, 0);
#else
CallFunctionAsync(RestartMe, 0);
#endif
}
void CVkProto::OnReceiveChatInfo(NETLIBHTTPREQUEST *reply, AsyncHttpRequest *pReq)
{
debugLogA("CVkProto::OnReceiveChatInfo %d", reply->resultCode);
if (reply->resultCode != 200)
return;
JSONROOT pRoot;
JSONNODE *pResponse = CheckJsonResponse(pReq, reply, pRoot);
if (pResponse == NULL)
return;
CVkChatInfo *cc = (CVkChatInfo*)pReq->pUserInfo;
if (m_chats.indexOf(cc) == -1)
return;
JSONNODE *info = json_get(pResponse, "info");
if (info != NULL) {
ptrT tszTitle(json_as_string(json_get(info, "title")));
if (lstrcmp(tszTitle, cc->m_tszTopic)) {
cc->m_tszTopic = mir_tstrdup(tszTitle);
setTString(cc->m_hContact, "Nick", tszTitle);
GCDEST gcd = { m_szModuleName, cc->m_tszId, GC_EVENT_CHANGESESSIONAME };
GCEVENT gce = { sizeof(GCEVENT), &gcd };
gce.ptszText = tszTitle;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
}
cc->m_admin_id = json_as_int(json_get(info, "admin_id"));
}
JSONNODE *users = json_as_array(json_get(pResponse, "users"));
if (users != NULL) {
for (int i = 0; i < cc->m_users.getCount(); i++)
cc->m_users[i].m_bDel = true;
for (int i = 0;; i++) {
JSONNODE *pUser = json_at(users, i);
if (pUser == NULL)
break;
int uid = json_as_int(json_get(pUser, "uid"));
TCHAR tszId[20];
_itot(uid, tszId, 10);
bool bNew;
CVkChatUser *cu = cc->m_users.find((CVkChatUser*)&uid);
if (cu == NULL) {
cc->m_users.insert(cu = new CVkChatUser(uid));
bNew = true;
}
else bNew = cu->m_bUnknown;
cu->m_bDel = false;
ptrT fName(json_as_string(json_get(pUser, "first_name")));
ptrT lName(json_as_string(json_get(pUser, "last_name")));
CMString tszNick = CMString(fName).Trim() + _T(" ") + CMString(lName).Trim();
cu->m_tszNick = mir_tstrdup(tszNick);
cu->m_bUnknown = false;
if (bNew) {
GCDEST gcd = { m_szModuleName, cc->m_tszId, GC_EVENT_JOIN };
GCEVENT gce = { sizeof(GCEVENT), &gcd };
gce.bIsMe = uid == m_myUserId;
gce.ptszUID = tszId;
gce.ptszNick = tszNick;
gce.ptszStatus = TranslateTS(sttStatuses[uid == cc->m_admin_id]);
gce.dwItemData = (INT_PTR)cu;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
}
}
for (int i = cc->m_users.getCount() - 1; i >= 0; i--) {
CVkChatUser &cu = cc->m_users[i];
if (!cu.m_bDel)
continue;
TCHAR tszId[20];
_itot(cu.m_uid, tszId, 10);
GCDEST gcd = { m_szModuleName, cc->m_tszId, GC_EVENT_PART };
GCEVENT gce = { sizeof(GCEVENT), &gcd };
gce.ptszUID = tszId;
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
cc->m_users.remove(i);
}
}
JSONNODE *msgs = json_as_array(json_get(pResponse, "msgs"));
if (msgs != NULL) {
for (int i = 1;; i++) {
JSONNODE *pMsg = json_at(msgs, i);
if (pMsg == NULL)
break;
AppendChatMessage(cc->m_chatid, pMsg, true);
}
cc->m_bHistoryRead = true;
}
for (int j = 0; j < cc->m_msgs.getCount(); j++) {
CVkChatMessage &p = cc->m_msgs[j];
AppendChatMessage(cc, p.m_mid, p.m_uid, p.m_date, p.m_tszBody, p.m_bHistory);
}
cc->m_msgs.destroy();
}
