void FacebookProto::UpdateChat(const char *chat_id, const char *id, const char *name, const char *message, DWORD timestamp, bool is_old)
{
// replace % to %% to not interfere with chat color codes
std::string smessage = message;
utils::text::replace_all(&smessage, "%", "%%");
ptrT tid(mir_a2t(id));
ptrT tnick(mir_a2t_cp(name, CP_UTF8));
ptrT ttext(mir_a2t_cp(smessage.c_str(), CP_UTF8));
ptrT tchat_id(mir_a2t(chat_id));
GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_MESSAGE };
GCEVENT gce = { sizeof(gce), &gcd };
gce.ptszText = ttext;
gce.time = timestamp ? timestamp : ::time(NULL);
if (id != NULL)
gce.bIsMe = !mir_strcmp(id, facy.self_.user_id.c_str());
gce.dwFlags |= GCEF_ADDTOLOG;
if (is_old) {
gce.dwFlags |= GCEF_NOTNOTIFY;
gce.dwFlags &= ~GCEF_ADDTOLOG;
}
gce.ptszNick = tnick;
gce.ptszUID = tid;
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
facy.erase_reader(ChatIDToHContact(chat_id));
}
void FacebookProto::UpdateChat(const char *chat_id, const char *id, const char *name, const char *message)
{
GCDEST gcd = { m_szModuleName };
gcd.ptszID = mir_a2t(chat_id);
GCEVENT gce = {sizeof(gce)};
gce.pDest = &gcd;
gce.ptszText = mir_a2t_cp(message,CP_UTF8);
gce.time = ::time(NULL);
gce.dwFlags = GC_TCHAR;
gcd.iType = GC_EVENT_MESSAGE;
gce.bIsMe = !strcmp(id,facy.self_.user_id.c_str());
gce.dwFlags |= GCEF_ADDTOLOG;
gce.ptszNick = mir_a2t_cp(name,CP_UTF8);
gce.ptszUID = mir_a2t(id);
CallServiceSync(MS_GC_EVENT,0,reinterpret_cast<LPARAM>(&gce));
mir_free(const_cast<TCHAR*>(gce.ptszUID));
mir_free(const_cast<TCHAR*>(gce.ptszNick));
mir_free(const_cast<TCHAR*>(gce.ptszText));
mir_free(const_cast<TCHAR*>(gcd.ptszID));
// Close chat window, if set
ForkThread( &FacebookProto::MessagingWorker, this, new send_messaging(chat_id, FACEBOOK_SEND_MESSAGE ) );
}
void WhatsAppProto::NotifyEvent(const string& title, const string& info, MCONTACT contact, DWORD flags, TCHAR* url)
{
TCHAR *rawTitle = mir_a2t_cp(title.c_str(), CP_UTF8);
TCHAR *rawInfo = mir_a2t_cp(info.c_str(), CP_UTF8);
NotifyEvent(rawTitle, rawInfo, contact, flags, url);
mir_free(rawTitle);
mir_free(rawInfo);
}
void FacebookProto::AddChatContact(const char *chat_id, const char *id, const char *name)
{
if (IsChatContact(chat_id, id))
return;
ptrT tchat_id(mir_a2t(chat_id));
ptrT tnick(mir_a2t_cp(name, CP_UTF8));
ptrT tid(mir_a2t(id));
GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_JOIN };
GCEVENT gce = { sizeof(gce), &gcd };
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = tnick;
gce.ptszUID = tid;
gce.time = ::time(NULL);
gce.bIsMe = !mir_strcmp(id, facy.self_.user_id.c_str());
if (gce.bIsMe) {
gce.ptszStatus = TranslateT("Myself");
}
else {
MCONTACT hContact = ContactIDToHContact(id);
if (hContact == NULL || getByte(hContact, FACEBOOK_KEY_CONTACT_TYPE, CONTACT_NONE) != CONTACT_FRIEND)
gce.ptszStatus = TranslateT("User");
else {
gce.ptszStatus = TranslateT("Friend");
}
}
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
}
void CSkypeProto::RemoveChatContact(const TCHAR *tchat_id, const char *id, const char *name, bool isKick, const char *initiator)
{
if (IsMe(id))
return;
ptrT tnick(mir_a2t_cp(name, CP_UTF8));
ptrT tid(mir_a2t(id));
ptrT tinitiator(mir_a2t(initiator));
GCDEST gcd = { m_szModuleName, tchat_id, isKick ? GC_EVENT_KICK : GC_EVENT_PART };
GCEVENT gce = { sizeof(gce), &gcd };
if (isKick)
{
gce.ptszUID = tid;
gce.ptszNick = tnick;
gce.ptszStatus = tinitiator;
gce.time = time(NULL);
}
else
{
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = tnick;
gce.ptszUID = tid;
gce.time = time(NULL);
gce.bIsMe = IsMe(id);
}
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
}
void TwitterProto::UpdateChat(const twitter_user &update)
{
GCDEST gcd = { m_szModuleName, m_tszUserName, GC_EVENT_MESSAGE };
GCEVENT gce = { sizeof(gce), &gcd };
gce.pDest = &gcd;
gce.bIsMe = (update.username == twit_.get_username());
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszUID = mir_a2t(update.username.c_str());
//TODO: write code here to replace % with %% in update.status.text (which is a std::string)
std::string chatText = update.status.text;
replaceAll(chatText, "%", "%%");
gce.ptszText = mir_a2t_cp(chatText.c_str(), CP_UTF8);
//gce.ptszText = mir_a2t_cp(update.status.text.c_str(),CP_UTF8);
gce.time = static_cast<DWORD>(update.status.time);
DBVARIANT nick;
MCONTACT hContact = UsernameToHContact(update.username.c_str());
if (hContact && !db_get_s(hContact, "CList", "MyHandle", &nick)) {
gce.ptszNick = mir_a2t(nick.pszVal);
db_free(&nick);
}
else
gce.ptszNick = mir_a2t(update.username.c_str());
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
mir_free(const_cast<TCHAR*>(gce.ptszNick));
mir_free(const_cast<TCHAR*>(gce.ptszUID));
mir_free(const_cast<TCHAR*>(gce.ptszText));
}
void FacebookProto::AddChatContact(const char *chat_id, const char *id, const char *name)
{
GCDEST gcd = { m_szModuleName };
gcd.ptszID = mir_a2t(chat_id);
gcd.iType = GC_EVENT_JOIN;
GCEVENT gce = {sizeof(gce)};
gce.pDest = &gcd;
gce.dwFlags = GC_TCHAR | GCEF_ADDTOLOG;
gce.ptszNick = mir_a2t_cp(name, CP_UTF8);
gce.ptszUID = mir_a2t(id);
gce.time = ::time(NULL);
gce.bIsMe = !strcmp(id, facy.self_.user_id.c_str());
if (gce.bIsMe)
gce.ptszStatus = _T("Admin");
else
gce.ptszStatus = _T("Normal");
CallServiceSync(MS_GC_EVENT,0,reinterpret_cast<LPARAM>(&gce));
mir_free(const_cast<TCHAR*>(gce.ptszNick));
mir_free(const_cast<TCHAR*>(gce.ptszUID));
mir_free(const_cast<TCHAR*>(gcd.ptszID));
}
static TCHAR *latin2t(const char *p)
{
if (p == NULL)
return mir_tstrdup(_T(""));
return mir_a2t_cp(p, 1250);
}
//------------------------------------------------------------------------------
std::wstring UserInformation::nameString(MCONTACT user) const
{
//WCHAR *ret = reinterpret_cast<WCHAR *>(CallService(MS_CLIST_GETCONTACTDISPLAYNAME, reinterpret_cast<unsigned int>(user), 0));
char* ret = (char *)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, WPARAM(user), 0);
if (0 == ret)
{
return L"";
}
return TranslateW(mir_a2t_cp(ret, CP_UTF8));
}
void FacebookProto::RenameChat(const char *chat_id, const char *name)
{
ptrT tchat_id(mir_a2t(chat_id));
ptrT tname(mir_a2t_cp(name, CP_UTF8));
GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_CHANGESESSIONAME };
GCEVENT gce = { sizeof(gce), &gcd };
gce.ptszText = tname;
CallService(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
}
void OmegleProto::SendMsgWorker(void *p)
{
if (p == NULL)
return;
ScopedLock s(facy.send_message_lock_);
std::string data = *(std::string*)p;
delete (std::string*)p;
data = utils::text::trim(data);
if (facy.state_ == STATE_ACTIVE && data.length() && facy.send_message(data))
{
TCHAR *msg = mir_a2t_cp(data.c_str(), CP_UTF8);
UpdateChat(facy.nick_, msg);
mir_free(msg);
}
}
void FacebookProto::AddChat(const char *id, const char *name)
{
GCSESSION gcw = {sizeof(gcw)};
// Create the group chat session
gcw.dwFlags = GC_TCHAR;
gcw.iType = GCW_CHATROOM;
gcw.pszModule = m_szModuleName;
gcw.ptszName = mir_a2t_cp(name, CP_UTF8);
gcw.ptszID = mir_a2t(id);
CallServiceSync(MS_GC_NEWSESSION, 0, (LPARAM)&gcw);
mir_free(const_cast<TCHAR*>(gcw.ptszName));
mir_free(const_cast<TCHAR*>(gcw.ptszID));
// Send setting events
GCDEST gcd = { m_szModuleName };
gcd.ptszID = mir_a2t(id);
GCEVENT gce = {sizeof(gce)};
gce.pDest = &gcd;
gce.dwFlags = GC_TCHAR;
// Create a user statuses
gcd.iType = GC_EVENT_ADDGROUP;
gce.ptszStatus = _T("Admin");
CallServiceSync( MS_GC_EVENT, NULL, reinterpret_cast<LPARAM>(&gce) );
gce.ptszStatus = _T("Normal");
CallServiceSync( MS_GC_EVENT, NULL, reinterpret_cast<LPARAM>(&gce) );
// Finish initialization
gcd.iType = GC_EVENT_CONTROL;
gce.time = ::time(NULL);
gce.pDest = &gcd;
// Add self contact
AddChatContact(id, facy.self_.user_id.c_str(), facy.self_.real_name.c_str());
CallServiceSync(MS_GC_EVENT,SESSION_INITDONE,reinterpret_cast<LPARAM>(&gce));
CallServiceSync(MS_GC_EVENT,SESSION_ONLINE, reinterpret_cast<LPARAM>(&gce));
mir_free(const_cast<TCHAR*>(gcd.ptszID));
}
void FacebookProto::RemoveChatContact(const char *chat_id, const char *id, const char *name)
{
// We dont want to remove our self-contact from chat. Ever.
if (!mir_strcmp(id, facy.self_.user_id.c_str()))
return;
ptrT tchat_id(mir_a2t(chat_id));
ptrT tnick(mir_a2t_cp(name, CP_UTF8));
ptrT tid(mir_a2t(id));
GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_PART };
GCEVENT gce = { sizeof(gce), &gcd };
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = tnick;
gce.ptszUID = tid;
gce.time = ::time(NULL);
gce.bIsMe = false;
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
}
void CSkypeProto::AddChatContact(const TCHAR *tchat_id, const char *id, const char *name, const TCHAR *role, bool isChange)
{
if (IsChatContact(tchat_id, id))
return;
ptrT tnick(mir_a2t_cp(name, CP_UTF8));
ptrT tid(mir_a2t(id));
GCDEST gcd = { m_szModuleName, tchat_id, GC_EVENT_JOIN };
GCEVENT gce = { sizeof(gce), &gcd };
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = tnick;
gce.ptszUID = tid;
gce.time = !isChange ? time(NULL) : NULL;
gce.bIsMe = IsMe(id);
gce.ptszStatus = TranslateTS(role);
CallServiceSync(MS_GC_EVENT, 0, reinterpret_cast<LPARAM>(&gce));
}
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));
}
bool Omegle_client::events( )
{
handle_entry( "events" );
std::string data = "id=" + this->chat_id_;
// Get update
http::response resp = flap( OMEGLE_REQUEST_EVENTS, &data );
// Return
switch ( resp.code )
{
case HTTP_CODE_OK:
{
if ( resp.data == "null" ) {
// Everything is OK, no new message received -- OR it is a problem
// TODO: if we are waiting for Stranger with common likes, then we should try standard Stranger if this takes too long
return handle_error( "events" );
} else if ( resp.data == "fail" ) {
// Something went wrong
return handle_error( "events" );
}
std::string::size_type pos = 0;
bool newStranger = false;
bool waiting = false;
if ( resp.data.find( "[\"waiting\"]" ) != std::string::npos ) {
// We are just waiting for new Stranger
waiting = true;
}
/*if ( (pos = resp.data.find( "[\"count\"," )) != std::string::npos ) {
// We got info about count of connected people there
pos += 9;
std::string count = utils::text::trim( resp.data.substr(pos, resp.data.find("]", pos) - pos));
char str[255];
mir_snprintf(str, sizeof(str), Translate("On whole Omegle are %s strangers online now."), count.c_str());
TCHAR *msg = mir_a2t_cp(str,CP_UTF8);
parent->UpdateChat(NULL, msg);
mir_free(msg);
}*/
if ( (pos = resp.data.find( "[\"serverMessage\", \"" )) != std::string::npos ) {
// We got server message
pos += 19;
std::string message = utils::text::trim( resp.data.substr(pos, resp.data.find("\"]", pos) - pos));
TCHAR *tstr = Langpack_PcharToTchar(message.c_str());
parent->UpdateChat(NULL, tstr);
mir_free(tstr);
}
if ( resp.data.find( "[\"connected\"]" ) != std::string::npos ) {
// Stranger connected
if (this->spy_mode_ && !this->question_.empty()) {
parent->AddChatContact(TranslateT("Stranger 1"));
parent->AddChatContact(TranslateT("Stranger 2"));
this->state_ = STATE_SPY;
} else {
parent->AddChatContact(TranslateT("Stranger"));
this->state_ = STATE_ACTIVE;
}
newStranger = true;
waiting = false;
}
if ( (pos = resp.data.find( "[\"commonLikes\"," )) != std::string::npos ) {
pos += 18;
std::string like = resp.data.substr(pos, resp.data.find("\"]", pos) - pos);
utils::text::replace_all(&like, "\", \"", ", ");
parent->debugLogA("Got common likes: '%s'", like.c_str());
like = Translate("You and the Stranger both like: ") + like;
TCHAR *msg = mir_a2t(like.c_str());
parent->SetTopic(msg);
mir_free(msg);
}
if ( (pos = resp.data.find( "[\"question\"," )) != std::string::npos ) {
pos += 14;
std::string question = utils::text::trim(
utils::text::special_expressions_decode(
utils::text::slashu_to_utf8(
resp.data.substr(pos, resp.data.find("\"]", pos) - pos) )) );
TCHAR *msg = mir_a2t_cp(question.c_str(),CP_UTF8);
parent->SetTopic(msg);
mir_free(msg);
}
if ( resp.data.find( "[\"typing\"]" ) != std::string::npos
|| resp.data.find( "[\"spyTyping\"," ) != std::string::npos )
{
// Stranger is typing, not supported by chat module yet
SkinPlaySound( "StrangerTyp" );
CallService(MS_MSG_SETSTATUSTEXT, (WPARAM)parent->GetChatHandle(), (LPARAM)TranslateT("Stranger is typing."));
}
if ( resp.data.find( "[\"stoppedTyping\"]" ) != std::string::npos
|| resp.data.find( "[\"spyStoppedTyping\"," ) != std::string::npos )
{
// Stranger stopped typing, not supported by chat module yet
SkinPlaySound( "StrangerTypStop" );
CallService(MS_MSG_SETSTATUSTEXT, (WPARAM)parent->GetChatHandle(), (LPARAM)TranslateT("Stranger stopped typing."));
}
pos = 0;
while ( (pos = resp.data.find( "[\"gotMessage\",", pos )) != std::string::npos ) {
pos += 16;
std::string message = utils::text::trim(
utils::text::special_expressions_decode(
utils::text::slashu_to_utf8(
resp.data.substr(pos, resp.data.find("\"]", pos) - pos) )) );
if (state_ == STATE_ACTIVE) {
TCHAR *msg = mir_a2t_cp(message.c_str(),CP_UTF8);
parent->UpdateChat(TranslateT("Stranger"), msg);
mir_free(msg);
CallService(MS_MSG_SETSTATUSTEXT, (WPARAM)parent->GetChatHandle(), 0);
}
}
pos = 0;
while ( (pos = resp.data.find( "[\"spyMessage\",", pos )) != std::string::npos ) {
pos += 16;
std::string message = resp.data.substr(pos, resp.data.find("\"]", pos) - pos);
if (state_ == STATE_SPY) {
std::string stranger = message.substr(0, message.find("\""));
message = message.substr(stranger.length() + 4);
message = utils::text::trim(
utils::text::special_expressions_decode(
utils::text::slashu_to_utf8( message )) );
stranger = Translate(stranger.c_str());
TCHAR *str = mir_a2t_cp(stranger.c_str(), CP_UTF8);
TCHAR *msg = mir_a2t_cp(message.c_str(), CP_UTF8);
parent->UpdateChat(str, msg);
mir_free(msg);
mir_free(str);
}
}
if ( resp.data.find( "[\"strangerDisconnected\"]" ) != std::string::npos ) {
// Stranger disconnected
if (db_get_b(NULL, parent->m_szModuleName, OMEGLE_KEY_DONT_STOP, 0))
{
SkinPlaySound( "StrangerChange" );
parent->NewChat();
}
else
parent->StopChat(false);
}
if ( (pos = resp.data.find( "[\"spyDisconnected\"," )) != std::string::npos ) {
pos += 21;
std::string stranger = utils::text::trim(
utils::text::special_expressions_decode(
utils::text::slashu_to_utf8(
resp.data.substr(pos, resp.data.find("\"]", pos) - pos) )) );
char str[255];
mir_snprintf(str, sizeof(str), Translate("%s disconnected."), Translate(stranger.c_str()));
TCHAR *msg = mir_a2t(str);
parent->UpdateChat(NULL, msg);
mir_free(msg);
// Stranger disconnected
if (db_get_b(NULL, parent->m_szModuleName, OMEGLE_KEY_DONT_STOP, 0))
{
SkinPlaySound( "StrangerChange" );
parent->NewChat();
}
else
parent->StopChat(false);
}
if ( resp.data.find( "[\"recaptchaRequired\"" ) != std::string::npos ) {
// Nothing to do with recaptcha
parent->UpdateChat(NULL, TranslateT("Recaptcha is required.\nOpen http://omegle.com , solve Recaptcha and try again."));
parent->StopChat(false);
}
if ( resp.data.find( "[\"recaptchaRejected\"]" ) != std::string::npos ) {
// Nothing to do with recaptcha
parent->StopChat(false);
}
if ( (pos = resp.data.find( "[\"error\"," )) != std::string::npos ) {
pos += 11;
std::string error = utils::text::trim(
utils::text::special_expressions_decode(
utils::text::slashu_to_utf8(
resp.data.substr(pos, resp.data.find("\"]", pos) - pos) )) );
error = Translate("Error: ") + error;
TCHAR *msg = mir_a2t(error.c_str());
parent->UpdateChat(NULL, msg);
mir_free(msg);
}
if (newStranger && state_ != STATE_SPY) {
// We got new stranger in this event, lets say him "Hi message" if enabled
if ( db_get_b( NULL, parent->m_szModuleName, OMEGLE_KEY_HI_ENABLED, 0 )) {
DBVARIANT dbv;
if ( !db_get_utf( NULL, parent->m_szModuleName, OMEGLE_KEY_HI, &dbv )) {
std::string *message = new std::string(dbv.pszVal);
db_free(&dbv);
parent->debugLogA("**Chat - saying Hi! message");
parent->ForkThread(&OmegleProto::SendMsgWorker, message);
}
else parent->debugLogA("**Chat - Hi message is enabled but not used");
}
}
if (waiting) {
// If we are only waiting in this event...
parent->UpdateChat(NULL, TranslateT("We are still waiting..."));
}
return handle_success( "events" );
}
case HTTP_CODE_FAKE_DISCONNECTED:
// timeout
return handle_success( "events" );
case HTTP_CODE_FAKE_ERROR:
default:
return handle_error( "events" );
}
}
static INT_PTR DbEventGetText(WPARAM wParam, LPARAM lParam)
{
DBEVENTGETTEXT* egt = (DBEVENTGETTEXT*)lParam;
if (egt == NULL)
return 0;
DBEVENTINFO *dbei = egt->dbei;
DBEVENTTYPEDESCR *et = (DBEVENTTYPEDESCR*)DbEventTypeGet((WPARAM)dbei->szModule, (LPARAM)dbei->eventType);
if (et && ServiceExists(et->textService))
return CallService(et->textService, wParam, lParam);
if (!dbei->pBlob)
return 0;
if (dbei->eventType == EVENTTYPE_AUTHREQUEST || dbei->eventType == EVENTTYPE_ADDED) {
// EVENTTYPE_AUTHREQUEST: uin(DWORD), hContact(DWORD), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ)
// EVENTTYPE_ADDED: uin(DWORD), hContact(HANDLE), nick(ASCIIZ), first(ASCIIZ), last(ASCIIZ), email(ASCIIZ)
DWORD uin = *(DWORD*)dbei->pBlob;
HANDLE hContact = (HANDLE)*(DWORD*)(dbei->pBlob + sizeof(DWORD));
char *buf = LPSTR(dbei->pBlob) + sizeof(DWORD)*2;
ptrT tszNick(getEventString(dbei, buf));
ptrT tszFirst(getEventString(dbei, buf));
ptrT tszLast(getEventString(dbei, buf));
ptrT tszEmail(getEventString(dbei, buf));
CMString nick, text;
if (tszFirst || tszLast) {
nick.AppendFormat(_T("%s %s"), tszFirst, tszLast);
nick.Trim();
}
if (tszEmail) {
if (!nick.IsEmpty())
nick.Append(_T(", "));
nick.Append(tszEmail);
}
if (uin != 0) {
if (!nick.IsEmpty())
nick.Append(_T(", "));
nick.AppendFormat(_T("%d"), uin);
}
if (!nick.IsEmpty())
nick = _T("(") + nick + _T(")");
if (dbei->eventType == EVENTTYPE_AUTHREQUEST) {
ptrT tszReason(getEventString(dbei, buf));
text.Format(TranslateT("Authorization request from %s%s: %s"),
(*tszNick == 0) ? cli.pfnGetContactDisplayName(hContact, 0) : tszNick, nick, tszReason);
}
else text.Format(TranslateT("You were added by %s%s"),
(*tszNick == 0) ? cli.pfnGetContactDisplayName(hContact, 0) : tszNick, nick);
return (egt->datatype == DBVT_WCHAR) ? (INT_PTR)mir_tstrdup(text) : (INT_PTR)mir_t2a(text);
}
if (dbei->eventType == EVENTTYPE_CONTACTS) {
CMString text(TranslateT("Contacts: "));
// blob is: [uin(ASCIIZ), nick(ASCIIZ)]*
char *buf = LPSTR(dbei->pBlob), *limit = LPSTR(dbei->pBlob) + dbei->cbBlob;
while (buf < limit) {
ptrT tszUin(getEventString(dbei, buf));
ptrT tszNick(getEventString(dbei, buf));
if (tszNick && *tszNick)
text.AppendFormat(_T("\"%s\" "), tszNick);
if (tszUin && *tszUin)
text.AppendFormat(_T("<%s>; "), tszUin);
}
return (egt->datatype == DBVT_WCHAR) ? (INT_PTR)mir_tstrdup(text) : (INT_PTR)mir_t2a(text);
}
if (dbei->eventType == EVENTTYPE_FILE) {
char *buf = LPSTR(dbei->pBlob) + sizeof(DWORD);
ptrT tszFileName(getEventString(dbei, buf));
ptrT tszDescription(getEventString(dbei, buf));
ptrT &ptszText = (lstrlen(tszDescription) == 0) ? tszFileName : tszDescription;
switch (egt->datatype) {
case DBVT_WCHAR:
return (INT_PTR)ptszText.detouch();
case DBVT_ASCIIZ:
return (INT_PTR)mir_t2a(ptszText);
}
return 0;
}
// by default treat an event's blob as a string
if (egt->datatype == DBVT_WCHAR) {
char *str = (char*)alloca(dbei->cbBlob + 1);
memcpy(str, dbei->pBlob, dbei->cbBlob);
str[dbei->cbBlob] = 0;
if (dbei->flags & DBEF_UTF) {
WCHAR *msg = NULL;
Utf8DecodeCP(str, egt->codepage, &msg);
if (msg)
return (INT_PTR)msg;
}
return (INT_PTR)mir_a2t_cp(str, egt->codepage);
}
if (egt->datatype == DBVT_ASCIIZ) {
char *msg = mir_strdup((char*)dbei->pBlob);
if (dbei->flags & DBEF_UTF)
Utf8DecodeCP(msg, egt->codepage, NULL);
return (INT_PTR)msg;
}
return 0;
}
//------------------------------------------------------------------------------
std::wstring EventInformation::getMessage()
{
const std::wstring intro = TranslateW(L"%u says");
return intro + L" " + mir_a2t_cp((char*)m_event_info.pBlob, CP_UTF8);
}
int WhatsAppProto::OnPrebuildContactMenu(WPARAM wParam,LPARAM lParam)
{
HANDLE hContact = reinterpret_cast<HANDLE>(wParam);
if (hContact)
debugLogA(this->GetContactDisplayName(hContact).c_str());
else
debugLogA("No contact found");
if (g_hContactMenuItems[CMI_ADD_CONTACT_TO_GROUP] != NULL)
CallService("CList/RemoveContactMenuItem", (WPARAM) g_hContactMenuItems[CMI_ADD_CONTACT_TO_GROUP], (LPARAM) 0);
if (g_hContactMenuItems[CMI_REMOVE_CONTACT_FROM_GROUP] != NULL)
CallService("CList/RemoveContactMenuItem", (WPARAM) g_hContactMenuItems[CMI_REMOVE_CONTACT_FROM_GROUP], (LPARAM) 0);
int chatType = getByte(hContact, "SimpleChatRoom", 0);
CLISTMENUITEM mi = {sizeof(mi)};
if (chatType == 0)
{
mi.flags = CMIF_CHILDPOPUP;
mi.position= -2000006102;
mi.icolibItem = GetIconHandle("addContactToGroup");
mi.pszName = GetIconDescription("addContactToGroup");
mi.pszService = NULL;
g_hContactMenuItems[CMI_ADD_CONTACT_TO_GROUP] = Menu_AddContactMenuItem(&mi);
if (!isOnline())
{
Menu_ShowItem(g_hContactMenuItems[CMI_ADD_CONTACT_TO_GROUP], false);
return 0;
}
mi.hParentMenu = (HGENMENU) g_hContactMenuItems[CMI_ADD_CONTACT_TO_GROUP];
mi.flags = CMIF_ROOTHANDLE | CMIF_TCHAR;
int iGrpCount = 0;
string fullSvcName;
string svcName = m_szModuleName;
svcName += "/AddContactToGroup_";
DBVARIANT dbv;
for (map<HANDLE, map<HANDLE, bool>>::iterator it = this->isMemberByGroupContact.begin();
it != this->isMemberByGroupContact.end(); ++it)
{
map<HANDLE, bool>::iterator memberIt = it->second.find(hContact);
// Only, if current contact is not already member of this group
if ((memberIt == it->second.end() || memberIt->second == false) && !getString(it->first, "ID", &dbv))
{
fullSvcName = svcName + dbv.pszVal;
mi.pszService = (char*) fullSvcName.c_str();
mi.ptszName = mir_a2t_cp(this->GetContactDisplayName(it->first).c_str(), CP_UTF8);
CreateServiceFunctionParam(mi.pszService, GlobalServiceParam<&WhatsAppProto::OnAddContactToGroup>, (LPARAM) it->first);
Menu_AddContactMenuItem(&mi);
db_free(&dbv);
mir_free(mi.ptszName);
iGrpCount++;
}
}
if (!iGrpCount)
Menu_ShowItem(g_hContactMenuItems[CMI_ADD_CONTACT_TO_GROUP], false);
}
else if (chatType == 1)
{
mi.flags = CMIM_FLAGS;
if (!isOnline() || getByte(hContact, "IsGroupMember", 0) == 0)
mi.flags |= CMIF_GRAYED;
CallService(MS_CLIST_MODIFYMENUITEM, (WPARAM) g_hContactMenuItems[CMI_LEAVE_GROUP], (LPARAM) &mi);
}
else if (chatType == 2)
{
// owning chat/group
mi.flags = CMIF_CHILDPOPUP;
mi.position= -2000006102;
mi.icolibItem = GetIconHandle("removeContactFromGroup");
mi.pszName = GetIconDescription("removeContactFromGroup");
mi.pszService = NULL;
g_hContactMenuItems[CMI_REMOVE_CONTACT_FROM_GROUP] = Menu_AddContactMenuItem(&mi);
bool bShow = false;
if (isOnline() && getByte(hContact, "IsGroupMember", 0) == 1)
{
map<HANDLE, map<HANDLE, bool>>::iterator groupsIt = this->isMemberByGroupContact.find(hContact);
if (groupsIt == this->isMemberByGroupContact.end())
{
debugLogA("Group exists only on contact list");
}
else
{
mi.hParentMenu = (HGENMENU) g_hContactMenuItems[CMI_REMOVE_CONTACT_FROM_GROUP];
mi.flags = CMIF_ROOTHANDLE | CMIF_TCHAR;
string fullSvcName;
string svcName = m_szModuleName;
svcName += "/RemoveContactFromGroup_";
DBVARIANT dbv;
for (map<HANDLE, bool>::iterator it = groupsIt->second.begin(); it != groupsIt->second.end(); ++it)
{
if (!getString(it->first, "ID", &dbv))
{
fullSvcName = svcName + dbv.pszVal;
mi.pszService = (char*) fullSvcName.c_str();
mi.ptszName = mir_a2t_cp(this->GetContactDisplayName(it->first).c_str(), CP_UTF8);
CreateServiceFunctionParam(mi.pszService,
GlobalServiceParam<&WhatsAppProto::OnRemoveContactFromGroup>, (LPARAM) it->first);
Menu_AddContactMenuItem(&mi);
db_free(&dbv);
mir_free(mi.ptszName);
bShow = true;
}
}
}
}
else Menu_ShowItem(g_hContactMenuItems[CMI_REMOVE_CONTACT_FROM_GROUP], false);
Menu_ShowItem(g_hContactMenuItems[CMI_REMOVE_GROUP], bShow);
Menu_ShowItem(g_hContactMenuItems[CMI_CHANGE_GROUP_SUBJECT], bShow);
}
return 0;
}
UINT CDropbox::RequestAccessTokenAsync(void *owner, void *param)
{
HWND hwndDlg = (HWND)param;
CDropbox *instance = (CDropbox*)owner;
EnableWindow(GetDlgItem(hwndDlg, IDC_AUTHORIZE), FALSE);
SetDlgItemText(hwndDlg, IDC_AUTH_STATUS, TranslateT("in process..."));
if (instance->HasAccessToken())
instance->DestroyAccessToken();
char requestToken[128];
GetDlgItemTextA(hwndDlg, IDC_REQUEST_CODE, requestToken, _countof(requestToken));
GetAccessTokenRequest request(requestToken);
NLHR_PTR response(request.Send(instance->hNetlibConnection));
if (response == NULL || response->resultCode != HTTP_STATUS_OK) {
Netlib_Logf(instance->hNetlibConnection, "%s: %s", MODULE, HttpStatusToText(HTTP_STATUS_ERROR));
if (hwndDlg)
SetDlgItemText(hwndDlg, IDC_AUTH_STATUS, TranslateT("server does not respond"));
/*else
ShowNotification(TranslateT("server does not respond"), MB_ICONERROR);*/
return 0;
}
JSONNode root = JSONNode::parse(response->pData);
if (root.empty()) {
Netlib_Logf(instance->hNetlibConnection, "%s: %s", MODULE, HttpStatusToText((HTTP_STATUS)response->resultCode));
if (hwndDlg)
SetDlgItemText(hwndDlg, IDC_AUTH_STATUS, TranslateT("server does not respond"));
/*else
ShowNotification((TCHAR*)error_description, MB_ICONERROR);*/
return 0;
}
JSONNode node = root.at("error_description");
if (node != JSONNULL) {
ptrT error_description(mir_a2t_cp(node.as_string().c_str(), CP_UTF8));
Netlib_Logf(instance->hNetlibConnection, "%s: %s", MODULE, HttpStatusToText((HTTP_STATUS)response->resultCode));
if (hwndDlg)
SetDlgItemText(hwndDlg, IDC_AUTH_STATUS, error_description);
/*else
ShowNotification((TCHAR*)error_description, MB_ICONERROR);*/
return 0;
}
node = root.at("access_token");
db_set_s(NULL, MODULE, "TokenSecret", node.as_string().c_str());
ProtoBroadcastAck(MODULE, NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)ID_STATUS_OFFLINE, (WPARAM)ID_STATUS_ONLINE);
MCONTACT hContact = instance->GetDefaultContact();
if (hContact) {
if (db_get_w(hContact, MODULE, "Status", ID_STATUS_OFFLINE) != ID_STATUS_ONLINE)
db_set_w(hContact, MODULE, "Status", ID_STATUS_ONLINE);
}
try {
RequestAccountInfo(instance);
}
catch (DropboxException &ex) {
Netlib_Logf(instance->hNetlibConnection, "%s: %s", MODULE, ex.what());
return 0;
}
if (hwndDlg)
SetDlgItemText(hwndDlg, IDC_AUTH_STATUS, TranslateT("you have been authorized"));
/*else
ShowNotification(TranslateT("you have been authorized"), MB_ICONINFORMATION);*/
SetDlgItemTextA(hwndDlg, IDC_REQUEST_CODE, "");
return 0;
}
INT_PTR CALLBACK DlgProcAbout(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static int iState = 0;
switch (msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
{ TCHAR filename[MAX_PATH], *productCopyright;
DWORD unused;
DWORD verInfoSize;
UINT blockSize;
PVOID pVerInfo;
GetModuleFileName(NULL,filename,SIZEOF(filename));
verInfoSize=GetFileVersionInfoSize(filename,&unused);
pVerInfo=mir_alloc(verInfoSize);
GetFileVersionInfo(filename,0,verInfoSize,pVerInfo);
VerQueryValue(pVerInfo,_T("\\StringFileInfo\\000004b0\\LegalCopyright"),(LPVOID*)&productCopyright,&blockSize);
SetDlgItemText(hwndDlg,IDC_DEVS,productCopyright);
mir_free(pVerInfo);
}
{ char productVersion[56], *p;
int isAnsi = 0;
TCHAR str[64];
CallService(MS_SYSTEM_GETVERSIONTEXT,SIZEOF(productVersion),(LPARAM)productVersion);
// Hide Unicode from version text as it is assumed at this point
p = strstr(productVersion, " Unicode");
if (p)
*p = '\0';
else
isAnsi = 1;
mir_sntprintf(str,SIZEOF(str),_T(STR_VERSION_FORMAT), TranslateT("v"), productVersion, isAnsi?" ANSI":"");
{
TCHAR oldTitle[256], newTitle[256];
GetDlgItemText( hwndDlg, IDC_HEADERBAR, oldTitle, SIZEOF( oldTitle ));
mir_sntprintf( newTitle, SIZEOF(newTitle), oldTitle, str );
SetDlgItemText( hwndDlg, IDC_HEADERBAR, newTitle );
}
mir_sntprintf(str,SIZEOF(str),TranslateT("Built %s %s"),_T(__DATE__),_T(__TIME__));
SetDlgItemText(hwndDlg,IDC_BUILDTIME,str);
}
ShowWindow(GetDlgItem(hwndDlg, IDC_CREDITSFILE), SW_HIDE);
{
HRSRC hResInfo = FindResource(hMirandaInst,MAKEINTRESOURCE(IDR_CREDITS),_T("TEXT"));
DWORD ResSize = SizeofResource(hMirandaInst,hResInfo);
HGLOBAL hRes = LoadResource(hMirandaInst,hResInfo);
char* pszMsg = (char*)LockResource(hRes);
if (pszMsg)
{
char* pszMsgt = (char*)alloca(ResSize + 1);
memcpy(pszMsgt, pszMsg, ResSize); pszMsgt[ResSize] = 0;
TCHAR *ptszMsg;
if (ResSize >=3 && pszMsgt[0] == '\xef' && pszMsgt[1] == '\xbb' && pszMsgt[2] == '\xbf')
ptszMsg = Utf8DecodeT(pszMsgt + 3);
else
ptszMsg = mir_a2t_cp(pszMsgt, 1252);
SetDlgItemText(hwndDlg, IDC_CREDITSFILE, ptszMsg);
UnlockResource(pszMsg);
mir_free(ptszMsg);
}
FreeResource(hRes);
}
Window_SetIcon_IcoLib(hwndDlg, SKINICON_OTHER_MIRANDA);
return TRUE;
case WM_COMMAND:
switch( LOWORD( wParam )) {
case IDOK:
case IDCANCEL:
DestroyWindow(hwndDlg);
return TRUE;
case IDC_CONTRIBLINK:
if (iState) {
iState = 0;
SetDlgItemText(hwndDlg, IDC_CONTRIBLINK, TranslateT("Credits >"));
ShowWindow(GetDlgItem(hwndDlg, IDC_DEVS), SW_SHOW);
ShowWindow(GetDlgItem(hwndDlg, IDC_BUILDTIME), SW_SHOW);
ShowWindow(GetDlgItem(hwndDlg, IDC_CREDITSFILE), SW_HIDE);
}
else {
iState = 1;
SetDlgItemText(hwndDlg, IDC_CONTRIBLINK, TranslateT("< Copyright"));
ShowWindow(GetDlgItem(hwndDlg, IDC_DEVS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_BUILDTIME), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CREDITSFILE), SW_SHOW);
}
break;
}
break;
case WM_CTLCOLOREDIT:
case WM_CTLCOLORSTATIC:
switch ( GetWindowLongPtr(( HWND )lParam, GWL_ID )) {
case IDC_WHITERECT:
case IDC_BUILDTIME:
case IDC_CREDITSFILE:
case IDC_DEVS:
SetTextColor((HDC)wParam,GetSysColor(COLOR_WINDOWTEXT));
break;
default:
return FALSE;
}
SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
return (INT_PTR)GetSysColorBrush(COLOR_WINDOW);
case WM_DESTROY:
Window_FreeIcon_IcoLib( hwndDlg );
{
HFONT hFont=(HFONT)SendDlgItemMessage(hwndDlg,IDC_VERSION,WM_GETFONT,0,0);
SendDlgItemMessage(hwndDlg,IDC_VERSION,WM_SETFONT,SendDlgItemMessage(hwndDlg,IDOK,WM_GETFONT,0,0),0);
DeleteObject(hFont);
}
break;
}
return FALSE;
}
