* - Must be part a bundle.

* - The Carbon/Cocoa application loop must be running (e.g. through QApplication)

* such that notifications are coming through.

*/

class GrowlNotifier : public Notifier {

public:

GrowlNotifier(const std::string& name);

virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback);

// Called by the delegate. Don't call.

void handleNotificationClicked(void* data);

void handleNotificationTimedOut(void* data);

private:

class Private;

boost::shared_ptr<Private> p;

};

NSMutableArray* defaultNotifications = [[NSMutableArray alloc] init];

foreach(Type type, getDefaultTypes()) {

[defaultNotifications addObject: STD2NSSTRING(typeToString(type))];

}

p->delegate.get().registrationDictionary = [[[NSDictionary alloc]

initWithObjects: [NSArray arrayWithObjects: allNotifications, defaultNotifications, nil]

forKeys: [NSArray arrayWithObjects: GROWL_NOTIFICATIONS_ALL, GROWL_NOTIFICATIONS_DEFAULT, nil]] autorelease];

[GrowlApplicationBridge setGrowlDelegate: p->delegate.get()];

}

void GrowlNotifier::showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picturePath, boost::function<void()> callback) {

ByteArray picture;

readByteArrayFromFile(picture, picturePath.string());

[GrowlApplicationBridge

notifyWithTitle: STD2NSSTRING(subject)

description: STD2NSSTRING(description)

notificationName: STD2NSSTRING(typeToString(type))

iconData: [NSData dataWithBytes: vecptr(picture) length: picture.size()]

priority: 0

isSticky: NO

}

void GrowlNotifier::handleNotificationClicked(void* rawData) {

Context* context = *(Context**) [((NSData*) rawData) bytes];

if (!context->callback->empty()) {

(*context->callback)();

}

delete context;

}

void GrowlNotifier::handleNotificationTimedOut(void* rawData) {

delete *(Context**) [((NSData*) rawData) bytes];

}

}

const std::string& subject,

const std::string& description,

const boost::filesystem::path& picture,

boost::function<void()> callback) = 0;

virtual bool isAvailable() const {

return true;

}

protected:

std::string typeToString(Type type);

static std::vector<Type> getAllTypes();

static std::vector<Type> getDefaultTypes();

static const int DEFAULT_STATUS_NOTIFICATION_TIMEOUT_SECONDS;

static const int DEFAULT_MESSAGE_NOTIFICATION_TIMEOUT_SECONDS;

};

}

/**

* Get the result of applying the temporary override to the persistent

* enabledness.

*/

bool getCurrentlyEnabled() const {

return persistentEnabled && !temporarilyDisabled;

}

virtual void showMessage(Type type, const std::string& subject, const std::string& description, const boost::filesystem::path& picture, boost::function<void()> callback) {

notifier->showMessage(type, subject, description, picture, callback);

}

}

private:

Notifier* notifier;

bool persistentEnabled;

bool temporarilyDisabled;

};

}

dock_ = dock;

uiEventStream_ = new UIEventStream();

notifier_ = new TogglableNotifier(notifier);

eventController_ = new EventController();

eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));

systemTrayController_ = new SystemTrayController(eventController_, systemTray);

loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings, uiEventStream_);

xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

std::string selectedLoginJID = settings_->getStringSetting("lastLoginJID");

bool loginAutomatically = settings_->getBoolSetting("loginAutomatically", false);

std::string cachedPassword;

std::string cachedCertificate;

if (!eagleMode_) {

namespace Swift {

class MainWindow;

class LoginWindow {

public:

virtual ~LoginWindow() {};

virtual void selectUser(const std::string&) = 0;

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

virtual void setMessage(const std::string&) = 0;

virtual void setIsLoggingIn(bool loggingIn) = 0;

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) = 0;

virtual void removeAvailableAccount(const std::string& jid) = 0;

boost::signal<void (const std::string&, const std::string&, const std::string& /* certificateFile */, bool /* remember password*/, bool /* login automatically */)> onLoginRequest;

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

virtual bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref) = 0;

toggleSoundsAction_->setCheckable(true);

toggleSoundsAction_->setChecked(true);

connect(toggleSoundsAction_, SIGNAL(toggled(bool)), SLOT(handleToggleSounds(bool)));

generalMenu_->addAction(toggleSoundsAction_);

toggleNotificationsAction_ = new QAction(tr("Display Pop-up &Notifications"), this);

toggleNotificationsAction_->setCheckable(true);

toggleNotificationsAction_->setChecked(true);

connect(toggleNotificationsAction_, SIGNAL(toggled(bool)), SLOT(handleToggleNotifications(bool)));

#ifndef SWIFTEN_PLATFORM_MACOSX

swiftMenu_->addSeparator();

#endif

#ifdef SWIFTEN_PLATFORM_MACOSX

QAction* quitAction = new QAction("&Quit", this);

#else

QAction* quitAction = new QAction(tr("&Quit"), this);

xmlConsoleAction_->setEnabled(!eagleMode_);

if (eagleMode_) {

remember_->setChecked(false);

loginAutomatically_->setChecked(false);

}

this->show();

}

bool QtLoginWindow::eventFilter(QObject *obj, QEvent *event) {

if (obj == username_->view() && event->type() == QEvent::KeyPress) {

QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);

if (keyEvent->key() == Qt::Key_Delete || keyEvent->key() == Qt::Key_Backspace) {

QString jid(username_->view()->currentIndex().data().toString());

int result = QMessageBox::question(this, tr("Remove profile"), tr("Remove the profile '%1'?").arg(jid), QMessageBox::Yes | QMessageBox::No);

if (result == QMessageBox::Yes) {

onPurgeSavedLoginRequest(Q2PSTRING(jid));

}

QMenu* swiftMenu;

QMenu* generalMenu;

};

public:

QtLoginWindow(UIEventStream* uiEventStream, bool eagleMode);

void morphInto(MainWindow *mainWindow);

virtual void loggedOut();

virtual void setMessage(const std::string& message);

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate);

virtual void removeAvailableAccount(const std::string& jid);

virtual void setLoginAutomatically(bool loginAutomatically);

virtual void setIsLoggingIn(bool loggingIn);

void selectUser(const std::string& user);

bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref certificate);

void hide();

QtMenus getMenus() const;