bool XferObject::RegisterInterfaces()
{
    const InterfaceDescription* serviceIntf = ajConnection->busAttachment->GetInterface(XFER_SERVICE_INTERFACE_NAME);
    assert(serviceIntf);
    AddInterface(*serviceIntf);
    /** Register the method handlers with the object */
    MethodEntry methodEntries[6];
    methodEntries[0].member = serviceIntf->GetMember("query");
    methodEntries[0].handler = (MessageReceiver::MethodHandler)(&XferObject::Query);
    methodEntries[1].member = serviceIntf->GetMember("initiate");
    methodEntries[1].handler = (MessageReceiver::MethodHandler)(&XferObject::InitiateXferIn);
    methodEntries[2].member = serviceIntf->GetMember("receive");
    methodEntries[2].handler = (MessageReceiver::MethodHandler)(&XferObject::ReceiveSegment);
    methodEntries[3].member = serviceIntf->GetMember("status");
    methodEntries[3].handler = (MessageReceiver::MethodHandler)(&XferObject::TransferStatus);
    methodEntries[4].member = serviceIntf->GetMember("close");
    methodEntries[4].handler = (MessageReceiver::MethodHandler)(&XferObject::EndXfer);
    methodEntries[5].member = serviceIntf->GetMember("error");
    methodEntries[5].handler = (MessageReceiver::MethodHandler)(&XferObject::ErrorCode);
    status = AddMethodHandlers(methodEntries, sizeof(methodEntries) / sizeof(methodEntries[0]));
    if (ER_OK != status) {
        NotifyUser(MSG_ERROR, "Failed to register method handlers for XferObject");
        return false;
    }
    NotifyUser(MSG_SYSTEM, "register method handlers for XferObject");
    return true;
}

bool AllJoynBusListener::AcceptSessionJoiner(SessionPort sessionPort, const char* joiner, const SessionOpts& opts)
{
    if (sessionPort != PHOTOCHAT_PORT) {
        NotifyUser(MSG_ERROR, "Rejecting join attempt on non-chat session port %d\n", sessionPort);
        return false;
    }
    NotifyUser(MSG_STATUS, "Accepting join session request from %s (opts.proximity=%x, opts.traffic=%x, opts.transports=%x)\n",
               joiner, opts.proximity, opts.traffic, opts.transports);
    return true;
}

void __cdecl Check_ThreadFunc(void *lpParam)
{
	InternetSetCookieA("https://mail.google.com/mail/", "GX", "");
	if (lpParam) {
		CheckMailInbox((Account *)lpParam);
		NotifyUser((Account *)lpParam);
	}
	else {
		for (int i = 0; i < acc_num && GetContactProto(acc[i].hContact); i++) {
			CheckMailInbox(&acc[i]);
			NotifyUser(&acc[i]);
		}
	}
}

//----------------------------------------------------------------------------------------
// AllJoynBusListener (BusListener, SessionPortListener, SessionListener )
//----------------------------------------------------------------------------------------
void AllJoynBusListener::FoundAdvertisedName(const char* name, TransportMask transport, const char* namePrefix)
{
    if (!connection->joinName.empty() && 0 == connection->sessionId) {
        const char* convName = name + strlen(NAME_PREFIX);
        SessionOpts opts(SessionOpts::TRAFFIC_MESSAGES, true, SessionOpts::PROXIMITY_ANY, TRANSPORT_ANY);
        QStatus status = connection->busAttachment->JoinSession(name, PHOTOCHAT_PORT, this, connection->sessionId, opts);
        if (ER_OK == status) {
            NotifyUser(MSG_STATUS, "Joined conversation \"%s\"\n", convName);
        } else {
            NotifyUser(MSG_ERROR, "JoinSession failed (status=%s)\n", QCC_StatusText(status));
        }
    }
    connection->joinComplete = true;
}

bool AllJoynConnection::invariants()
{
    if (NULL == ManagedOutput) {
        MessageBox(NULL, L"Managed Output not set", L"Alljoyn", MB_OK);
        return false;
    }
    if (NULL == JoinNotifier) {
        NotifyUser(MSG_ERROR, "Join Notifier not set");
        return false;
    }
    if (advertisedName.empty() && joinName.empty()) {
        NotifyUser(MSG_ERROR, "Neither advertised or joinName set");
        return false;
    }
    return true;
}

bool ChatConnection::invariants()
{
    if (NULL == JoinNotifier) {
        NotifyUser(MSG_ERROR, "Join Notifier not set");
        return false;
    }
    if (NULL == ManagedOutput) {
        NotifyUser(MSG_ERROR, "Managed Output  not set");
        return false;
    }
    if (advertisedName.empty() && joinName.empty()) {
        NotifyUser(MSG_ERROR, "Neither advertised or joinName set");
        return false;
    }
    return true;
}

void duGifCtrl::OnMouseLUp(POINT pt)
{
	if (GetState() == DU_STATE_PRESS)
	{
		Plugin_SetState(this, DU_STATE_NORMAL);
		NotifyUser(DUM_GIFCLICK, NULL, NULL);
	}
}

void WINAPI duListBox::OnMouseDbClick(POINT pt)
{
	if (m_pHotItem)
	{
		int nHotItemIndex = GetItemIndex(m_pHotItem);
		NotifyUser(DUM_LBLBUTTONDBCLICK, (WPARAM)nHotItemIndex, NULL);
	}
}

