delete presenceOracle_;

presenceOracle_ = NULL;

delete nickResolver_;

nickResolver_ = NULL;

delete avatarManager_;

avatarManager_ = NULL;

delete rosterController_;

rosterController_ = NULL;

delete xmppRosterController_;

xmppRosterController_ = NULL;

delete clientVersionResponder_;

clientVersionResponder_ = NULL;

delete discoResponder_;

discoResponder_ = NULL;

delete client_;

client_ = NULL;

}

void MainController::handleConnected() {

//FIXME: this freshLogin thing is temporary so I can see what's what before I split into a seperate method.

bool freshLogin = rosterController_ == NULL;

if (freshLogin) {

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());

xmppRoster_ = boost::shared_ptr<XMPPRoster>(new XMPPRoster());

presenceOracle_ = new PresenceOracle(client_);

lastSentPresence_ = boost::shared_ptr<Presence>();

client_->onPresenceReceived.connect(boost::bind(&MainController::handleIncomingPresence, this, _1));

nickResolver_ = new NickResolver(xmppRoster_);

avatarManager_ = new AvatarManager(client_, client_, avatarStorage_, this);

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, treeWidgetFactory_, nickResolver_);

rosterController_->onStartChatRequest.connect(boost::bind(&MainController::handleChatRequest, this, _1));

rosterController_->onJoinMUCRequest.connect(boost::bind(&MainController::handleJoinMUCRequest, this, _1, _2));

rosterController_->onChangeStatusRequest.connect(boost::bind(&MainController::handleChangeStatusRequest, this, _1, _2));

rosterController_->onSignOutRequest.connect(boost::bind(&MainController::signOut, this));

xmppRosterController_ = new XMPPRosterController(client_, xmppRoster_);

xmppRosterController_->requestRoster();

clientVersionResponder_ = new SoftwareVersionResponder(CLIENT_NAME, CLIENT_VERSION, client_);

loginWindow_->morphInto(rosterController_->getWindow());

DiscoInfo discoInfo;

discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

capsInfo_ = boost::shared_ptr<CapsInfo>(new CapsInfo(CapsInfoGenerator(CLIENT_NODE).generateCapsInfo(discoInfo)));

discoResponder_ = new DiscoInfoResponder(client_);

discoResponder_->setDiscoInfo(discoInfo);

discoResponder_->setDiscoInfo(capsInfo_->getNode() + "#" + capsInfo_->getVersion(), discoInfo);

serverDiscoInfo_ = boost::shared_ptr<DiscoInfo>(new DiscoInfo());

}

boost::shared_ptr<GetDiscoInfoRequest> discoInfoRequest(new GetDiscoInfoRequest(JID(), client_));

discoInfoRequest->onResponse.connect(boost::bind(&MainController::handleServerDiscoInfoResponse, this, _1, _2));

discoInfoRequest->send();

boost::shared_ptr<GetVCardRequest> vCardRequest(new GetVCardRequest(JID(), client_));

vCardRequest->onResponse.connect(boost::bind(&MainController::handleOwnVCardReceived, this, _1, _2));

vCardRequest->send();

idleDetector_->onInputIdle.connect(boost::bind(&MainController::handleInputIdle, this));

idleDetector_->onInputNotIdle.connect(boost::bind(&MainController::handleInputNotIdle, this));

//Send presence last to catch all the incoming presences.

boost::shared_ptr<Presence> initialPresence;

if (queuedPresence_.get() != NULL) {

initialPresence = queuedPresence_;

} else {

initialPresence = boost::shared_ptr<Presence>(new Presence());

}

initialPresence->addPayload(capsInfo_);

setManagersEnabled(true);

sendPresence(initialPresence);

}

void MainController::handleEventQueueLengthChange(int count) {

application_->getApplicationMessageDisplay()->setMessage(count == 0 ? "" : boost::lexical_cast<std::string>(count).c_str());

}

void MainController::handleChangeStatusRequest(StatusShow::Type show, const String &statusText) {

boost::shared_ptr<Presence> presence(new Presence());

if (show == StatusShow::None) {

// FIXME: This is wrong. None doesn't mean unavailable

presence->setType(Presence::Unavailable);

}

else {

presence->setShow(show);

}

presence->setStatus(statusText);

if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {

performLoginFromCachedCredentials();

queuedPresence_ = presence;