void CPlugin::print(NPPrint * pNPPrint)
{
dbgOut1("CPlugin::print()");
if(pNPPrint == NULL)
return;
}
//**************************
// Plugin window procedure
//**************************
static LRESULT CALLBACK NP_LOADDS PluginWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
CPlugin *pPlugin = (CPlugin *)GetWindowLongPtr(hWnd, GWLP_USERDATA);
switch(message)
{
case WM_CREATE:
pPlugin = (CPlugin *)(((CREATESTRUCT FAR*)lParam)->lpCreateParams);
assert(pPlugin != NULL);
SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)pPlugin);
pPlugin->onCreate(hWnd);
return 0L;
case WM_LBUTTONUP:
HANDLE_WM_LBUTTONUP(hWnd, wParam, lParam, pPlugin->onLButtonUp);
return 0L;
case WM_RBUTTONUP:
HANDLE_WM_RBUTTONUP(hWnd, wParam, lParam, pPlugin->onRButtonUp);
return 0L;
case WM_PAINT:
HANDLE_WM_PAINT(hWnd, wParam, lParam, pPlugin->onPaint);
return 0L;
case WM_MOUSEMOVE:
dbgOut1("MouseMove");
break;
default:
break;
}
return(DefWindowProc(hWnd, message, wParam, lParam));
}
void CPlugin::showGetPluginDialog()
{
assert(m_pNPMIMEType != NULL);
if(m_pNPMIMEType == NULL)
return;
// Get environment
BOOL bOffline = FALSE;
NPN_GetValue(m_pNPInstance, NPNVisOfflineBool, (void *)&bOffline);
NPN_GetValue(m_pNPInstance, NPNVjavascriptEnabledBool, (void *)&m_bJavaScript);
//NPN_GetValue(m_pNPInstance, NPNVasdEnabledBool, (void *)&m_bSmartUpdate);
m_bOnline = !bOffline;
dbgOut1("Environment:");
dbgOut2("%s", m_bOnline ? "On-line" : "Off-line");
dbgOut2("JavaScript %s", m_bJavaScript ? "Enabled" : "Disabled");
dbgOut2("SmartUpdate %s", m_bSmartUpdate ? "Enabled" : "Disabled");
if((!m_bSmartUpdate && (m_szPageURL != NULL) || (m_szFileURL != NULL)) || !m_bJavaScript)
{
// we don't want it more than once
if(m_hWndDialog == NULL)
CreateDialogParam(m_hInst, MAKEINTRESOURCE(IDD_PLUGIN_DOWNLOAD), m_hWnd,
(DLGPROC)GetPluginDialogProc, (LPARAM)this);
}
else
getPlugin();
}
NPError WINAPI NP_GetEntryPoints(NPPluginFuncs* aPluginFuncs)
{
dbgOut1("wrapper: NP_GetEntryPoints");
if(aPluginFuncs == NULL)
return NPERR_INVALID_FUNCTABLE_ERROR;
if(aPluginFuncs->size < sizeof(NPPluginFuncs))
return NPERR_INVALID_FUNCTABLE_ERROR;
aPluginFuncs->version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
aPluginFuncs->newp = NPP_New;
aPluginFuncs->destroy = NPP_Destroy;
aPluginFuncs->setwindow = NPP_SetWindow;
aPluginFuncs->newstream = NPP_NewStream;
aPluginFuncs->destroystream = NPP_DestroyStream;
aPluginFuncs->asfile = NPP_StreamAsFile;
aPluginFuncs->writeready = NPP_WriteReady;
aPluginFuncs->write = NPP_Write;
aPluginFuncs->print = NPP_Print;
aPluginFuncs->event = NPP_HandleEvent;
aPluginFuncs->urlnotify = NPP_URLNotify;
aPluginFuncs->getvalue = NPP_GetValue;
aPluginFuncs->setvalue = NPP_SetValue;
aPluginFuncs->javaClass = NULL;
return NPERR_NO_ERROR;
}
// ***************************************************************
inline void HalExpansionPortClass::ledsClr(uint32_t bitmask) {
if (!(cHtpLedNotMask & bitmask)){
dbgOut1(eDbgAll_errEvt,'B',"HalTwiPca ledsClr not a Led ",bitmask);
return;
}
((uint32_t &) portStateOutput[1]) &= bitmask;
}
void nsPluginThread::dispatch()
{
dbgOut2("nsPluginThread::dispatch: %s", FormatAction(mAction));
switch (mAction) {
case action_npp_new:
pluginNPPFuncs.newp((NPMIMEType)mP1, (NPP)mP2, (uint16)mP3, (int16)mP4, (char**)mP5, (char**)mP6, (NPSavedData*)mP7);
break;
case action_npp_destroy:
pluginNPPFuncs.destroy((NPP)mP1, (NPSavedData**)mP2);
break;
case action_npp_set_window:
pluginNPPFuncs.setwindow((NPP)mP1, (NPWindow*)mP2);
break;
case action_npp_new_stream:
pluginNPPFuncs.newstream((NPP)mP1, (NPMIMEType)mP2, (NPStream*)mP3, (NPBool)mP4, (uint16*)mP5);
break;
case action_npp_destroy_stream:
{
NPStream * stream = (NPStream *)mP2;
pluginNPPFuncs.destroystream((NPP)mP1, stream, (NPError)mP3);
break;
}
case action_npp_stream_as_file:
{
NPStream * stream = (NPStream *)mP2;
pluginNPPFuncs.asfile((NPP)mP1, stream, (char*)mP3);
break;
}
case action_npp_write_ready:
pluginNPPFuncs.writeready((NPP)mP1, (NPStream *)mP2);
break;
case action_npp_write:
pluginNPPFuncs.write((NPP)mP1, (NPStream *)mP2, (int32)mP3, (int32)mP4, (void *)mP5);
break;
case action_npp_print:
pluginNPPFuncs.print((NPP)mP1, (NPPrint*)mP2);
break;
case action_npp_handle_event:
pluginNPPFuncs.event((NPP)mP1, (void *)mP2);
break;
case action_npp_url_notify:
pluginNPPFuncs.urlnotify((NPP)mP1, (const char*)mP2, (NPReason)mP3, (void*)mP4);
break;
case action_npp_get_java_class:
//pluginNPPFuncs.javaClass;
break;
case action_npp_get_value:
pluginNPPFuncs.getvalue((NPP)mP1, (NPPVariable)mP2, (void *)mP3);
break;
case action_npp_set_value:
pluginNPPFuncs.setvalue((NPP)mP1, (NPNVariable)mP2, (void *)mP3);
break;
default:
dbgOut1("Unexpected action!");
break;
}
}
BOOL nsPluginThread::init()
{
dbgOut1("nsPluginThread::init");
// scan plugins dir for available plugins to see if we have anything
// for the given mimetype
pluginLibrary = LoadRealPlugin((NPMIMEType)mP1);
if(!pluginLibrary)
return FALSE;
NP_GETENTRYPOINTS plugin_NP_GetEntryPoints = (NP_GETENTRYPOINTS)GetProcAddress(pluginLibrary, "NP_GetEntryPoints");
if(!plugin_NP_GetEntryPoints)
return FALSE;
NP_INITIALIZE plugin_NP_Initialize = (NP_INITIALIZE)GetProcAddress(pluginLibrary, "NP_Initialize");
if(!plugin_NP_Initialize)
return FALSE;
plugin_NP_Shutdown = (NP_SHUTDOWN)GetProcAddress(pluginLibrary, "NP_Shutdown");
if(!plugin_NP_Shutdown)
return FALSE;
// fill callbacks structs
memset(&pluginNPPFuncs, 0, sizeof(NPPluginFuncs));
pluginNPPFuncs.size = sizeof(NPPluginFuncs);
plugin_NP_GetEntryPoints(&pluginNPPFuncs);
// inform the plugin about our entry point it should call
memset((void *)&wrapperNPNFuncs, 0, sizeof(wrapperNPNFuncs));
wrapperNPNFuncs.size = sizeof(wrapperNPNFuncs);
wrapperNPNFuncs.version = NPNFuncs.version;
wrapperNPNFuncs.geturlnotify = NPN_GetURLNotify;
wrapperNPNFuncs.geturl = NPN_GetURL;
wrapperNPNFuncs.posturlnotify = NPN_PostURLNotify;
wrapperNPNFuncs.posturl = NPN_PostURL;
wrapperNPNFuncs.requestread = NPN_RequestRead;
wrapperNPNFuncs.newstream = NPN_NewStream;
wrapperNPNFuncs.write = NPN_Write;
wrapperNPNFuncs.destroystream = NPN_DestroyStream;
wrapperNPNFuncs.status = NPN_Status;
wrapperNPNFuncs.uagent = NPN_UserAgent;
wrapperNPNFuncs.memalloc = NPN_MemAlloc;
wrapperNPNFuncs.memfree = NPN_MemFree;
wrapperNPNFuncs.memflush = NPN_MemFlush;
wrapperNPNFuncs.reloadplugins = NPN_ReloadPlugins;
wrapperNPNFuncs.getJavaEnv = NPN_GetJavaEnv;
wrapperNPNFuncs.getJavaPeer = NPN_GetJavaPeer;
wrapperNPNFuncs.getvalue = NPN_GetValue;
wrapperNPNFuncs.setvalue = NPN_SetValue;
wrapperNPNFuncs.invalidaterect = NPN_InvalidateRect;
wrapperNPNFuncs.invalidateregion = NPN_InvalidateRegion;
wrapperNPNFuncs.forceredraw = NPN_ForceRedraw;
plugin_NP_Initialize(&wrapperNPNFuncs);
return TRUE;
}
// ***************************************************************
inline void HalExpansionPortClass::portClr(eHalPhysicalPorts portNumber,uint8_t bitmask) {
#ifdef PORTS_DEBUG
if (ehpPortBuffSize< portNumber){
dbgOut1(eDbgAll_errEvt,'B',"HalTwiPca portClr invalid port ",portNumber);
return;
}
#endif
portStateOutput[portNumber] &= bitmask;
}
void nsPluginThread::shut()
{
dbgOut1("nsPluginThread::shut");
if (!plugin_NP_Shutdown)
plugin_NP_Shutdown();
if (!pluginLibrary)
UnloadRealPlugin(pluginLibrary);
}
//---------------------------------------------------------------------------
// 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;
}
// ***************************************************************
void HalExpansionPortClass::bit_Set(ePca9698Bits gpio ) {
unsigned byte = gpio / 8;
unsigned bit = gpio % 8;
#ifdef PORTS_DEBUG
if (epbtTooFar <= gpio){
dbgOut1(eDbgAll_errEvt,'B',"HalTwiPca bitSet invalid ",gpio);
return;
}
#endif
portStateOutput[byte] |= (1 << bit);
}
/**********************************************
* \brief
*
*
* \return none
*/
result_t HalExpansionPortClass::writePcaPorts(uint32_t iRegister, uint8_t *pBuffer, uint32_t bufLength) {
uint32_t bufCnt=bufLength;
uint32_t breakOut_cnt=0;
result_t retResult=SUCCESS;
TWI_StartWrite(HW_ADDR_TWI_PCA9698,HW_PCA9698_TwiAddr, iRegister,HW_PCA9698_InternalAddrLen,*pBuffer);
pBuffer++;
bufCnt--;
while(bufCnt >0) {
//if no NACK and Byte sent, then transmit next one
if (TWI_SR_NACK & TWI_GetStatus(HW_ADDR_TWI_PCA9698)) {
dbgOut1(eDbgAll_errEvt,'B',"HalTwiPca Unexpected NACK ",bufCnt);
retResult=FAIL;
break;
}
if (!TWI_ByteSent(HW_ADDR_TWI_PCA9698)) {
if (90000 < ++breakOut_cnt) {
dbgOut1(eDbgAll_errEvt,'B',"HalTwiPca TWI_SR_TXRDY exceeded ",bufCnt);
retResult=FAIL;
break; //Out while
}
continue;
}
breakOut_cnt = 0;
TWI_WriteByte(HW_ADDR_TWI_PCA9698,*pBuffer);
pBuffer++;
bufCnt--;
}
TWI_Stop(HW_ADDR_TWI_PCA9698);
while (!TWI_TransferComplete(HW_ADDR_TWI_PCA9698)) {
if (90000 < ++breakOut_cnt) {
dbgOut(eDbgAll_errEvt,'B',"HalTwiPca TWI_SR_TXCOMP exceeded ");
break; //Out while
}
}
return retResult;
}//portInit
nsPluginThread::nsPluginThread(DWORD aP1) : CThread(),
mP1(aP1),
mP2(0),
mP3(0),
mP4(0),
mP5(0),
mP6(0),
mP7(0)
{
dbgOut1("nsPluginThread::nsPluginThread");
open(this);
}
//------------------------------------------------------------------------------------
// 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);
}
//------------------------------------------------------------------------------------
// NPP_WriteReady:
//------------------------------------------------------------------------------------
int32_t NP_LOADDS
NPP_WriteReady(NPP pInstance, NPStream *stream)
{
dbgOut1("NPP_WriteReady");
if(pInstance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
CPlugin * pPlugin = (CPlugin *)pInstance->pdata;
assert(pPlugin != NULL);
// We don't want any data, kill the stream
NPN_DestroyStream(pInstance, stream, NPRES_DONE);
return -1L; // don't accept any bytes in NPP_Write()
}
//---------------------------------------------------------------------------
// 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;
}
CPlugin::~CPlugin()
{
dbgOut1("CPlugin::~CPlugin()");
if(m_pNPMIMEType != NULL)
{
delete [] m_pNPMIMEType;
m_pNPMIMEType = NULL;
}
if(m_szPageURL != NULL)
{
delete [] m_szPageURL;
m_szPageURL = NULL;
}
if(m_szFileURL != NULL)
{
delete [] m_szFileURL;
m_szFileURL = NULL;
}
if(m_szFileExtension != NULL)
{
delete [] m_szFileExtension;
m_szFileExtension = NULL;
}
if(m_szURLString != NULL)
{
delete [] m_szURLString;
m_szURLString = NULL;
}
if(m_hIcon != NULL)
{
DestroyIcon(m_hIcon);
m_hIcon = NULL;
}
if(m_szCommandMessage != NULL)
{
delete [] m_szCommandMessage;
m_szCommandMessage = NULL;
}
}
//------------------------------------------------------------------------------------
// 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 CPlugin::shut()
{
dbgOut1("CPlugin::shut()");
if(m_hWndDialog != NULL)
{
DestroyWindow(m_hWndDialog);
m_hWndDialog = NULL;
}
if(m_hWnd != NULL)
{
DestroyWindow(m_hWnd);
m_hWnd = NULL;
}
// we should release the service manager
NS_IF_RELEASE(gServiceManager);
gServiceManager = NULL;
}
NPError WINAPI NP_Initialize(NPNetscapeFuncs* aNetscapeFuncs)
{
dbgOut1("wrapper: NP_Initialize");
if(aNetscapeFuncs == NULL)
return NPERR_INVALID_FUNCTABLE_ERROR;
if(HIBYTE(aNetscapeFuncs->version) > NP_VERSION_MAJOR)
return NPERR_INCOMPATIBLE_VERSION_ERROR;
if(aNetscapeFuncs->size < sizeof NPNetscapeFuncs)
return NPERR_INVALID_FUNCTABLE_ERROR;
NPNFuncs.size = aNetscapeFuncs->size;
NPNFuncs.version = aNetscapeFuncs->version;
NPNFuncs.geturlnotify = aNetscapeFuncs->geturlnotify;
NPNFuncs.geturl = aNetscapeFuncs->geturl;
NPNFuncs.posturlnotify = aNetscapeFuncs->posturlnotify;
NPNFuncs.posturl = aNetscapeFuncs->posturl;
NPNFuncs.requestread = aNetscapeFuncs->requestread;
NPNFuncs.newstream = aNetscapeFuncs->newstream;
NPNFuncs.write = aNetscapeFuncs->write;
NPNFuncs.destroystream = aNetscapeFuncs->destroystream;
NPNFuncs.status = aNetscapeFuncs->status;
NPNFuncs.uagent = aNetscapeFuncs->uagent;
NPNFuncs.memalloc = aNetscapeFuncs->memalloc;
NPNFuncs.memfree = aNetscapeFuncs->memfree;
NPNFuncs.memflush = aNetscapeFuncs->memflush;
NPNFuncs.reloadplugins = aNetscapeFuncs->reloadplugins;
NPNFuncs.getJavaEnv = aNetscapeFuncs->getJavaEnv;
NPNFuncs.getJavaPeer = aNetscapeFuncs->getJavaPeer;
NPNFuncs.getvalue = aNetscapeFuncs->getvalue;
NPNFuncs.setvalue = aNetscapeFuncs->setvalue;
NPNFuncs.invalidaterect = aNetscapeFuncs->invalidaterect;
NPNFuncs.invalidateregion = aNetscapeFuncs->invalidateregion;
NPNFuncs.forceredraw = aNetscapeFuncs->forceredraw;
return NPERR_NO_ERROR;
}
NPError WINAPI NP_Shutdown()
{
dbgOut1("wrapper:NP_Shutdown");
return NPERR_NO_ERROR;
}
BOOL CPlugin::init(HWND hWndParent)
{
dbgOut1("CPlugin::init()");
nsISupports * sm = NULL;
nsIPrefBranch * prefBranch = NULL;
PRBool bSendUrls = PR_FALSE; // default to false if problem getting pref
// note that Mozilla will add reference, so do not forget to release
NPN_GetValue(NULL, NPNVserviceManager, &sm);
// do a QI on the service manager we get back to ensure it's the one we are expecting
if(sm) {
sm->QueryInterface(NS_GET_IID(nsIServiceManager), (void**)&gServiceManager);
NS_RELEASE(sm);
}
if (gServiceManager) {
// get service using its contract id and use it to allocate the memory
gServiceManager->GetServiceByContractID(NS_PREFSERVICE_CONTRACTID,
NS_GET_IID(nsIPrefBranch),
(void **)&prefBranch);
if(prefBranch) {
prefBranch->GetBoolPref("application.use_ns_plugin_finder", &bSendUrls);
NS_RELEASE(prefBranch);
}
}
m_bSmartUpdate = bSendUrls;
if(!m_bHidden)
{
assert(IsWindow(hWndParent));
if(IsWindow(hWndParent))
m_hWndParent = hWndParent;
RECT rcParent;
GetClientRect(m_hWndParent, &rcParent);
CreateWindow(szNullPluginWindowClassName,
"NULL Plugin",
WS_CHILD,
0,0, rcParent.right, rcParent.bottom,
m_hWndParent,
(HMENU)NULL,
m_hInst,
(LPVOID)this);
assert(m_hWnd != NULL);
if((m_hWnd == NULL) || (!IsWindow(m_hWnd)))
return FALSE;
UpdateWindow(m_hWnd);
ShowWindow(m_hWnd, SW_SHOW);
}
if(IsNewMimeType((LPSTR)m_pNPMIMEType) || m_bHidden)
showGetPluginDialog();
return TRUE;
}
nsPluginThread::~nsPluginThread()
{
dbgOut1("nsPluginThread::~nsPluginThread");
close(this);
}
//*******************
// NP API handles
//*******************
void CPlugin::resize()
{
dbgOut1("CPlugin::resize()");
}
//------------------------------------------------------------------------------------
// NPP_StreamAsFile:
//------------------------------------------------------------------------------------
void NP_LOADDS
NPP_StreamAsFile(NPP instance, NPStream *stream, const char* fname)
{
dbgOut1("NPP_StreamAsFile");
}
CPlugin::CPlugin(HINSTANCE hInst,
NPP pNPInstance,
WORD wMode,
NPMIMEType pluginType,
LPSTR szPageURL,
LPSTR szFileURL,
LPSTR szFileExtension,
BOOL bHidden) :
m_pNPInstance(pNPInstance),
m_wMode(wMode),
m_hInst(hInst),
m_hWnd(NULL),
m_hWndParent(NULL),
m_hWndDialog(NULL),
m_hIcon(NULL),
m_pNPMIMEType(NULL),
m_szPageURL(NULL),
m_szFileURL(NULL),
m_szFileExtension(NULL),
m_bOnline(TRUE),
m_bJavaScript(TRUE),
m_bSmartUpdate(TRUE),
m_szURLString(NULL),
m_szCommandMessage(NULL),
m_bWaitingStreamFromPFS(FALSE),
m_PFSStream(NULL),
m_bHidden(bHidden)
{
dbgOut1("CPlugin::CPlugin()");
assert(m_hInst != NULL);
assert(m_pNPInstance != NULL);
if(pluginType && *pluginType)
{
m_pNPMIMEType = (NPMIMEType)new char[lstrlen((LPSTR)pluginType) + 1];
if(m_pNPMIMEType != NULL)
lstrcpy((LPSTR)m_pNPMIMEType, pluginType);
}
if(szPageURL && *szPageURL)
{
m_szPageURL = new char[lstrlen(szPageURL) + 1];
if(m_szPageURL != NULL)
lstrcpy(m_szPageURL, szPageURL);
}
if(szFileURL && *szFileURL)
{
m_szFileURL = new char[lstrlen(szFileURL) + 1];
if(m_szFileURL != NULL)
lstrcpy(m_szFileURL, szFileURL);
}
if(szFileExtension && *szFileExtension)
{
m_szFileExtension = new char[lstrlen(szFileExtension) + 1];
if(m_szFileExtension != NULL)
lstrcpy(m_szFileExtension, szFileExtension);
}
m_hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_PLUGICON));
char szString[1024] = {'\0'};
LoadString(m_hInst, IDS_CLICK_TO_GET, szString, sizeof(szString));
if(*szString)
{
m_szCommandMessage = new char[lstrlen(szString) + 1];
if(m_szCommandMessage != NULL)
lstrcpy(m_szCommandMessage, szString);
}
}
