Since we need to access the UI from uisupport in various places, we introduce GraphicalUi.
This avoids the need to go via Client::mainUi() and abstract classes.
Also, getting rid of AbstractActionProvider and renaming NetworkModelActionProvider to
ContextMenuActionProvider to prepare for ToolbarActionProvider.
set(SOURCES
abstractmessageprocessor.cpp
+ abstractui.cpp
backlogrequester.cpp
buffermodel.cpp
buffersettings.cpp
messagefilter.cpp
messagemodel.cpp
networkmodel.cpp
- quasselui.cpp
selectionmodelsynchronizer.cpp
treemodel.cpp)
set(MOC_HDRS
abstractmessageprocessor.h
+ abstractui.h
buffermodel.h
client.h
clientbacklogmanager.h
messagefilter.h
messagemodel.h
networkmodel.h
- quasselui.h
selectionmodelsynchronizer.h
treemodel.h)
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include "quasselui.h"
+#include "abstractui.h"
-AbstractUi * AbstractUi::_instance = 0;
bool AbstractUi::_visible = false;
-AbstractUi::AbstractUi() {
- Q_ASSERT(!_instance);
- _instance = this;
+AbstractUi::AbstractUi(QObject *parent) : QObject(parent) {
+
}
Q_OBJECT
public:
- AbstractUi();
+ AbstractUi(QObject *parent = 0);
virtual ~AbstractUi() {};
- virtual void init() {}; // called after the client is initialized
+ virtual void init() = 0; // called after the client is initialized
virtual MessageModel *createMessageModel(QObject *parent) = 0;
virtual AbstractMessageProcessor *createMessageProcessor(QObject *parent) = 0;
- virtual AbstractActionProvider *actionProvider() const = 0;
inline static bool isVisible() { return _visible; }
inline static void setVisible(bool visible) { _visible = visible; }
void disconnectFromCore();
private:
- static AbstractUi *_instance;
static bool _visible;
};
-class AbstractActionProvider : public QObject {
- Q_OBJECT
-
- public:
- AbstractActionProvider(QObject *parent = 0) : QObject(parent) {}
- virtual ~AbstractActionProvider() {}
-
- virtual void addActions(QMenu *, const QModelIndex &index, QObject *receiver = 0, const char *slot = 0, bool allowBufferHide = false) = 0;
- virtual void addActions(QMenu *, const QList<QModelIndex> &indexList, QObject *receiver = 0, const char *slot = 0, bool allowBufferHide = false) = 0;
- virtual void addActions(QMenu *, BufferId id, QObject *receiver = 0, const char *slot = 0) = 0;
- virtual void addActions(QMenu *, MessageFilter *filter, BufferId msgBuffer, QObject *receiver = 0, const char *slot = 0) = 0;
- virtual void addActions(QMenu *, MessageFilter *filter, BufferId msgBuffer, const QString &chanOrNick, QObject *receiver = 0, const char *slot = 0) = 0;
-
- signals:
- void showChannelList(NetworkId);
- void showIgnoreList(NetworkId);
-
-};
-
#endif
#include "client.h"
#include "abstractmessageprocessor.h"
+#include "abstractui.h"
#include "bufferinfo.h"
#include "buffermodel.h"
#include "buffersettings.h"
#include "network.h"
#include "networkmodel.h"
#include "quassel.h"
-#include "quasselui.h"
#include "signalproxy.h"
#include "util.h"
#include "bufferview.h"
#include "chatitem.h"
#include "chatlinemodel.h"
+#include "contextmenuactionprovider.h"
#include "iconloader.h"
#include "mainwin.h"
#include "qtui.h"
void ChatItem::addActionsToMenu(QMenu *menu, const QPointF &pos) {
Q_UNUSED(pos);
- Client::mainUi()->actionProvider()->addActions(menu, chatScene()->filter(), data(MessageModel::BufferIdRole).value<BufferId>());
+ GraphicalUi::contextMenuActionProvider()->addActions(menu, chatScene()->filter(), data(MessageModel::BufferIdRole).value<BufferId>());
}
// ************************************************************
foreach(QAction *action, menu->actions())
action->setVisible(false);
QString name = data(ChatLineModel::DisplayRole).toString().mid(click.start, click.length);
- Client::mainUi()->actionProvider()->addActions(menu, chatScene()->filter(), data(MessageModel::BufferIdRole).value<BufferId>(), name);
+ GraphicalUi::contextMenuActionProvider()->addActions(menu, chatScene()->filter(), data(MessageModel::BufferIdRole).value<BufferId>(), name);
break;
}
default:
#include "client.h"
#include "clientbacklogmanager.h"
#include "columnhandleitem.h"
+#include "contextmenuactionprovider.h"
#include "iconloader.h"
#include "messagefilter.h"
#include "qtui.h"
item->addActionsToMenu(&menu, item->mapFromScene(pos));
else
// no item -> default scene actions
- Client::mainUi()->actionProvider()->addActions(&menu, filter(), BufferId());
+ GraphicalUi::contextMenuActionProvider()->addActions(&menu, filter(), BufferId());
menu.exec(event->screenPos());
#include "chatview.h"
#include "client.h"
#include "messagefilter.h"
-#include "quasselui.h"
ChatView::ChatView(BufferId bufferId, QWidget *parent)
: QGraphicsView(parent),
#include "clientbacklogmanager.h"
#include "coreinfodlg.h"
#include "coreconnectdlg.h"
+#include "contextmenuactionprovider.h"
#include "debuglogwidget.h"
#include "debugmessagemodelfilter.h"
#include "iconloader.h"
connect(QApplication::instance(), SIGNAL(aboutToQuit()), SLOT(saveLayout()));
connect(Client::instance(), SIGNAL(networkCreated(NetworkId)), SLOT(clientNetworkCreated(NetworkId)));
connect(Client::instance(), SIGNAL(networkRemoved(NetworkId)), SLOT(clientNetworkRemoved(NetworkId)));
- connect(Client::mainUi()->actionProvider(), SIGNAL(showChannelList(NetworkId)), SLOT(showChannelList(NetworkId)));
+ connect(GraphicalUi::contextMenuActionProvider(), SIGNAL(showChannelList(NetworkId)), SLOT(showChannelList(NetworkId)));
// Setup Dock Areas
setDockNestingEnabled(true);
#include "abstractnotificationbackend.h"
#include "actioncollection.h"
#include "chatlinemodel.h"
+#include "contextmenuactionprovider.h"
#include "mainwin.h"
-#include "networkmodelactionprovider.h"
#include "qtuimessageprocessor.h"
#include "qtuisettings.h"
#include "qtuistyle.h"
QList<AbstractNotificationBackend::Notification> QtUi::_notifications;
QtUiStyle *QtUi::_style = 0;
-QtUi::QtUi() : AbstractUi() {
+QtUi::QtUi() : GraphicalUi() {
if(_instance != 0) {
qWarning() << "QtUi has been instantiated again!";
return;
}
_instance = this;
- _actionProvider = new NetworkModelActionProvider(this);
+ setContextMenuActionProvider(new ContextMenuActionProvider(this));
QtUiSettings uiSettings;
Quassel::loadTranslation(uiSettings.value("Locale", QLocale::system()).value<QLocale>());
#ifndef QTUI_H
#define QTUI_H
-#include "quasselui.h"
+#include "graphicalui.h"
#include "abstractnotificationbackend.h"
#include "mainwin.h"
/** This is basically a wrapper around MainWin, which is necessary because we cannot derive MainWin
* from both QMainWindow and AbstractUi (because of multiple inheritance of QObject).
*/
-class QtUi : public AbstractUi {
+class QtUi : public GraphicalUi {
Q_OBJECT
public:
* @param category The category (default: "General")
*/
static ActionCollection *actionCollection(const QString &category = "General");
- inline AbstractActionProvider *actionProvider() const;
/* Notifications */
static const QList<AbstractNotificationBackend::Notification> &activeNotifications();
public slots:
- void init();
+ virtual void init();
protected slots:
void connectedToCore();
void notificationActivated();
private:
- AbstractActionProvider *_actionProvider;
-
static QPointer<QtUi> _instance;
static QPointer<MainWin> _mainWin;
static QHash<QString, ActionCollection *> _actionCollections;
QtUi *QtUi::instance() { return _instance ? _instance.data() : new QtUi(); }
QtUiStyle *QtUi::style() { return _style; }
MainWin *QtUi::mainWindow() { return _mainWin; }
-AbstractActionProvider *QtUi::actionProvider() const { return _actionProvider; }
#endif
clearablelineedit.cpp
clickablelabel.cpp
colorbutton.cpp
+ contextmenuactionprovider.cpp
+ graphicalui.cpp
icon.cpp
iconloader.cpp
inputline.cpp
- networkmodelactionprovider.cpp
nickview.cpp
nickviewfilter.cpp
settingspage.cpp
tabcompleter.cpp
+ #toolbaractionprovider.cpp
uisettings.cpp
- uistyle.cpp)
+ uistyle.cpp
+ )
set(MOC_HDRS
abstractbuffercontainer.h
clearablelineedit.h
clickablelabel.h
colorbutton.h
+ contextmenuactionprovider.h
+ graphicalui.h
iconloader.h
inputline.h
- networkmodelactionprovider.h
nickview.h
nickviewfilter.h
settingspage.h
- tabcompleter.h)
+ tabcompleter.h
+ #toolbaractionprovider.h
+ )
set(HEADERS
icon.h
#include "buffersettings.h"
#include "buffersyncer.h"
#include "client.h"
+#include "contextmenuactionprovider.h"
+#include "graphicalui.h"
#include "iconloader.h"
#include "network.h"
#include "networkmodel.h"
-#include "networkmodelactionprovider.h"
-#include "quasselui.h"
+#include "contextmenuactionprovider.h"
#include "uisettings.h"
/*****************************************
indexList.removeAll(index);
indexList.prepend(index);
- Client::mainUi()->actionProvider()->addActions(contextMenu, indexList, this, "menuActionTriggered", (bool)config());
+ GraphicalUi::contextMenuActionProvider()->addActions(contextMenu, indexList, this, "menuActionTriggered", (bool)config());
}
void BufferView::addFilterActions(QMenu *contextMenu, const QModelIndex &index) {
}
void BufferView::menuActionTriggered(QAction *result) {
- NetworkModelActionProvider::ActionType type = (NetworkModelActionProvider::ActionType)result->data().toInt();
+ ContextMenuActionProvider::ActionType type = (ContextMenuActionProvider::ActionType)result->data().toInt();
switch(type) {
- case NetworkModelActionProvider::HideBufferTemporarily:
+ case ContextMenuActionProvider::HideBufferTemporarily:
removeSelectedBuffers();
break;
- case NetworkModelActionProvider::HideBufferPermanently:
+ case ContextMenuActionProvider::HideBufferPermanently:
removeSelectedBuffers(true);
break;
default:
#include <QMenu>
#include <QMessageBox>
-#include "networkmodelactionprovider.h"
+#include "contextmenuactionprovider.h"
#include "buffermodel.h"
#include "buffersettings.h"
#include "network.h"
#include "util.h"
-NetworkModelActionProvider::NetworkModelActionProvider(QObject *parent)
-: AbstractActionProvider(parent),
+ContextMenuActionProvider::ContextMenuActionProvider(QObject *parent)
+: QObject(parent),
_actionCollection(new ActionCollection(this)),
_messageFilter(0),
_receiver(0)
_nickModeMenuAction->setMenu(nickModeMenu);
}
-NetworkModelActionProvider::~NetworkModelActionProvider() {
+ContextMenuActionProvider::~ContextMenuActionProvider() {
_hideEventsMenuAction->menu()->deleteLater();
_hideEventsMenuAction->deleteLater();
_nickCtcpMenuAction->menu()->deleteLater();
_nickModeMenuAction->deleteLater();
}
-void NetworkModelActionProvider::registerAction(ActionType type, const QString &text, bool checkable) {
+void ContextMenuActionProvider::registerAction(ActionType type, const QString &text, bool checkable) {
registerAction(type, QPixmap(), text, checkable);
}
-void NetworkModelActionProvider::registerAction(ActionType type, const QPixmap &icon, const QString &text, bool checkable) {
+void ContextMenuActionProvider::registerAction(ActionType type, const QPixmap &icon, const QString &text, bool checkable) {
Action *act;
if(icon.isNull())
act = new Action(text, this);
_actionByType[type] = act;
}
-void NetworkModelActionProvider::addActions(QMenu *menu, BufferId bufId, QObject *receiver, const char *method) {
+void ContextMenuActionProvider::addActions(QMenu *menu, BufferId bufId, QObject *receiver, const char *method) {
if(!bufId.isValid())
return;
addActions(menu, Client::networkModel()->bufferIndex(bufId), receiver, method);
}
-void NetworkModelActionProvider::addActions(QMenu *menu, const QModelIndex &index, QObject *receiver, const char *method, bool isCustomBufferView) {
+void ContextMenuActionProvider::addActions(QMenu *menu, const QModelIndex &index, QObject *receiver, const char *method, bool isCustomBufferView) {
if(!index.isValid())
return;
addActions(menu, QList<QModelIndex>() << index, 0, QString(), receiver, method, isCustomBufferView);
}
-void NetworkModelActionProvider::addActions(QMenu *menu, MessageFilter *filter, BufferId msgBuffer, QObject *receiver, const char *slot) {
+void ContextMenuActionProvider::addActions(QMenu *menu, MessageFilter *filter, BufferId msgBuffer, QObject *receiver, const char *slot) {
addActions(menu, filter, msgBuffer, QString(), receiver, slot);
}
-void NetworkModelActionProvider::addActions(QMenu *menu, MessageFilter *filter, BufferId msgBuffer, const QString &chanOrNick, QObject *receiver, const char *method) {
+void ContextMenuActionProvider::addActions(QMenu *menu, MessageFilter *filter, BufferId msgBuffer, const QString &chanOrNick, QObject *receiver, const char *method) {
if(!filter)
return;
addActions(menu, QList<QModelIndex>() << Client::networkModel()->bufferIndex(msgBuffer), filter, chanOrNick, receiver, method, false);
}
-void NetworkModelActionProvider::addActions(QMenu *menu, const QList<QModelIndex> &indexList, QObject *receiver, const char *method, bool isCustomBufferView) {
+void ContextMenuActionProvider::addActions(QMenu *menu, const QList<QModelIndex> &indexList, QObject *receiver, const char *method, bool isCustomBufferView) {
addActions(menu, indexList, 0, QString(), receiver, method, isCustomBufferView);
}
// add a list of actions sensible for the current item(s)
-void NetworkModelActionProvider::addActions(QMenu *menu,
+void ContextMenuActionProvider::addActions(QMenu *menu,
const QList<QModelIndex> &indexList,
MessageFilter *filter,
const QString &contextItem,
}
}
-void NetworkModelActionProvider::addNetworkItemActions(QMenu *menu, const QModelIndex &index) {
+void ContextMenuActionProvider::addNetworkItemActions(QMenu *menu, const QModelIndex &index) {
NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
if(!networkId.isValid())
return;
}
-void NetworkModelActionProvider::addBufferItemActions(QMenu *menu, const QModelIndex &index, bool isCustomBufferView) {
+void ContextMenuActionProvider::addBufferItemActions(QMenu *menu, const QModelIndex &index, bool isCustomBufferView) {
BufferInfo bufferInfo = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
menu->addSeparator();
}
}
-void NetworkModelActionProvider::addIrcUserActions(QMenu *menu, const QModelIndex &index) {
+void ContextMenuActionProvider::addIrcUserActions(QMenu *menu, const QModelIndex &index) {
// this can be called: a) as a nicklist context menu (index has IrcUserItemType)
// b) as a query buffer context menu (index has BufferItemType and is a QueryBufferItem)
// c) right-click in a query chatview (same as b), index will be the corresponding QueryBufferItem)
/******** Helper Functions ***********************************************************************/
-bool NetworkModelActionProvider::checkRequirements(const QModelIndex &index, ItemActiveStates requiredActiveState) {
+bool ContextMenuActionProvider::checkRequirements(const QModelIndex &index, ItemActiveStates requiredActiveState) {
if(!index.isValid())
return false;
return true;
}
-Action * NetworkModelActionProvider::addAction(ActionType type , QMenu *menu, const QModelIndex &index, ItemActiveStates requiredActiveState) {
+Action * ContextMenuActionProvider::addAction(ActionType type , QMenu *menu, const QModelIndex &index, ItemActiveStates requiredActiveState) {
return addAction(action(type), menu, checkRequirements(index, requiredActiveState));
}
-Action * NetworkModelActionProvider::addAction(Action *action , QMenu *menu, const QModelIndex &index, ItemActiveStates requiredActiveState) {
+Action * ContextMenuActionProvider::addAction(Action *action , QMenu *menu, const QModelIndex &index, ItemActiveStates requiredActiveState) {
return addAction(action, menu, checkRequirements(index, requiredActiveState));
}
-Action * NetworkModelActionProvider::addAction(ActionType type , QMenu *menu, bool condition) {
+Action * ContextMenuActionProvider::addAction(ActionType type , QMenu *menu, bool condition) {
return addAction(action(type), menu, condition);
}
-Action * NetworkModelActionProvider::addAction(Action *action , QMenu *menu, bool condition) {
+Action * ContextMenuActionProvider::addAction(Action *action , QMenu *menu, bool condition) {
if(condition) {
menu->addAction(action);
action->setVisible(true);
return action;
}
-void NetworkModelActionProvider::addHideEventsMenu(QMenu *menu, BufferId bufferId) {
+void ContextMenuActionProvider::addHideEventsMenu(QMenu *menu, BufferId bufferId) {
if(BufferSettings(bufferId).hasFilter())
addHideEventsMenu(menu, BufferSettings(bufferId).messageFilter());
else
addHideEventsMenu(menu);
}
-void NetworkModelActionProvider::addHideEventsMenu(QMenu *menu, MessageFilter *msgFilter) {
+void ContextMenuActionProvider::addHideEventsMenu(QMenu *menu, MessageFilter *msgFilter) {
if(BufferSettings(msgFilter->idString()).hasFilter())
addHideEventsMenu(menu, BufferSettings(msgFilter->idString()).messageFilter());
else
addHideEventsMenu(menu);
}
-void NetworkModelActionProvider::addHideEventsMenu(QMenu *menu, int filter) {
+void ContextMenuActionProvider::addHideEventsMenu(QMenu *menu, int filter) {
action(HideApplyToAll)->setEnabled(filter != -1);
action(HideUseDefaults)->setEnabled(filter != -1);
if(filter == -1)
menu->addAction(_hideEventsMenuAction);
}
-QString NetworkModelActionProvider::nickName(const QModelIndex &index) const {
+QString ContextMenuActionProvider::nickName(const QModelIndex &index) const {
IrcUser *ircUser = qobject_cast<IrcUser *>(index.data(NetworkModel::IrcUserRole).value<QObject *>());
if(ircUser)
return ircUser->nick();
return bufferInfo.bufferName(); // FIXME this might break with merged queries maybe
}
-BufferId NetworkModelActionProvider::findQueryBuffer(const QModelIndex &index, const QString &predefinedNick) const {
+BufferId ContextMenuActionProvider::findQueryBuffer(const QModelIndex &index, const QString &predefinedNick) const {
NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
if(!networkId.isValid())
return BufferId();
return findQueryBuffer(networkId, nick);
}
-BufferId NetworkModelActionProvider::findQueryBuffer(NetworkId networkId, const QString &nick) const {
+BufferId ContextMenuActionProvider::findQueryBuffer(NetworkId networkId, const QString &nick) const {
return Client::networkModel()->bufferId(networkId, nick);
}
-void NetworkModelActionProvider::handleExternalAction(ActionType type, QAction *action) {
+void ContextMenuActionProvider::handleExternalAction(ActionType type, QAction *action) {
Q_UNUSED(type);
if(_receiver && _method) {
if(!QMetaObject::invokeMethod(_receiver, _method, Q_ARG(QAction *, action)))
/******** Handle Actions *************************************************************************/
-void NetworkModelActionProvider::actionTriggered(QAction *action) {
+void ContextMenuActionProvider::actionTriggered(QAction *action) {
ActionType type = (ActionType)action->data().toInt();
if(type > 0) {
if(type & NetworkMask)
_receiver = 0;
}
-void NetworkModelActionProvider::handleNetworkAction(ActionType type, QAction *) {
+void ContextMenuActionProvider::handleNetworkAction(ActionType type, QAction *) {
if(!_indexList.count())
return;
const Network *network = Client::network(_indexList.at(0).data(NetworkModel::NetworkIdRole).value<NetworkId>());
}
}
-void NetworkModelActionProvider::handleBufferAction(ActionType type, QAction *) {
+void ContextMenuActionProvider::handleBufferAction(ActionType type, QAction *) {
if(type == BufferRemove) {
removeBuffers(_indexList);
} else {
}
}
-void NetworkModelActionProvider::removeBuffers(const QModelIndexList &indexList) {
+void ContextMenuActionProvider::removeBuffers(const QModelIndexList &indexList) {
QList<BufferInfo> inactive;
foreach(QModelIndex index, indexList) {
BufferInfo info = index.data(NetworkModel::BufferInfoRole).value<BufferInfo>();
}
}
-void NetworkModelActionProvider::handleHideAction(ActionType type, QAction *action) {
+void ContextMenuActionProvider::handleHideAction(ActionType type, QAction *action) {
Q_UNUSED(action)
int filter = 0;
- if(NetworkModelActionProvider::action(HideJoin)->isChecked())
+ if(ContextMenuActionProvider::action(HideJoin)->isChecked())
filter |= Message::Join;
- if(NetworkModelActionProvider::action(HidePart)->isChecked())
+ if(ContextMenuActionProvider::action(HidePart)->isChecked())
filter |= Message::Part;
- if(NetworkModelActionProvider::action(HideQuit)->isChecked())
+ if(ContextMenuActionProvider::action(HideQuit)->isChecked())
filter |= Message::Quit;
- if(NetworkModelActionProvider::action(HideNick)->isChecked())
+ if(ContextMenuActionProvider::action(HideNick)->isChecked())
filter |= Message::Nick;
- if(NetworkModelActionProvider::action(HideMode)->isChecked())
+ if(ContextMenuActionProvider::action(HideMode)->isChecked())
filter |= Message::Mode;
- if(NetworkModelActionProvider::action(HideDayChange)->isChecked())
+ if(ContextMenuActionProvider::action(HideDayChange)->isChecked())
filter |= Message::DayChange;
switch(type) {
};
}
-void NetworkModelActionProvider::handleGeneralAction(ActionType type, QAction *action) {
+void ContextMenuActionProvider::handleGeneralAction(ActionType type, QAction *action) {
Q_UNUSED(action)
if(!_indexList.count())
}
}
-void NetworkModelActionProvider::handleNickAction(ActionType type, QAction *) {
+void ContextMenuActionProvider::handleNickAction(ActionType type, QAction *) {
foreach(QModelIndex index, _indexList) {
NetworkId networkId = index.data(NetworkModel::NetworkIdRole).value<NetworkId>();
if(!networkId.isValid())
#include "action.h"
#include "actioncollection.h"
#include "messagefilter.h"
-#include "quasselui.h"
-class NetworkModelActionProvider : public AbstractActionProvider {
+class ContextMenuActionProvider : public QObject {
Q_OBJECT
public:
- NetworkModelActionProvider(QObject *parent = 0);
- ~NetworkModelActionProvider();
+ ContextMenuActionProvider(QObject *parent = 0);
+ ~ContextMenuActionProvider();
// don't change enums without doublechecking masks etc. in code
enum ActionType {
};
// inlines
-ActionCollection *NetworkModelActionProvider::actionCollection() const { return _actionCollection; }
-Action *NetworkModelActionProvider::action(ActionType type) const { return _actionByType.value(type, 0); }
+ActionCollection *ContextMenuActionProvider::actionCollection() const { return _actionCollection; }
+Action *ContextMenuActionProvider::action(ActionType type) const { return _actionByType.value(type, 0); }
#endif
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005-09 by the Quassel Project *
+ * devel@quassel-irc.org *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) version 3. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+
+#include "graphicalui.h"
+
+#include "contextmenuactionprovider.h"
+
+ContextMenuActionProvider *GraphicalUi::_contextMenuActionProvider = 0;
+
+GraphicalUi::GraphicalUi(QObject *parent) : AbstractUi(parent) {
+
+}
+
+void GraphicalUi::setContextMenuActionProvider(ContextMenuActionProvider *provider) {
+ _contextMenuActionProvider = provider;
+}
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2005-09 by the Quassel Project *
+ * devel@quassel-irc.org *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) version 3. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+
+#ifndef GRAPHICALUI_H_
+#define GRAPHICALUI_H_
+
+#include "abstractui.h"
+
+class ContextMenuActionProvider;
+
+class GraphicalUi : public AbstractUi {
+ Q_OBJECT
+
+public:
+ GraphicalUi(QObject *parent = 0);
+
+ inline static ContextMenuActionProvider *contextMenuActionProvider();
+
+protected:
+ void setContextMenuActionProvider(ContextMenuActionProvider *);
+
+private:
+ static ContextMenuActionProvider *_contextMenuActionProvider;
+
+};
+
+ContextMenuActionProvider *GraphicalUi::contextMenuActionProvider() {
+ return _contextMenuActionProvider;
+}
+
+#endif
#include "buffermodel.h"
#include "client.h"
+#include "contextmenuactionprovider.h"
+#include "graphicalui.h"
+#include "nickview.h"
#include "nickviewfilter.h"
#include "networkmodel.h"
-#include "quasselui.h"
#include "types.h"
#include "uisettings.h"
indexList.prepend(index);
QMenu contextMenu(this);
- Client::mainUi()->actionProvider()->addActions(&contextMenu, indexList);
+ GraphicalUi::contextMenuActionProvider()->addActions(&contextMenu, indexList);
contextMenu.exec(QCursor::pos());
}