static cell_t sm_GetFunctionByName(IPluginContext *pContext, const cell_t *params)
{
Handle_t hndl = static_cast<Handle_t>(params[1]);
HandleError err;
char *name;
uint32_t idx;
IPlugin *pPlugin;
if (hndl == 0)
{
pPlugin = g_PluginSys.FindPluginByContext(pContext->GetContext());
} else {
pPlugin = g_PluginSys.PluginFromHandle(hndl, &err);
if (!pPlugin)
{
return pContext->ThrowNativeError("Plugin handle %x is invalid (error %d)", hndl, err);
}
}
pContext->LocalToString(params[2], &name);
/* Get public function index */
if (pPlugin->GetBaseContext()->FindPublicByName(name, &idx) == SP_ERROR_NOT_FOUND)
{
/* Return INVALID_FUNCTION if not found */
return -1;
}
/* Return function ID */
return PublicIndexToFuncId(idx);
}
static cell_t sm_RemoveFromForward(IPluginContext *pContext, const cell_t *params)
{
Handle_t fwdHandle = static_cast<Handle_t>(params[1]);
Handle_t plHandle = static_cast<Handle_t>(params[2]);
HandleError err;
IChangeableForward *pForward;
IPlugin *pPlugin;
if ((err=g_HandleSys.ReadHandle(fwdHandle, g_PrivateFwdType, NULL, (void **)&pForward))
!= HandleError_None)
{
return pContext->ThrowNativeError("Invalid private forward handle %x (error %d)", fwdHandle, err);
}
if (plHandle == 0)
{
pPlugin = g_PluginSys.FindPluginByContext(pContext->GetContext());
} else {
pPlugin = g_PluginSys.PluginFromHandle(plHandle, &err);
if (!pPlugin)
{
return pContext->ThrowNativeError("Plugin handle %x is invalid (error %d)", plHandle, err);
}
}
IPluginFunction *pFunction = pPlugin->GetBaseContext()->GetFunctionById(params[3]);
if (!pFunction)
{
return pContext->ThrowNativeError("Invalid function id (%X)", params[3]);
}
return pForward->RemoveFunction(pFunction);
}
bool MainWindowPlugin::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
Q_UNUSED(AInitOrder);
FPluginManager = APluginManager;
IPlugin *plugin = FPluginManager->pluginInterface("IOptionsManager").value(0,NULL);
if (plugin)
{
FOptionsManager = qobject_cast<IOptionsManager *>(plugin->instance());
if (FOptionsManager)
{
connect(FOptionsManager->instance(), SIGNAL(profileRenamed(const QString &, const QString &)),
SLOT(onProfileRenamed(const QString &, const QString &)));
}
}
plugin = APluginManager->pluginInterface("ITrayManager").value(0,NULL);
if (plugin)
{
FTrayManager = qobject_cast<ITrayManager *>(plugin->instance());
if (FTrayManager)
{
connect(FTrayManager->instance(),SIGNAL(notifyActivated(int, QSystemTrayIcon::ActivationReason)),
SLOT(onTrayNotifyActivated(int,QSystemTrayIcon::ActivationReason)));
}
}
connect(Options::instance(),SIGNAL(optionsOpened()),SLOT(onOptionsOpened()));
connect(Options::instance(),SIGNAL(optionsClosed()),SLOT(onOptionsClosed()));
connect(Options::instance(),SIGNAL(optionsChanged(const OptionsNode &)),SLOT(onOptionsChanged(const OptionsNode &)));
connect(FPluginManager->instance(),SIGNAL(shutdownStarted()),SLOT(onShutdownStarted()));
return true;
}
IPlugin* load(const char* path) override
{
g_log_info.log("plugins") << "loading plugin " << path;
typedef IPlugin* (*PluginCreator)(Engine&);
auto* lib = loadLibrary(path);
if (lib)
{
PluginCreator creator = (PluginCreator)getLibrarySymbol(lib, "createPlugin");
if (creator)
{
IPlugin* plugin = creator(m_engine);
if (!plugin || !plugin->create())
{
LUMIX_DELETE(m_engine.getAllocator(), plugin);
ASSERT(false);
return nullptr;
}
m_plugins.push(plugin);
m_libraries.push(lib);
m_library_loaded.invoke(lib);
g_log_info.log("plugins") << "plugin loaded";
return plugin;
}
}
unloadLibrary(lib);
return 0;
}
void EntityOutputManager::CleanUpHook(omg_hooks *hook)
{
FreeHooks.push(hook);
OnHookRemoved();
IPlugin *pPlugin = plsys->FindPluginByContext(hook->pf->GetParentContext()->GetContext());
SourceHook::List<omg_hooks *> *pList = NULL;
if (!pPlugin->GetProperty("OutputHookList", (void **)&pList, false) || !pList)
{
return;
}
SourceHook::List<omg_hooks *>::iterator p_iter = pList->begin();
omg_hooks *pluginHook;
while (p_iter != pList->end())
{
pluginHook = (omg_hooks *)*p_iter;
if (pluginHook == hook)
{
p_iter = pList->erase(p_iter);
}
else
{
p_iter++;
}
}
}
/* Destructor */
sentry::Sentry::~Sentry() throw(){
/* Execute the pre-shutdown actions */
IHookPoint* pre_shutdown = findHookPoint("core.pre_shutdown");
if( ! pre_shutdown ){
Logger::log("Could not find hookpoint core.pre_shutdown", Logger::LOG_ERROR);
}else{
_executeCommandsIn(pre_shutdown);
delete pre_shutdown;
}
/* Unload the plug-ins */
for(map<string, IPlugin*>::iterator it = _plugins.begin(); it != _plugins.end(); it++){
IPlugin* plugin = it->second;
Logger::log("Unloading " + plugin->getName(), Logger::LOG_INFO);
delete plugin;
}
delete _config;
/* elete the hookpoints */
for(map<string, IHookPoint*>::iterator it = _hookpoints.begin(); it != _hookpoints.end(); it++){
IHookPoint* hookpoint = it->second;
delete hookpoint;
}
}
void ConsoleWidget::initialize(IPluginManager *APluginManager)
{
IPlugin *plugin = APluginManager->pluginInterface("IXmppStreams").value(0,NULL);
if (plugin)
{
FXmppStreams = qobject_cast<IXmppStreams *>(plugin->instance());
if (FXmppStreams)
{
foreach(IXmppStream *stream, FXmppStreams->xmppStreams())
onStreamCreated(stream);
connect(FXmppStreams->instance(), SIGNAL(created(IXmppStream *)), SLOT(onStreamCreated(IXmppStream *)));
connect(FXmppStreams->instance(), SIGNAL(jidChanged(IXmppStream *, const Jid &)), SLOT(onStreamJidChanged(IXmppStream *, const Jid &)));
connect(FXmppStreams->instance(), SIGNAL(streamDestroyed(IXmppStream *)), SLOT(onStreamDestroyed(IXmppStream *)));
}
}
plugin = APluginManager->pluginInterface("IStanzaProcessor").value(0,NULL);
if (plugin)
{
FStanzaProcessor = qobject_cast<IStanzaProcessor *>(plugin->instance());
if (FStanzaProcessor)
{
foreach(int shandleId, FStanzaProcessor->stanzaHandles())
onStanzaHandleInserted(shandleId,FStanzaProcessor->stanzaHandle(shandleId));
connect(FStanzaProcessor->instance(),SIGNAL(stanzaHandleInserted(int, const IStanzaHandle &)),SLOT(onStanzaHandleInserted(int, const IStanzaHandle &)));
ui.cmbCondition->clearEditText();
}
}
connect(Options::instance(),SIGNAL(optionsOpened()),SLOT(onOptionsOpened()));
connect(Options::instance(),SIGNAL(optionsClosed()),SLOT(onOptionsClosed()));
}
HRESULT Init(HWND hWnd)
{
mod_file_system.Init("Core.FileSystem.dll");
mod_dx9.Init("Engine.Graphics.DX9.dll");
mod_file_system.CreateInstance(CLSID_CFileSystem, UUID_PPV(IFileSystem, &pFS));
gEnv = &sgEnv;
gEnv->Core = 0;
gEnv->Logger = 0;
gEnv->PluginManager = 0;
gEnv->FileSystem = pFS;
IPlugin *plug;
mod_dx9.CreateInstance(UUID_PPV(IPlugin, &plug));
plug->Initialize(gEnv, 0);
plug->Release();
mod_dx9.CreateInstance(UUID_PPV(IRenderer, &pRenderer));
SRendererParams params;
params.FullScreen = fullScreen;
params.MainWindow = (WND_HANDLE)hWnd;
params.ScreenHeight = iHeight;
params.ScreenWidth = iWidth;
params.BackBufferFormat = FMT_X8R8G8B8;
pRenderer->Init(params);
return InitGeometry();
}
void PluginManager::UnLoad()
{
// Before we unload the plugins, store the list of visible workspace tabs
{
wxArrayString visibleTabs;
for(size_t i = 0; i < GetWorkspacePaneNotebook()->GetPageCount(); ++i) {
visibleTabs.Add(GetWorkspacePaneNotebook()->GetPageText(i));
}
clConfig::Get().Write("VisibleWorkspaceTabs", visibleTabs);
}
// Now do the same for the output view
{
wxArrayString visibleTabs;
for(size_t i = 0; i < GetOutputPaneNotebook()->GetPageCount(); ++i) {
visibleTabs.Add(GetOutputPaneNotebook()->GetPageText(i));
}
clConfig::Get().Write("VisibleOutputTabs", visibleTabs);
}
std::map<wxString, IPlugin*>::iterator plugIter = m_plugins.begin();
for(; plugIter != m_plugins.end(); plugIter++) {
IPlugin* plugin = plugIter->second;
plugin->UnPlug();
delete plugin;
}
m_dl.clear();
m_plugins.clear();
}
static cell_t sm_CallStartFunction(IPluginContext *pContext, const cell_t *params)
{
Handle_t hndl;
HandleError err;
IPlugin *pPlugin;
ResetCall();
hndl = static_cast<Handle_t>(params[1]);
if (hndl == 0)
{
pPlugin = g_PluginSys.FindPluginByContext(pContext->GetContext());
} else {
pPlugin = g_PluginSys.PluginFromHandle(hndl, &err);
if (!pPlugin)
{
return pContext->ThrowNativeError("Plugin handle %x is invalid (error %d)", hndl, err);
}
}
s_pFunction = pPlugin->GetBaseContext()->GetFunctionById(params[2]);
if (!s_pFunction)
{
return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
}
s_pCallable = static_cast<ICallable *>(s_pFunction);
s_CallStarted = true;
return 1;
}
static cell_t LogToFile(IPluginContext *pContext, const cell_t *params)
{
char *file;
pContext->LocalToString(params[1], &file);
char path[PLATFORM_MAX_PATH];
g_pSM->BuildPath(Path_Game, path, sizeof(path), "%s", file);
FILE *fp = fopen(path, "at");
if (!fp)
{
return pContext->ThrowNativeError("Could not open file \"%s\"", path);
}
char buffer[2048];
{
DetectExceptions eh(pContext);
g_pSM->SetGlobalTarget(SOURCEMOD_SERVER_LANGUAGE);
g_pSM->FormatString(buffer, sizeof(buffer), pContext, params, 2);
if (eh.HasException()) {
fclose(fp);
return 0;
}
}
IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
g_Logger.LogToOpenFile(fp, "[%s] %s", pPlugin->GetFilename(), buffer);
fclose(fp);
return 1;
}
bool JabberSearch::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
Q_UNUSED(AInitOrder);
FPluginManager = APluginManager;
IPlugin *plugin = APluginManager->pluginInterface("IStanzaProcessor").value(0,NULL);
if (plugin)
{
FStanzaProcessor = qobject_cast<IStanzaProcessor *>(plugin->instance());
}
plugin = APluginManager->pluginInterface("IServiceDiscovery").value(0,NULL);
if (plugin)
{
FDiscovery = qobject_cast<IServiceDiscovery *>(plugin->instance());
}
plugin = APluginManager->pluginInterface("IPresenceManager").value(0,NULL);
if (plugin)
{
FPresenceManager = qobject_cast<IPresenceManager *>(plugin->instance());
}
plugin = APluginManager->pluginInterface("IDataForms").value(0,NULL);
if (plugin)
{
FDataForms = qobject_cast<IDataForms *>(plugin->instance());
}
return FStanzaProcessor!=NULL;
}
bool CAlgorithmSettingsModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if(CQJsonModel::setData(index, value,role))
{
CQJsonTreeItem* parentItem = backtrack(index);
QJsonObject params;
IPlugin* plugin = workflow->getStep(parentItem->row());
CQJsonTreeItem* tempItem;
int size = parentItem->getChilds()->size();
for(int i = 0; i < size; i++)
{
tempItem = parentItem->getChilds()->value(i);
QJsonObject o = tempItem->toJson();
QString key = o.keys().at(0);
params.insert(key, o.take(key));
}
if(plugin->ValidateParameters(¶ms))
{
plugin->getAlgorithm()->setParameters(params);
}else{
QString pluginM = plugin->Name();
pluginM.append(" parameter not Valid!");
CLogController::instance().frameworkMessage(pluginM);
}
return true;
}
return false;
}
static cell_t ReadPlugin(IPluginContext *pContext, const cell_t *params)
{
Handle_t hndl = (Handle_t)params[1];
HandleError err;
IPluginIterator *pIter;
HandleSecurity sec;
sec.pIdentity = g_pCoreIdent;
sec.pOwner = pContext->GetIdentity();
if ((err=handlesys->ReadHandle(hndl, g_PlIter, &sec, (void **)&pIter)) != HandleError_None)
{
return pContext->ThrowNativeError("Could not read Handle %x (error %d)", hndl, err);
}
IPlugin *pPlugin = pIter->GetPlugin();
if (!pPlugin)
{
return BAD_HANDLE;
}
pIter->NextPlugin();
return pPlugin->GetMyHandle();
}
void ConVarManager::OnUnlinkConCommandBase(ConCommandBase *pBase, const char *name)
{
/* Only check convars that have not been created by SourceMod's core */
ConVarInfo *pInfo;
if (!convar_cache_lookup(name, &pInfo))
{
return;
}
HandleSecurity sec(NULL, g_pCoreIdent);
/* Remove it from our cache */
m_ConVars.remove(pInfo);
convar_cache.remove(name);
/* Now make sure no plugins are referring to this pointer */
IPluginIterator *pl_iter = scripts->GetPluginIterator();
while (pl_iter->MorePlugins())
{
IPlugin *pl = pl_iter->GetPlugin();
ConVarList *pConVarList;
if (pl->GetProperty("ConVarList", (void **)&pConVarList, true)
&& pConVarList != NULL)
{
pConVarList->remove(pInfo->pVar);
}
pl_iter->NextPlugin();
}
/* Free resources */
handlesys->FreeHandle(pInfo->handle, &sec);
delete pInfo;
}
static cell_t sm_RegConsoleCmd(IPluginContext *pContext, const cell_t *params)
{
char *name,*help;
IPluginFunction *pFunction;
pContext->LocalToString(params[1], &name);
if (strcasecmp(name, "sm") == 0)
{
return pContext->ThrowNativeError("Cannot register \"sm\" command");
}
pContext->LocalToString(params[3], &help);
pFunction = pContext->GetFunctionById(params[2]);
if (!pFunction)
{
return pContext->ThrowNativeError("Invalid function id (%X)", params[2]);
}
IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
const char *group = pPlugin->GetFilename();
if (!g_ConCmds.AddAdminCommand(pFunction, name, group, 0, help, params[4]))
{
return pContext->ThrowNativeError("Command \"%s\" could not be created. A convar with the same name already exists.", name);
}
return 1;
}
bool UsrMessageNatives::FindListener(int msgid, IPluginContext *pCtx, IPluginFunction *pHook, bool intercept, MsgWrapperIter *iter)
{
MsgWrapperList *pList;
MsgWrapperIter _iter;
MsgListenerWrapper *pListener;
IPlugin *pl = g_PluginSys.FindPluginByContext(pCtx->GetContext());
if (!pl->GetProperty("MsgListeners", reinterpret_cast<void **>(&pList)))
{
return false;
}
for (_iter=pList->begin(); _iter!=pList->end(); _iter++)
{
pListener = (*_iter);
if ((msgid == pListener->GetMessageId())
&& (intercept == pListener->IsInterceptHook())
&& (pHook == pListener->GetHookedFunction()))
{
*iter = _iter;
return true;
}
}
return false;
}
bool PluginManager::Process( Network::UdpSocket& udp, ushort op, uint ip, ushort port, Common::Stream& stream )
{
IPlugin * plugin = _plugins[op].get();
if(plugin == NULL)
return false;
return plugin->Process(udp, ip, port, stream);
}
IPlugin* load(const char* path) override
{
g_log_info.log("plugins") << "loading plugin " << path;
typedef IPlugin* (*PluginCreator)(Engine&);
Library* lib = Library::create(Path(path), m_engine.getAllocator());
if (lib->load())
{
PluginCreator creator = (PluginCreator)lib->resolve("createPlugin");
if (creator)
{
IPlugin* plugin = creator(m_engine);
if (!plugin->create())
{
m_engine.getAllocator().deleteObject(plugin);
ASSERT(false);
return nullptr;
}
m_plugins.push(plugin);
m_libraries.push(lib);
g_log_info.log("plugins") << "plugin loaded";
return plugin;
}
}
Library::destroy(lib);
return 0;
}
bool ShortcutManager::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
Q_UNUSED(AInitOrder);
IPlugin *plugin = APluginManager->pluginInterface("IOptionsManager").value(0,NULL);
if (plugin)
{
FOptionsManager = qobject_cast<IOptionsManager *>(plugin->instance());
}
plugin = APluginManager->pluginInterface("ITrayManager").value(0,NULL);
if (plugin)
{
FTrayManager = qobject_cast<ITrayManager *>(plugin->instance());
}
plugin = APluginManager->pluginInterface("INotifications").value(0,NULL);
if (plugin)
{
FNotifications = qobject_cast<INotifications *>(plugin->instance());
}
connect(Options::instance(),SIGNAL(optionsOpened()),SLOT(onOptionsOpened()));
connect(Options::instance(),SIGNAL(optionsClosed()),SLOT(onOptionsClosed()));
connect(Shortcuts::instance(),SIGNAL(shortcutActivated(const QString, QWidget *)),SLOT(onShortcutActivated(const QString, QWidget *)));
return FOptionsManager!=NULL;
}
bool WizardTransport::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
IPlugin *plugin = APluginManager->pluginInterface("IXmppStreamManager").value(0,NULL);
if (plugin)
FXmppStreamManager = qobject_cast<IXmppStreamManager *>(plugin->instance());
plugin = APluginManager->pluginInterface("IXmppStreamManager").value(0,NULL);
if (plugin)
{
FXmppStreamManager = qobject_cast<IXmppStreamManager *>(plugin->instance());
if (FXmppStreamManager)
{
connect(FXmppStreamManager->instance(),SIGNAL(streamOpened(IXmppStream *)),SLOT(onStreamOpened(IXmppStream *)));
connect(FXmppStreamManager->instance(),SIGNAL(streamClosed(IXmppStream *)),SLOT(onStreamClosed(IXmppStream *)));
}
}
plugin = APluginManager->pluginInterface("IRostersViewPlugin").value(0,NULL);
if (plugin)
{
FRostersViewPlugin = qobject_cast<IRostersViewPlugin *>(plugin->instance());
if (FRostersViewPlugin)
{
connect(FRostersViewPlugin->rostersView()->instance(),
SIGNAL(indexContextMenu(QList<IRosterIndex *>, quint32, Menu *)),
SLOT(onRosterIndexContextMenu(QList<IRosterIndex *>, quint32, Menu *)));
//connect(Shortcuts::instance(), SIGNAL(shortcutActivated(QString,QWidget*)), SLOT(onShortcutActivated(QString,QWidget*)));
}
}
plugin = APluginManager->pluginInterface("IDataForms").value(0,NULL);
AInitOrder = 200;
return true;
}
void LogAction(Handle_t hndl, int type, int client, int target, const char *message)
{
if (g_OnLogAction->GetFunctionCount())
{
cell_t result = 0;
g_OnLogAction->PushCell(hndl);
g_OnLogAction->PushCell(type);
g_OnLogAction->PushCell(client);
g_OnLogAction->PushCell(target);
g_OnLogAction->PushString(message);
g_OnLogAction->Execute(&result);
if (result >= (ResultType)Pl_Handled)
{
return;
}
}
const char *logtag = "SM";
if (type == 2)
{
HandleError err;
IPlugin *pPlugin = scripts->FindPluginByHandle(hndl, &err);
if (pPlugin)
{
logtag = pPlugin->GetFilename();
}
}
g_Logger.LogMessage("[%s] %s", logtag, message);
}
bool PrivateStorage::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
Q_UNUSED(AInitOrder);
IPlugin *plugin = APluginManager->pluginInterface("IXmppStreamManager").value(0,NULL);
if (plugin)
{
FXmppStreamManager = qobject_cast<IXmppStreamManager *>(plugin->instance());
if (FXmppStreamManager)
{
connect(FXmppStreamManager->instance(), SIGNAL(streamOpened(IXmppStream *)), SLOT(onXmppStreamOpened(IXmppStream *)));
connect(FXmppStreamManager->instance(), SIGNAL(streamAboutToClose(IXmppStream *)), SLOT(onXmppStreamAboutToClose(IXmppStream *)));
connect(FXmppStreamManager->instance(), SIGNAL(streamClosed(IXmppStream *)), SLOT(onXmppStreamClosed(IXmppStream *)));
}
}
plugin = APluginManager->pluginInterface("IStanzaProcessor").value(0,NULL);
if (plugin)
{
FStanzaProcessor = qobject_cast<IStanzaProcessor *>(plugin->instance());
}
plugin = APluginManager->pluginInterface("IPresenceManager").value(0,NULL);
if (plugin)
{
FPresenceManager = qobject_cast<IPresenceManager *>(plugin->instance());
if (FPresenceManager)
{
connect(FPresenceManager->instance(),SIGNAL(presenceAboutToClose(IPresence *, int, const QString &)),
SLOT(onPresenceAboutToClose(IPresence *, int, const QString &)));
}
}
return FStanzaProcessor!=NULL;
}
void PluginManagerWidget::onIndexChanged(const QModelIndex& current)
{
const QString& pluginName = current.data().toString();
IPlugin *first = PluginLoader::instance().plugin(pluginName);
m_ui->Description->setText(first->description());
Settings::setLastPlugin(current.row());
}
bool ContactProximityNotification::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
IPlugin *plugin = APluginManager->pluginInterface("IGeoloc").value(0,NULL);
if (plugin)
{
connect(plugin->instance(),SIGNAL(locationReceived(Jid,Jid,MercatorCoordinates,bool)),SLOT(onLocationReceived(Jid,Jid,MercatorCoordinates,bool)));
connect(plugin->instance(),SIGNAL(locationRemoved(Jid,Jid)),SLOT(onLocationRemoved(Jid,Jid)));
}
else
return false;
static cell_t IsPluginDebugging(IPluginContext *pContext, const cell_t *params)
{
IPlugin *pPlugin = GetPluginFromHandle(pContext, params[1]);
if (!pPlugin)
{
return 0;
}
return pPlugin->IsDebugging() ? 1 : 0;
}
static cell_t GetPluginStatus(IPluginContext *pContext, const cell_t *params)
{
IPlugin *pPlugin = GetPluginFromHandle(pContext, params[1]);
if (!pPlugin)
{
return 0;
}
return pPlugin->GetStatus();
}
bool PluginManager::Process( Network::TcpClient& client, ushort op, Common::Stream& stream )
{
IPlugin * plugin = _plugins[op].get();
if(plugin == NULL)
{
LOG_INFO(("Received unknown op code: %04X", op));
return false;
}
return plugin->Process(client, stream);
}
bool XmppUriQueries::initConnections(IPluginManager *APluginManager, int &AInitOrder)
{
Q_UNUSED(AInitOrder);
IPlugin *plugin = APluginManager->pluginInterface("IMessageWidgets").value(0,NULL);
if (plugin)
{
FMessageWidgets = qobject_cast<IMessageWidgets *>(plugin->instance());
}
return true;
}
void AddMetaItemPage::initialize(IPluginManager *APluginManager)
{
IPlugin *plugin = APluginManager->pluginInterface("IRosterChanger").value(0,NULL);
if (plugin)
FRosterChanger = qobject_cast<IRosterChanger *>(plugin->instance());
plugin = APluginManager->pluginInterface("IMessageProcessor").value(0,NULL);
if (plugin)
FMessageProcessor = qobject_cast<IMessageProcessor *>(plugin->instance());
}
