TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-04 02:42:49 -04:00
Code Issues Packages Projects Releases Wiki Activity
panda3d/direct/src/plugin_activex/PPInstance.cpp
David Rose c06abc5887 fix some memory management issues
2009-09-16 19:00:11 +00:00

522 lines
17 KiB
C++
Raw Blame History

// Filename: PPInstance.cpp
// Created by: atrestman (14Sept09)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University. All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license. You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <windows.h>
#include <process.h>
#include "resource.h"
#include "PPInstance.h"
#include "P3DActiveXCtrl.h"
#include "PPBrowserObject.h"
#include "PPDownloadRequest.h"
#include "p3d_plugin_config.h"
#include "get_tinyxml.h"
#define P3D_CONTENTS_FILENAME "contents.xml"
#define P3D_DEFAULT_PLUGIN_FILENAME "p3d_plugin.dll"
static HMODULE s_hP3DPluginDll = NULL;
static int s_instanceCount = 0;
P3D_initialize_func *P3D_initialize;
P3D_finalize_func *P3D_finalize;
P3D_new_instance_func *P3D_new_instance;
P3D_instance_start_func *P3D_instance_start;
P3D_instance_finish_func *P3D_instance_finish;
P3D_instance_setup_window_func *P3D_instance_setup_window;
P3D_instance_get_request_func *P3D_instance_get_request;
P3D_check_request_func *P3D_check_request;
P3D_request_finish_func *P3D_request_finish;
P3D_instance_feed_url_stream_func *P3D_instance_feed_url_stream;
P3D_instance_set_browser_script_object_func *P3D_instance_set_browser_script_object;
P3D_instance_get_panda_script_object_func *P3D_instance_get_panda_script_object;
P3D_make_class_definition_func *P3D_make_class_definition;
P3D_new_undefined_object_func *P3D_new_undefined_object;
P3D_new_none_object_func *P3D_new_none_object;
P3D_new_bool_object_func *P3D_new_bool_object;
P3D_new_int_object_func *P3D_new_int_object;
P3D_new_float_object_func *P3D_new_float_object;
P3D_new_string_object_func *P3D_new_string_object;
void P3D_NofificationSync(P3D_instance *instance)
{
static bool handleRequestOnUIThread = true;
if ( instance )
{
CP3DActiveXCtrl* parent = static_cast<CP3DActiveXCtrl*>(instance->_user_data);
if ( parent )
{
if ( ::IsWindow( parent->m_hWnd ) )
{
::PostMessage( parent->m_hWnd, WM_PANDA_NOTIFICATION, 0, 0 );
}
else
{
nout << "Can handle P3D_Notification on UI thread. Controls window is invalid\n";
}
}
else
{
nout << "Can handle P3D_Notification on UI thread. Instance's user data is not a Control\n";
}
}
}
PPInstance::PPInstance( CP3DActiveXCtrl& parentCtrl ) :
m_parentCtrl( parentCtrl ), m_p3dInstance( NULL ), m_p3dObject( NULL ), m_handleRequestOnUIThread( true )
{
TCHAR tempFolderName[ MAX_PATH ];
DWORD pathLength = ::GetTempPath( MAX_PATH, tempFolderName );
m_logger.Open( std::string( tempFolderName ), std::string( P3D_DEFAULT_PLUGIN_LOG_FILENAME ) );
}
PPInstance::~PPInstance( )
{
if ( m_p3dInstance )
{
nout << this << ": Finishing P3D instance \n";
P3D_instance_finish( m_p3dInstance );
m_p3dInstance = NULL;
}
if ( m_p3dObject )
{
P3D_OBJECT_DECREF( m_p3dObject );
m_p3dObject = NULL;
}
UnloadPlugin();
}
int PPInstance::DownloadFile( const std::string& from, const std::string& to )
{
int error( 0 );
PPDownloadRequest p3dContentsDownloadRequest( *this, to );
PPDownloadCallback dcForContents( p3dContentsDownloadRequest );
nout << "Downloading " << from << " into " << to << "\n";
HRESULT hr = ::URLOpenStream( m_parentCtrl.GetControllingUnknown(), from.c_str(), 0, &dcForContents );
if ( FAILED( hr ) )
{
error = 1;
nout << "Error downloading " << from << " :" << hr << "\n";
}
return error;
}
int PPInstance::ReadContents( const std::string& contentsFilename, std::string& p3dDllFilename )
{
int error(1);
TiXmlDocument doc( contentsFilename.c_str( ) );
if ( doc.LoadFile( ) )
{
TiXmlElement *xcontents = doc.FirstChildElement( "contents" );
if ( xcontents != NULL )
{
TiXmlElement *xpackage = xcontents->FirstChildElement( "package" );
while ( xpackage != NULL )
{
const char *name = xpackage->Attribute( "name" );
if ( name != NULL && strcmp( name, "coreapi" ) == 0 )
{
const char *platform = xpackage->Attribute( "platform" );
if ( platform != NULL && !strcmp(platform, "win32") )
{
p3dDllFilename += xpackage->Attribute( "filename" );
error = 0;
break;
}
}
xpackage = xpackage->NextSiblingElement( "package" );
}
}
}
return error;
}
int PPInstance::DownloadP3DComponents( std::string& p3dDllFilename )
{
int error(0);
TCHAR tempFolderName[ MAX_PATH ];
DWORD pathLength = ::GetTempPath( MAX_PATH, tempFolderName );
std::string localContentsFileName( tempFolderName, pathLength );
localContentsFileName += P3D_CONTENTS_FILENAME;
std::string hostUrl( PANDA_PACKAGE_HOST_URL );
if (!hostUrl.empty() && hostUrl[hostUrl.size() - 1] != '/') {
hostUrl += '/';
}
std::string remoteContentsFilename( hostUrl );
remoteContentsFilename += P3D_CONTENTS_FILENAME;
error = DownloadFile( remoteContentsFilename, localContentsFileName );
if ( !error )
{
std::string p3dRemoteModuleFileName( hostUrl );
error = ReadContents( localContentsFileName, p3dRemoteModuleFileName );
if ( !error )
{
std::string p3dLocalModuleFileName( tempFolderName, pathLength );
p3dLocalModuleFileName += P3D_DEFAULT_PLUGIN_FILENAME;
// Check for existance
if ( ::GetFileAttributes( p3dLocalModuleFileName.c_str( ) ) == INVALID_FILE_ATTRIBUTES )
{
error = DownloadFile( p3dRemoteModuleFileName, p3dLocalModuleFileName );
}
if ( !error )
{
p3dDllFilename = p3dLocalModuleFileName;
}
}
}
return error;
}
int PPInstance::LoadPlugin( const std::string& dllFilename )
{
s_instanceCount += 1;
int error(0);
if ( !s_hP3DPluginDll )
{
std::string filename( dllFilename );
if ( filename.empty() )
{
// Look for the plugin along the path.
filename = P3D_DEFAULT_PLUGIN_FILENAME;
filename += ".dll";
}
nout << "Loading " << filename << "\n";
s_hP3DPluginDll = LoadLibrary( filename.c_str() );
nout << "got " << s_hP3DPluginDll << "\n";
if ( s_hP3DPluginDll == NULL )
{
// Couldn't load the DLL.
nout << "Error loading " << filename << " :" << GetLastError() << "\n";
return false;
}
char buffer[MAX_PATH];
if ( GetModuleFileName( s_hP3DPluginDll, buffer, MAX_PATH ) != 0 )
{
if ( GetLastError() != 0 )
{
filename = buffer;
}
}
// Now get all of the function pointers.
P3D_initialize = (P3D_initialize_func *)GetProcAddress(s_hP3DPluginDll, "P3D_initialize");
P3D_finalize = (P3D_finalize_func *)GetProcAddress(s_hP3DPluginDll, "P3D_finalize");
P3D_new_instance = (P3D_new_instance_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_instance");
P3D_instance_start = (P3D_instance_start_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_start");
P3D_instance_finish = (P3D_instance_finish_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_finish");
P3D_instance_setup_window = (P3D_instance_setup_window_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_setup_window");
P3D_instance_get_request = (P3D_instance_get_request_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_get_request");
P3D_check_request = (P3D_check_request_func *)GetProcAddress(s_hP3DPluginDll, "P3D_check_request");
P3D_request_finish = (P3D_request_finish_func *)GetProcAddress(s_hP3DPluginDll, "P3D_request_finish");
P3D_instance_feed_url_stream = (P3D_instance_feed_url_stream_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_feed_url_stream");
P3D_instance_set_browser_script_object = (P3D_instance_set_browser_script_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_set_browser_script_object");
P3D_instance_get_panda_script_object = (P3D_instance_get_panda_script_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_instance_get_panda_script_object");
P3D_make_class_definition = (P3D_make_class_definition_func *)GetProcAddress(s_hP3DPluginDll, "P3D_make_class_definition");
P3D_new_undefined_object = (P3D_new_undefined_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_undefined_object");
P3D_new_none_object = (P3D_new_none_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_none_object");
P3D_new_bool_object = (P3D_new_bool_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_bool_object");
P3D_new_int_object = (P3D_new_int_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_int_object");
P3D_new_float_object = (P3D_new_float_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_float_object");
P3D_new_string_object = (P3D_new_string_object_func *)GetProcAddress(s_hP3DPluginDll, "P3D_new_string_object");
// Ensure that all of the function pointers have been found.
if (P3D_initialize == NULL ||
P3D_finalize == NULL ||
P3D_new_instance == NULL ||
P3D_instance_finish == NULL ||
P3D_instance_get_request == NULL ||
P3D_check_request == NULL ||
P3D_request_finish == NULL ||
P3D_instance_get_panda_script_object == NULL ||
P3D_instance_set_browser_script_object == NULL ||
P3D_instance_feed_url_stream == NULL ||
P3D_make_class_definition == NULL ||
P3D_new_none_object == NULL ||
P3D_new_bool_object == NULL ||
P3D_new_int_object == NULL ||
P3D_new_float_object == NULL ||
P3D_new_string_object == NULL )
{
return ( error = 1 );
}
// Successfully loaded.
nout << "Initializing P3D P3D_API_VERSION=" << P3D_API_VERSION << "\n";
if ( !P3D_initialize( P3D_API_VERSION, "", "", true, "", "", "", false ) )
{
// Oops, failure to initialize.
nout << "Error initializing P3D: " << GetLastError() << "\n";
::FreeLibrary( s_hP3DPluginDll );
s_hP3DPluginDll = NULL;
return ( error = 1 );
}
}
return error ;
}
int PPInstance::UnloadPlugin()
{
int error( 0 );
assert( s_instanceCount > 0 );
s_instanceCount -= 1;
if ( s_instanceCount == 0 && s_hP3DPluginDll != NULL )
{
nout << "Finalizing P3D\n";
P3D_finalize();
nout << "Unloading P3D dll " << s_hP3DPluginDll << "\n";
if ( !::FreeLibrary( s_hP3DPluginDll ) )
{
nout << "Error unloading P3D dll :" << GetLastError << "\n";
error = 1;
}
else
{
s_hP3DPluginDll = NULL;
}
}
return error;
}
int PPInstance::Start( const std::string& p3dFilename )
{
m_eventStop.ResetEvent();
P3D_window_handle parent_window;
parent_window._hwnd = m_parentCtrl.m_hWnd;
RECT rect;
GetClientRect( m_parentCtrl.m_hWnd, &rect );
P3D_token* p3dTokens = new P3D_token[ m_parentCtrl.m_parameters.size() ];
for ( UINT i = 0; i < m_parentCtrl.m_parameters.size(); i++ )
{
std::pair< CString, CString > keyAndValue = m_parentCtrl.m_parameters[ i ];
p3dTokens[i]._keyword = strdup( m_parentCtrl.m_parameters[ i ].first );
p3dTokens[i]._value = strdup( m_parentCtrl.m_parameters[ i ].second );
}
nout << "Creating new P3D instance object \n";
m_p3dInstance = P3D_new_instance( &P3D_NofificationSync, p3dTokens, m_parentCtrl.m_parameters.size(), 0, NULL, (void*)&m_parentCtrl );
for ( UINT j = 0; j < m_parentCtrl.m_parameters.size(); j++ )
{
delete [] p3dTokens[j]._keyword;
delete [] p3dTokens[j]._value;
}
delete [] p3dTokens;
if ( !m_p3dInstance )
{
nout << "Error creating P3D instance: " << GetLastError() << "\n";
return 0;
}
CComPtr<IDispatch> pDispatch;
PPBrowserObject *pobj = new PPBrowserObject( &m_parentCtrl, pDispatch );
P3D_instance_set_browser_script_object( m_p3dInstance, pobj );
P3D_OBJECT_DECREF( pobj );
m_p3dObject = P3D_instance_get_panda_script_object( m_p3dInstance );
P3D_OBJECT_INCREF( m_p3dObject );
P3D_instance_setup_window( m_p3dInstance, P3D_WT_embedded, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, parent_window );
std::string p3dRemoteFilename( GetHostUrl() );
p3dRemoteFilename += p3dFilename;
nout << "Starting new P3D instance " << p3dRemoteFilename << "\n";
if ( !P3D_instance_start( m_p3dInstance, false, p3dRemoteFilename.c_str() ) )
{
nout << "Error starting P3D instance: " << GetLastError() << "\n";
}
return 1;
}
std::string PPInstance::GetHostUrl( )
{
CString hostingPageLocation = m_parentCtrl.m_hostingPageUrl.Left( m_parentCtrl.m_hostingPageUrl.ReverseFind( '/' ) );;
std::string p3dRemoteFilename( hostingPageLocation );
p3dRemoteFilename += "/";
return p3dRemoteFilename;
}
std::string PPInstance::GetP3DFilename( )
{
std::string p3dFilename;
for ( UINT i = 0; i < m_parentCtrl.m_parameters.size(); i++ )
{
std::pair< CString, CString > keyAndValue = m_parentCtrl.m_parameters[ i ];
if ( keyAndValue.first == "data" )
{
p3dFilename = keyAndValue.second;
}
}
return p3dFilename;
}
void PPInstance::HandleRequestLoop()
{
P3D_instance *p3d_inst = P3D_check_request(false);
while ( p3d_inst != NULL )
{
P3D_request *request = P3D_instance_get_request(p3d_inst);
if ( request != NULL )
{
CP3DActiveXCtrl* parent = ( CP3DActiveXCtrl* )(p3d_inst->_user_data);
if ( parent )
{
parent->m_instance.HandleRequest( request );
}
else
{
nout << "Error handling P3D request. Instance's user data is not a Control \n";
}
}
p3d_inst = P3D_check_request( false );
}
}
void PPInstance::HandleRequestGetUrl( void* data )
{
P3D_request *request = static_cast<P3D_request*>( data );
if ( !request )
{
return;
}
int unique_id = request->_request._get_url._unique_id;
const std::string &url = request->_request._get_url._url;
CP3DActiveXCtrl* parent = static_cast<CP3DActiveXCtrl*> ( request->_instance->_user_data );
if ( !parent )
{
return;
}
nout << "Handling P3D_RT_get_url request from " << url << "\n";
PPDownloadRequest p3dObjectDownloadRequest( parent->m_instance, request );
PPDownloadCallback bsc( p3dObjectDownloadRequest );
HRESULT hr = ::URLOpenStream( parent->GetControllingUnknown(), url.c_str(), 0, &bsc );
if ( FAILED( hr ) )
{
nout << "Error handling P3D_RT_get_url request" << " :" << hr << "\n";
return;
}
//inet_InternetSession inet(parent->m_pythonEmbed.m_threadData.m_parent);
//std::string outdata;
//if ( !inet.getURLMemory( url, outdata, request ) )
//{
// handled = false;
//}
P3D_instance_feed_url_stream(
request->_instance,
request->_request._get_url._unique_id,
P3D_RC_done,
0,
0,
(const void*)NULL,
0
);
P3D_request_finish( request, true );
}
void PPInstance::HandleRequest( P3D_request *request )
{
if ( !request )
{
return;
}
bool handled = false;
switch ( request->_request_type )
{
case P3D_RT_stop:
{
P3D_instance_finish( request->_instance );
handled = true;
break;
}
case P3D_RT_get_url:
{
if ( !m_handleRequestOnUIThread )
{
_beginthread( HandleRequestGetUrl, 0, request );
}
else
{
HandleRequestGetUrl( request );
}
handled = true;
return;
}
case P3D_RT_notify:
{
CString notification = request->_request._notify._message;
if ( notification == "ondownloadbegin" )
{
m_handleRequestOnUIThread = false;
}
else if ( notification == "ondownloadcomplete" )
{
m_handleRequestOnUIThread = true;
}
handled = true;
break;
}
default:
{
// Some request types are not handled.
break;
}
};
P3D_request_finish( request, handled );
}
Reference in New Issue View Git Blame Copy Permalink