void XferObject::EndXfer(const InterfaceDescription::Member* member, Message& msg)
{
    closeFile();
    if (state != -1)
        state = 0;
    saveAsFilename = "";
    NotifyUser(MSG_SYSTEM, "Closed %s", saveAsFilename.c_str());
}

void XferObject::ErrorCode(const InterfaceDescription::Member* member, Message& msg)
{
    MsgArg outArg("i", errorCode);
    QStatus status = MethodReply(msg, &outArg, 1);
    if (ER_OK != status) {
        NotifyUser(MSG_ERROR, "XferObject::ErrorCode : Error sending reply");
    }
}

/** Send a Chat signal */
QStatus ChatObject::SendChatSignal(const char* msg)
{
    MsgArg chatArg("s", msg);
    uint8_t flags = 0;
    if (0 == ajConnection->sessionId) {
        NotifyUser(MSG_ERROR, "Sending Chat signal without a session id\n");
        return ER_ALLJOYN_JOINSESSION_REPLY_NO_SESSION;
    }
    return Signal(NULL, ajConnection->sessionId, *chatSignalMember, &chatArg, 1, 0, flags);
}

bool XferObject::openFile(const char* filename)
{
    hFile = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile == INVALID_HANDLE_VALUE) {
        DWORD err = GetLastError();
        NotifyUser(MSG_SYSTEM, "XferObjectQuery : Error opening file %s %d %x", filename, err, err);
        return false;
    }
    return true;
}

void
Wrapup( )
{
	struct rusage local_rusage;
	char notification[ BUFSIZ ];

	dprintf(D_FULLDEBUG, "Entering Wrapup()\n" );

	notification[0] = '\0';

	/* This HadErr business isn't well defined. There doesn't seem
		to be a clean way of representing the event of a
		pre-job startup initialization failure.  So, instead of trying
		to propogate the nonexistant JobStatus around to future
		code paths trying to clean up a mess specified by HadErr,
		we are simply going to EXCEPT(). HadErr only gets specified
		when either the std file can't be opened or the shadow
		cannot chdir() to the initialdir(often because of a
		permission/existance problem). */
	if( HadErr ) {
		/* dump the specific error if it has been determined */
		if (ErrBuf[0] != '\0') {
			EXCEPT("%s", ErrBuf);
		} else {
			EXCEPT("Couldn't set up std files or chdir to initialdir--"
				"probably a permissions error.");
		}
	} else {
		/* all event logging has been moved from handle_termination() to
		   log_termination()	--RR */
		handle_termination( Proc, notification, &JobStatus, NULL );
	}

	/* fill in the Proc structure's exit_status with JobStatus, so that when
	 * we call update_job_status the exit status is written into the job queue,
	 * so that the history file will have exit status information for the job.
	 * note that JobStatus is in BSD format, and Proc->exit_status is in POSIX
	 * int format, so we copy very carefully.  on most platforms the 2 formats
	 * are interchangeable, so most of the time we'll get intelligent results.
	 *    -Todd, 11/95
	*/
	memcpy(&(Proc->exit_status[0]),&JobStatus,sizeof((Proc->exit_status[0])));
	get_local_rusage( &local_rusage );
	update_job_status( &local_rusage, &JobRusage );


	/* log the event associated with the termination; pass local and remote
	   rusage for the run.  The total local and remote rusages for the job are
	   stored in the Proc --- these values were updated by update_job_status */
	log_termination (&local_rusage, &JobRusage);

	if( notification[0] ) {
		NotifyUser( notification, Proc );
	}
}

void WINAPI duListBox::OnMouseLDown(POINT pt)
{
	if (m_pHotItem != m_pSelItem)
	{
		ListBoxItem *pTemp = m_pSelItem;
		m_pSelItem = m_pHotItem;
		Plugin_Redraw(this, TRUE);

		int nOldSelItemIndex = GetItemIndex(pTemp);
		int nNewSelItemIndex = GetItemIndex(m_pHotItem);
		NotifyUser(DUM_LBSELCHANGED, (WPARAM)nOldSelItemIndex, (LPARAM)nNewSelItemIndex);
	}
}

void duSpin::SetValue(int nVal)
{
	m_nVal = nVal;
	TCHAR m_szValue[256];
	_stprintf(m_szValue, _T("%d"), m_nVal);
	SetText(m_szValue);

	m_nSelectionStart = 0;
	m_nSelectionEnd = GetEditTextLength();

	OnEmReplaceSel(FALSE, m_szValue, FALSE, FALSE);
	m_nSelectionStart = m_nSelectionEnd = 0;
	
	NotifyUser(DUM_SPINCHANGE, m_nVal, NULL);
}

void XferObject::InitiateXferIn(const InterfaceDescription::Member* member, Message& msg)
{
    int segmentSize = msg->GetArg(0)->v_uint32;
    int nSegs = msg->GetArg(1)->v_uint32;
    int accept = 0;
    xferCallback("Initiate", accept);
    const char* filename = GetSaveAsFilename();
    commonSegSize = segmentSize;
    if (openFile(filename))
        accept = 1;
    MsgArg outArg("i", accept);
    QStatus status = MethodReply(msg, &outArg, 1);
    if (ER_OK != status) {
        NotifyUser(MSG_ERROR, "XferObjectQuery : Error sending reply");
    }
}