random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/nprt_plugin/plugin.cpp

470 lines
13 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
//////////////////////////////////////////////////
//
// CPlugin class implementation
//
#include <windows.h>
#include <windowsx.h>
#include "plugin.h"
#include "npupp.h"
#include "nsError.h"
#include <malloc.h>
static NPIdentifier sGetVersion_id;
//static NPObject *sWindowObj;
#define BUFFER_LEN 1024
// Helper class that can be used to map calls to the NPObject hooks
// into virtual methods on instances of classes that derive from this
// class.
class ScriptablePluginObjectBase : public NPObject
{
public:
ScriptablePluginObjectBase(NPP npp)
: mNpp(npp)
{
}
virtual ~ScriptablePluginObjectBase()
{
}
// Virtual NPObject hooks called through this base class. Override
// as you see fit.
virtual void Invalidate();
virtual bool HasMethod(NPIdentifier name);
virtual bool Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result);
virtual bool InvokeDefault(const NPVariant *args, uint32_t argCount,
NPVariant *result);
virtual bool HasProperty(NPIdentifier name);
virtual bool GetProperty(NPIdentifier name, NPVariant *result);
virtual bool SetProperty(NPIdentifier name, const NPVariant *value);
virtual bool RemoveProperty(NPIdentifier name);
public:
static void _Deallocate(NPObject *npobj);
static void _Invalidate(NPObject *npobj);
static bool _HasMethod(NPObject *npobj, NPIdentifier name);
static bool _Invoke(NPObject *npobj, NPIdentifier name,
const NPVariant *args, uint32_t argCount,
NPVariant *result);
static bool _InvokeDefault(NPObject *npobj, const NPVariant *args,
uint32_t argCount, NPVariant *result);
static bool _HasProperty(NPObject * npobj, NPIdentifier name);
static bool _GetProperty(NPObject *npobj, NPIdentifier name,
NPVariant *result);
static bool _SetProperty(NPObject *npobj, NPIdentifier name,
const NPVariant *value);
static bool _RemoveProperty(NPObject *npobj, NPIdentifier name);
protected:
NPP mNpp;
};
#define DECLARE_NPOBJECT_CLASS_WITH_BASE(_class, ctor) \
static NPClass s##_class##_NPClass = { \
NP_CLASS_STRUCT_VERSION, \
ctor, \
ScriptablePluginObjectBase::_Deallocate, \
ScriptablePluginObjectBase::_Invalidate, \
ScriptablePluginObjectBase::_HasMethod, \
ScriptablePluginObjectBase::_Invoke, \
ScriptablePluginObjectBase::_InvokeDefault, \
ScriptablePluginObjectBase::_HasProperty, \
ScriptablePluginObjectBase::_GetProperty, \
ScriptablePluginObjectBase::_SetProperty, \
ScriptablePluginObjectBase::_RemoveProperty, \
}
#define GET_NPOBJECT_CLASS(_class) &s##_class##_NPClass
void
ScriptablePluginObjectBase::Invalidate()
{
}
bool
ScriptablePluginObjectBase::HasMethod(NPIdentifier name)
{
return false;
}
bool
ScriptablePluginObjectBase::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
return false;
}
bool
ScriptablePluginObjectBase::InvokeDefault(const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
return false;
}
bool
ScriptablePluginObjectBase::HasProperty(NPIdentifier name)
{
return false;
}
bool
ScriptablePluginObjectBase::GetProperty(NPIdentifier name, NPVariant *result)
{
return false;
}
bool
ScriptablePluginObjectBase::SetProperty(NPIdentifier name,
const NPVariant *value)
{
return false;
}
bool
ScriptablePluginObjectBase::RemoveProperty(NPIdentifier name)
{
return false;
}
// static
void
ScriptablePluginObjectBase::_Deallocate(NPObject *npobj)
{
// Call the virtual destructor.
delete (ScriptablePluginObjectBase *)npobj;
}
// static
void
ScriptablePluginObjectBase::_Invalidate(NPObject *npobj)
{
((ScriptablePluginObjectBase *)npobj)->Invalidate();
}
// static
bool
ScriptablePluginObjectBase::_HasMethod(NPObject *npobj, NPIdentifier name)
{
return ((ScriptablePluginObjectBase *)npobj)->HasMethod(name);
}
// static
bool
ScriptablePluginObjectBase::_Invoke(NPObject *npobj, NPIdentifier name,
const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
return ((ScriptablePluginObjectBase *)npobj)->Invoke(name, args, argCount,
result);
}
// static
bool
ScriptablePluginObjectBase::_InvokeDefault(NPObject *npobj,
const NPVariant *args,
uint32_t argCount,
NPVariant *result)
{
return ((ScriptablePluginObjectBase *)npobj)->InvokeDefault(args, argCount,
result);
}
// static
bool
ScriptablePluginObjectBase::_HasProperty(NPObject * npobj, NPIdentifier name)
{
return ((ScriptablePluginObjectBase *)npobj)->HasProperty(name);
}
// static
bool
ScriptablePluginObjectBase::_GetProperty(NPObject *npobj, NPIdentifier name,
NPVariant *result)
{
return ((ScriptablePluginObjectBase *)npobj)->GetProperty(name, result);
}
// static
bool
ScriptablePluginObjectBase::_SetProperty(NPObject *npobj, NPIdentifier name,
const NPVariant *value)
{
return ((ScriptablePluginObjectBase *)npobj)->SetProperty(name, value);
}
// static
bool
ScriptablePluginObjectBase::_RemoveProperty(NPObject *npobj, NPIdentifier name)
{
return ((ScriptablePluginObjectBase *)npobj)->RemoveProperty(name);
}
class ScriptablePluginObject : public ScriptablePluginObjectBase
{
public:
ScriptablePluginObject(NPP npp)
: ScriptablePluginObjectBase(npp)
{
}
virtual bool HasMethod(NPIdentifier name);
virtual bool HasProperty(NPIdentifier name);
virtual bool GetProperty(NPIdentifier name, NPVariant *result);
virtual bool Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result);
virtual bool InvokeDefault(const NPVariant *args, uint32_t argCount,
NPVariant *result);
};
static NPObject *
AllocateScriptablePluginObject(NPP npp, NPClass *aClass)
{
return new ScriptablePluginObject(npp);
}
DECLARE_NPOBJECT_CLASS_WITH_BASE(ScriptablePluginObject,
AllocateScriptablePluginObject);
bool
ScriptablePluginObject::HasMethod(NPIdentifier name)
{
return name == sGetVersion_id;
}
bool
ScriptablePluginObject::HasProperty(NPIdentifier name)
{
return PR_FALSE;
}
bool
ScriptablePluginObject::GetProperty(NPIdentifier name, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
return PR_FALSE;
}
bool
ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
if (name == sGetVersion_id) {
char csVersion[BUFFER_LEN];
memset(&csVersion[0], '\0', BUFFER_LEN);
DWORD BufferSize = BUFFER_LEN;
DWORD cbData;
bool keyFound = false;
wchar_t exeName[] = L"\\winamp.exe";
wchar_t fileName[BUFFER_LEN];
memset(&fileName[0],'\0',BUFFER_LEN);
wchar_t fileNameTemp[BUFFER_LEN];
HKEY hKey;
cbData = BUFFER_LEN;
// first check the protocol handler registry key, we're looking for
// the winamp:// protocol handler. If we find this, then this is the
// "right" exe for winamp we need to get the version number on
if (RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("winamp\\shell\\open\\command"), 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
if ( RegQueryValueEx( hKey,
TEXT(""),
NULL,
NULL,
(LPBYTE) fileNameTemp,
&cbData ) != ERROR_SUCCESS) {
return PR_FALSE;
}
RegCloseKey (hKey);
if (wcsstr(fileNameTemp,L"winamp.exe")) {
int indexOfFirstQuote = wcscspn(fileNameTemp, L"\"");
int indexOfSecondQuote = wcscspn(&fileNameTemp[indexOfFirstQuote+1], L"\"");
if (indexOfFirstQuote >= 0) {
keyFound = true;
wcsncpy(fileName,&fileNameTemp[indexOfFirstQuote+1], indexOfSecondQuote);
}
} else {
// some other app (itunes ??) controlling the winamp:// protocol
// return error
return PR_FALSE;
}
}
if (!keyFound) {
// See if the reg key exists
if (RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Winamp"), 0, KEY_READ, &hKey) != ERROR_SUCCESS) {
return PR_FALSE;
}
cbData = BUFFER_LEN;
if ( RegQueryValueEx( hKey,
TEXT(""),
NULL,
NULL,
(LPBYTE) fileName,
&cbData ) != ERROR_SUCCESS) {
return PR_FALSE;
}
RegCloseKey (hKey);
keyFound = true;
wcscat(fileName,exeName);
}
if (!keyFound) {
return PR_FALSE;
}
static TCHAR sBackSlash[] = {'\\','\0'};
DWORD dwVersionDataLen = GetFileVersionInfoSize(fileName, NULL);
if (dwVersionDataLen) {
char* fvBuf = (char *)alloca(dwVersionDataLen);
if (GetFileVersionInfo(fileName, 0, dwVersionDataLen, fvBuf)) {
LPVOID pVal;
UINT nValLen;
if (VerQueryValue(fvBuf, sBackSlash, &pVal, &nValLen)) {
if (nValLen == sizeof(VS_FIXEDFILEINFO)) {
VS_FIXEDFILEINFO* pFixedFileInfo = (VS_FIXEDFILEINFO*)pVal;
//sprintf(csVersion, "%d.%d.%d.%d",
//HIWORD(pFixedFileInfo->dwFileVersionMS), LOWORD(pFixedFileInfo->dwFileVersionMS),
//HIWORD(pFixedFileInfo->dwFileVersionLS), LOWORD(pFixedFileInfo->dwFileVersionLS));
sprintf(csVersion, "%d.%d%d",
HIWORD(pFixedFileInfo->dwFileVersionMS), LOWORD(pFixedFileInfo->dwFileVersionMS),
HIWORD(pFixedFileInfo->dwFileVersionLS));
}
}
}
}
size_t versionLen = (uint32)strlen(&csVersion[0]) + 1;
char *targetResult = (char *) NPN_MemAlloc(versionLen);
if (targetResult != NULL )
memcpy(targetResult, csVersion, versionLen);
else
return PR_FALSE;
STRINGZ_TO_NPVARIANT(targetResult, *result);
return PR_TRUE;
}
return PR_FALSE;
}
bool
ScriptablePluginObject::InvokeDefault(const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
VOID_TO_NPVARIANT(*result);
return PR_FALSE;
}
CPlugin::CPlugin(NPP pNPInstance) :
m_pNPInstance(pNPInstance),
m_bInitialized(FALSE),
m_pScriptableObject(NULL)
{
//NPN_GetValue(m_pNPInstance, NPNVWindowNPObject, &sWindowObj);
sGetVersion_id = NPN_GetStringIdentifier("getVersion");
}
CPlugin::~CPlugin()
{
//if (sWindowObj)
// NPN_ReleaseObject(sWindowObj);
if (m_pScriptableObject)
NPN_ReleaseObject(m_pScriptableObject);
//sWindowObj = 0;
}
NPBool CPlugin::init(NPWindow* pNPWindow)
{
if(pNPWindow == NULL)
return FALSE;
m_Window = pNPWindow;
m_bInitialized = TRUE;
return TRUE;
}
void CPlugin::shut()
{
m_bInitialized = FALSE;
}
NPBool CPlugin::isInitialized()
{
return m_bInitialized;
}
int16 CPlugin::handleEvent(void* event)
{
return 0;
}
NPObject *
CPlugin::GetScriptableObject()
{
if (!m_pScriptableObject) {
m_pScriptableObject =
NPN_CreateObject(m_pNPInstance,
GET_NPOBJECT_CLASS(ScriptablePluginObject));
}
if (m_pScriptableObject) {
NPN_RetainObject(m_pScriptableObject);
}
return m_pScriptableObject;
}
Reference in New Issue View Git Blame Copy Permalink