int32_t NPP_Write(NPP instance, NPStream * stream, int32_t offset, int32_t len, void *buffer)
{
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
int32_t rv = len;
CPlugin *pPlugin = (CPlugin *) instance->pdata;
if (pPlugin == NULL)
return NPERR_GENERIC_ERROR;
rv = pPlugin->Write(stream, offset, len, buffer);
// printf("rv = %i\n", rv);
return rv;
}
void SM_ConfigsExecuted_Plugin(unsigned int serial)
{
IPluginIterator *iter = g_PluginSys.GetPluginIterator();
while (iter->MorePlugins())
{
CPlugin *plugin = (CPlugin *)(iter->GetPlugin());
if (plugin->GetSerial() == serial)
{
SM_DoSingleExecFwds(plugin->GetBaseContext());
break;
}
iter->NextPlugin();
}
iter->Release();
}
//------------------------------------------------------------------------------------
// NPP_DestroyStream:
//------------------------------------------------------------------------------------
NPError NP_LOADDS
NPP_DestroyStream(NPP pInstance, NPStream *stream, NPError reason)
{
dbgOut1("NPP_DestroyStream");
if(pInstance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
CPlugin * pPlugin = (CPlugin *)pInstance->pdata;
assert(pPlugin != NULL);
if (!pPlugin)
return NPERR_GENERIC_ERROR;
return pPlugin->destroyStream(stream, reason);
}
static cell_t SQL_TQuery(IPluginContext *pContext, const cell_t *params)
{
IDatabase *db = NULL;
HandleError err;
if ((err = g_DBMan.ReadHandle(params[1], DBHandle_Database, (void **)&db))
!= HandleError_None)
{
return pContext->ThrowNativeError("Invalid database Handle %x (error: %d)", params[1], err);
}
if (!db->GetDriver()->IsThreadSafe())
{
return pContext->ThrowNativeError("Driver \"%s\" is not thread safe!", db->GetDriver()->GetIdentifier());
}
IPluginFunction *pf = pContext->GetFunctionById(params[2]);
if (!pf)
{
return pContext->ThrowNativeError("Function id %x is invalid", params[2]);
}
char *query;
pContext->LocalToString(params[3], &query);
cell_t data = params[4];
PrioQueueLevel level = PrioQueue_Normal;
if (params[5] == (cell_t)PrioQueue_High)
{
level = PrioQueue_High;
} else if (params[5] == (cell_t)PrioQueue_Low) {
level = PrioQueue_Low;
}
CPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pContext->GetContext());
TQueryOp *op = new TQueryOp(db, pf, query, data);
if (pPlugin->GetProperty("DisallowDBThreads", NULL)
|| !g_DBMan.AddToThreadQueue(op, level))
{
/* Do everything right now */
op->RunThreadPart();
op->RunThinkPart();
op->Destroy();
}
return 1;
}
//---------------------------------------------------------------------------
// NPP_SetWindow:
//---------------------------------------------------------------------------
NPError NP_LOADDS NPP_SetWindow(NPP pInstance, NPWindow * pNPWindow)
{
if(pInstance == NULL)
{
dbgOut1("NPP_SetWindow returns NPERR_INVALID_INSTANCE_ERROR");
return NPERR_INVALID_INSTANCE_ERROR;
}
if(pNPWindow == NULL)
{
dbgOut1("NPP_SetWindow returns NPERR_GENERIC_ERROR");
return NPERR_GENERIC_ERROR;
}
HWND hWnd = (HWND)(DWORD)pNPWindow->window;
CPlugin * pPlugin = (CPlugin *)pInstance->pdata;
assert(pPlugin != NULL);
if(pPlugin == NULL)
{
dbgOut1("NPP_SetWindow returns NPERR_GENERIC_ERROR");
return NPERR_GENERIC_ERROR;
}
if((hWnd == NULL) && (pPlugin->getWindow() == NULL)) // spurious entry
{
dbgOut1("NPP_SetWindow just returns with NPERR_NO_ERROR");
return NPERR_NO_ERROR;
}
if((hWnd == NULL) && (pPlugin->getWindow() != NULL))
{ // window went away
dbgOut1("NPP_SetWindow, going away...");
pPlugin->shut();
return NPERR_NO_ERROR;
}
if((pPlugin->getWindow() == NULL) && (hWnd != NULL))
{ // First time in -- no window created by plugin yet
dbgOut1("NPP_SetWindow, first time");
if(!pPlugin->init(hWnd))
{
delete pPlugin;
pPlugin = NULL;
return NPERR_MODULE_LOAD_FAILED_ERROR;
}
}
if((pPlugin->getWindow() != NULL) && (hWnd != NULL))
{ // Netscape window has been resized
dbgOut1("NPP_SetWindow, resizing");
pPlugin->resize();
}
return NPERR_NO_ERROR;
}
bool SaveFile(FILE_MP3* pFileMP3)
{
if (!pFileMP3->bModifyFlag) return true;
UINT result = STEP_ERROR;
FILE_INFO fileInfo;
fileInfo.pFileMP3 = pFileMP3;
int nIndex = plugins.GetPluginIndex(pFileMP3->nFormat);
if (nIndex < 0) {
// 対応プラグインなし
return false;
}
PSTEPlugin plugin = (PSTEPlugin)plugins.arPlugins.GetAt(nIndex);
if (!plugin->bUse) return false;
if (plugin->STEPSave != NULL) {
result = plugin->STEPSave(&fileInfo);
if (result == STEP_SUCCESS) {
result = CFileMP3::ConvFileName(pFileMP3) == true ? STEP_SUCCESS : STEP_ERROR;
}
}
if (result != STEP_SUCCESS) {
return false;
}
pFileMP3->bModifyFlag = false;
return true;
}
NPError NPP_NewStream(NPP instance,
NPMIMEType type,
NPStream* stream,
NPBool seekable,
uint16_t* stype)
{
if(instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
CPlugin * plugin = (CPlugin *)instance->pdata;
if(plugin == NULL)
return NPERR_GENERIC_ERROR;
NPError rv = plugin->NewStream(type, stream, seekable, stype);
return rv;
}
// here is the place to clean up and destroy the CPlugin object
NPError NPP_Destroy (NPP instance, NPSavedData** save)
{
if(instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
NPError rv = NPERR_NO_ERROR;
CPlugin * pPlugin = (CPlugin *)instance->pdata;
if(pPlugin != NULL) {
pPlugin->shut();
delete pPlugin;
pPlugin = NULL;
}
instance->pdata = NULL;
return rv;
}
// render function for oscilliscope. Returns 0 if successful, 1 if visualization should end.
int render1(struct winampVisModule *this_mod)
{
if (g_plugin.PluginRender(this_mod->waveformData[0], this_mod->waveformData[1]))
return 0; // ok
else
return 1; // failed
}
int32_t NPP_WriteReady(NPP instance, NPStream * stream)
{
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
int32_t rv = 0x0fffffff;
CPlugin *pPlugin = (CPlugin *) instance->pdata;
if (pPlugin == NULL)
return NPERR_GENERIC_ERROR;
rv = pPlugin->WriteReady(stream);
// printf("rv = %i\n",rv);
return rv;
}
//---------------------------------------------------------------------------
// NPP_Destroy:
//---------------------------------------------------------------------------
NPError NP_LOADDS
NPP_Destroy(NPP pInstance, NPSavedData** save)
{
dbgOut1("NPP_Destroy");
if(pInstance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
CPlugin * pPlugin = (CPlugin *)pInstance->pdata;
if(pPlugin != NULL)
{
pPlugin->shut();
delete pPlugin;
}
return NPERR_NO_ERROR;
}
long CMUSHclientDoc::BroadcastPlugin(long Message, LPCTSTR Text)
{
CPlugin * pSavedPlugin = m_CurrentPlugin;
long iCount = 0;
CString strCurrentID;
CString strCurrentName;
if (pSavedPlugin)
{
strCurrentID = pSavedPlugin->m_strID;
strCurrentName = pSavedPlugin->m_strName;
}
// tell a plugin the message
for (PluginListIterator pit = m_PluginList.begin ();
pit != m_PluginList.end ();
++pit)
{
CPlugin * pPlugin = *pit;
if (!(pPlugin->m_bEnabled)) // ignore disabled plugins
continue;
// don't broadcast to ourselves - could cause indefinite loop
if (pPlugin == pSavedPlugin)
continue;
CScriptCallInfo callinfo (ON_PLUGIN_BROADCAST, pPlugin->m_PluginCallbacks [ON_PLUGIN_BROADCAST]);
m_CurrentPlugin = pPlugin;
// see what the plugin makes of this,
pPlugin->ExecutePluginScript (callinfo,
Message,
(LPCTSTR) strCurrentID,
(LPCTSTR) strCurrentName,
Text);
if (callinfo._dispid_info.isvalid ())
iCount++;
} // end of doing each plugin
m_CurrentPlugin = pSavedPlugin;
return iCount;
} // end of CMUSHclientDoc::BroadcastPlugin
// ==============================
// ! Scriptability related code !
// ==============================
//
// here the plugin is asked by Mozilla to tell if it is scriptable
// we should return a valid interface id and a pointer to
// nsScriptablePeer interface which we should have implemented
// and which should be defined in the corressponding *.xpt file
// in the bin/components folder
NPError NPP_GetValue(NPP instance, NPPVariable variable, void *value)
{
NPError rv = NPERR_NO_ERROR;
if (variable == NPPVpluginScriptableNPObject) {
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
CPlugin *plugin = (CPlugin *) instance->pdata;
if (plugin == NULL)
return NPERR_GENERIC_ERROR;
*(NPObject **) value = plugin->GetScriptableObject();
} else {
rv = PluginGetValue(variable, value);
}
return rv;
}
static cell_t sm_LogError(IPluginContext *pContext, const cell_t *params)
{
g_SourceMod.SetGlobalTarget(LANG_SERVER);
char buffer[1024];
g_SourceMod.FormatString(buffer, sizeof(buffer), pContext, params, 1);
if (pContext->GetContext()->n_err != SP_ERROR_NONE)
{
return 0;
}
CPlugin *pPlugin = g_PluginSys.GetPluginByCtx(pContext->GetContext());
g_Logger.LogError("[%s] %s", pPlugin->GetFilename(), buffer);
return 1;
}
// ==============================
// ! Scriptability related code !
// ==============================
//
// here the plugin is asked by Mozilla to tell if it is scriptable
// we should return a valid interface id and a pointer to
// nsScriptablePeer interface which we should have implemented
// and which should be defined in the corressponding *.xpt file
// in the bin/components folder
NPError NPP_GetValue(NPP instance, NPPVariable variable, void *value)
{
if(instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
NPError rv = NPERR_NO_ERROR;
if(instance == NULL)
return NPERR_GENERIC_ERROR;
CPlugin * plugin = (CPlugin *)instance->pdata;
if(plugin == NULL)
return NPERR_GENERIC_ERROR;
switch (variable)
{
case NPPVpluginWindowBool:
*((PRBool *)value) = PR_TRUE;
break;
case NPPVpluginNameString:
*((char **)value) = "Boilerplate Plugin";
break;
case NPPVpluginDescriptionString:
*((char **)value) = "Boilerplate web plugin";
break;
case NPPVpluginScriptableNPObject:
if (!plugin->isInitialized())
{
return NPERR_GENERIC_ERROR;
}
*((NPObject **)value) = plugin->GetScriptableObject();
break;
default:
rv = NPERR_GENERIC_ERROR;
break;
}
return rv;
}
NPObject *NPP_GetScriptableInstance(NPP instance)
{
if(!instance)
{
return 0;
}
NPObject *npobj = 0;
CPlugin *pPlugin = (CPlugin *)instance->pdata;
if (!pPlugin)
{
npobj = pPlugin->GetScriptableObject();
}
return npobj;
}
int16_t NPP_HandleEvent(NPP instance, void *event)
{
if(instance == NULL)
{
return 0;
}
int16_t rv = 0;
CPlugin * pPlugin = (CPlugin *)instance->pdata;
if (pPlugin)
{
rv = pPlugin->handleEvent(event);
}
return rv;
}
BOOL CPlugin::RequestAPIs( void )
{
bool loadedPlugin = FALSE;
if (Plugin.AddAPI(PLUGIN_API_GUI,"Adds winamp toolbar button",sizeof(PluginGUITable)) &&
Plugin.AddAPI(PLUGIN_API_BASIC,NULL,sizeof(PluginBasicTable),PLUGIN_REQUIRES,&__BASICTABLENAME))
loadedPlugin = TRUE;
else
loadedPlugin = FALSE;
if (AddAPI(PLUGIN_API_CMDPROC,"Command Processor for /winamp",sizeof(PluginCmdProcTable)) &&
AddAPI(PLUGIN_API_BASIC,NULL,sizeof(PluginBasicTable),PLUGIN_REQUIRES,&__BASICTABLENAME))
loadedPlugin = TRUE;
else
loadedPlugin = FALSE;
return loadedPlugin;
}
extern "C" bool OnAction(long action, const void *param)
{
bool bHandled = false;
if( action == VIS_ACTION_UPDATE_TRACK )
{
}
else if( action == VIS_ACTION_UPDATE_ALBUMART )
{
}
else if (action == VIS_ACTION_NEXT_PRESET)
{
g_plugin.NextPreset(1.0f);
bHandled = true;
}
else if (action == VIS_ACTION_PREV_PRESET)
{
g_plugin.PrevPreset(1.0f);
bHandled = true;
}
else if (action == VIS_ACTION_LOAD_PRESET && param)
{
g_plugin.m_nCurrentPreset = (*(int *)param) + g_plugin.m_nDirs;
wchar_t szFile[MAX_PATH] = {0};
lstrcpyW(szFile, g_plugin.m_szPresetDir); // note: m_szPresetDir always ends with '\'
lstrcatW(szFile, g_plugin.m_presets[g_plugin.m_nCurrentPreset].szFilename.c_str());
g_plugin.LoadPreset(szFile, 1.0f);
bHandled = true;
}
else if (action == VIS_ACTION_LOCK_PRESET)
{
g_plugin.m_bPresetLockedByUser = !g_plugin.m_bPresetLockedByUser;
bHandled = true;
}
else if (action == VIS_ACTION_RANDOM_PRESET)
{
g_plugin.LoadRandomPreset(1.0f);
bHandled = true;
}
return bHandled;
}
extern "C" ADDON_STATUS ADDON_Create(void* hdl, void* props)
{
if (!props)
return ADDON_STATUS_UNKNOWN;
VIS_PROPS* visprops = (VIS_PROPS*)props;
swprintf(g_plugin.m_szPluginsDirPath, L"%hs\\resources\\", visprops->presets);
if (FALSE == g_plugin.PluginPreInitialize(0, 0))
return ADDON_STATUS_UNKNOWN;
if (FALSE == g_plugin.PluginInitialize((ID3D11DeviceContext*)visprops->device, visprops->x, visprops->y, visprops->width, visprops->height, visprops->pixelRatio))
return ADDON_STATUS_UNKNOWN;
IsInitialized = true;
return ADDON_STATUS_NEED_SETTINGS;
// return ADDON_STATUS_NEED_SAVEDSETTINGS; // We need some settings to be saved later before we quit this plugin
}
static BOOL onInitDialog(HWND hWnd, HWND hWndFocus, LPARAM lParam)
{
CPlugin * pPlugin = (CPlugin *)lParam;
SetWindowLong(hWnd, DWL_USER, (long)pPlugin);
// look at the last used API call if needed
int iSel = 0;
if (pPlugin && pPlugin->m_Pref_bRememberLastCall) {
char szFileName[_MAX_PATH];
GetINIFileName(pPlugin->getInstance(), szFileName, sizeof(szFileName));
iSel = XP_GetPrivateProfileInt(SECTION_PREFERENCES, KEY_LAST_API_CALL, 0, szFileName);
}
fillAPIComboBoxAndSetSel(GetDlgItem(hWnd, IDC_COMBO_API_CALL), iSel);
updateUI(hWnd);
int iTopMargin = 188;
SetWindowPos(hWnd, NULL, 0,iTopMargin, 0,0, SWP_NOZORDER | SWP_NOSIZE);
return TRUE;
}
//------------------------------------------------------------------------------------
// NPP_NewStream:
//------------------------------------------------------------------------------------
NPError NP_LOADDS
NPP_NewStream(NPP pInstance,
NPMIMEType type,
NPStream *stream,
NPBool seekable,
uint16_t *stype)
{
dbgOut1("NPP_NewStream");
if(pInstance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
CPlugin * pPlugin = (CPlugin *)pInstance->pdata;
assert(pPlugin != NULL);
if (!pPlugin)
return NPERR_GENERIC_ERROR;
return pPlugin->newStream(type, stream, seekable, stype);
}
void CPluginMngr::Finalize()
{
if (m_Finalized)
return;
pNatives = BuildNativeTable();
CPlugin *a = head;
while (a)
{
if (a->getStatusCode() == ps_running)
{
amx_Register(a->getAMX(), pNatives, -1);
a->Finalize();
}
a = a->next;
}
m_Finalized = true;
}
void SM_ExecuteForPlugin(IPluginContext *ctx)
{
CPlugin *plugin = (CPlugin *)g_PluginSys.GetPluginByCtx(ctx->GetContext());
unsigned int num = plugin->GetConfigCount();
if (!num)
{
SM_DoSingleExecFwds(ctx);
}
else
{
bool can_create = true;
for (unsigned int i=0; i<num; i++)
{
can_create = SM_ExecuteConfig(plugin, plugin->GetConfig(i), can_create);
}
char cmd[255];
UTIL_Format(cmd, sizeof(cmd), "sm internal 2 %d\n", plugin->GetSerial());
engine->ServerCommand(cmd);
}
}
// during this call we know when the plugin window is ready or
// is about to be destroyed so we can do some gui specific
// initialization and shutdown
NPError NPP_SetWindow (NPP instance, NPWindow* pNPWindow)
{
if(instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
NPError rv = NPERR_NO_ERROR;
if(pNPWindow == NULL)
return NPERR_GENERIC_ERROR;
CPlugin * pPlugin = (CPlugin *)instance->pdata;
if(pPlugin == NULL)
return NPERR_GENERIC_ERROR;
// window just created
if(!pPlugin->isInitialized())
{
if(!pPlugin->init(pNPWindow))
{
return NPERR_MODULE_LOAD_FAILED_ERROR;
}
return NPERR_NO_ERROR;
}
else
{
// window goes away
if(pNPWindow->window == NULL)
return NPERR_NO_ERROR;
// window resized
if(pNPWindow->window != NULL)
{
pPlugin->SetWindow(pNPWindow);
return NPERR_NO_ERROR;
}
}
return rv;
}
BOOL IsPluginSupportGenreSIF(const FILE_MP3 *fileMP3) {
int nIndex = plugins.GetPluginIndex(fileMP3->nFormat);
if (nIndex < 0) {
// 対応プラグインなし
return FALSE;
}
PSTEPlugin plugin = (PSTEPlugin)plugins.arPlugins.GetAt(nIndex);
if (!plugin->bUse) return FALSE;
if (plugin->STEPSupportGenreSIF == NULL) {
return IsPluginSupportSIF(fileMP3);// FALSE;
}
return plugin->STEPSupportGenreSIF(fileMP3->nFormat) ? TRUE : FALSE;
}
int GetColumnMax(UINT nFormat, COLUMNTYPE nColumn, bool isEditSIF) {
int nIndex = plugins.GetPluginIndex(nFormat);
if (nIndex < 0) {
// 対応プラグインなし
return 0;
}
PSTEPlugin plugin = (PSTEPlugin)plugins.arPlugins.GetAt(nIndex);
if (!plugin->bUse) return 0;
if (plugin->STEPGetColumnMax == NULL) {
return 0;
}
return plugin->STEPGetColumnMax(nFormat, nColumn, isEditSIF);
}
LPCWSTR GetColumnName(UINT nFormat, COLUMNTYPE nColumn) {
int nIndex = plugins.GetPluginIndex(nFormat);
if (nIndex < 0) {
// 対応プラグインなし
return 0;
}
PSTEPlugin plugin = (PSTEPlugin)plugins.arPlugins.GetAt(nIndex);
if (!plugin->bUse) return 0;
if (plugin->STEPGetColumnName == NULL) {
return 0;
}
return plugin->STEPGetColumnName(nFormat, nColumn);
}
static cell_t CreateNative(IPluginContext *pContext, const cell_t *params)
{
char *name;
CPlugin *pPlugin;
pContext->LocalToString(params[1], &name);
IPluginFunction *pFunction = pContext->GetFunctionById(params[2]);
if (!pFunction)
{
return pContext->ThrowNativeError("Function %x is not a valid function", params[2]);
}
pPlugin = g_PluginSys.GetPluginByCtx(pContext->GetContext());
if (!pPlugin->AddFakeNative(pFunction, name, FakeNativeRouter))
{
return pContext->ThrowNativeError("Fatal error creating dynamic native!");
}
return 1;
}
CONTROLTYPE GetControlType(UINT nFormat, COLUMNTYPE nColumn, bool isEditSIF) {
int nIndex = plugins.GetPluginIndex(nFormat);
if (nIndex < 0) {
// 対応プラグインなし
return invalid;
}
PSTEPlugin plugin = (PSTEPlugin)plugins.arPlugins.GetAt(nIndex);
if (!plugin->bUse) return invalid;
if (plugin->STEPGetControlType == NULL) {
return invalid;
}
return plugin->STEPGetControlType(nFormat, nColumn, isEditSIF);
}
