VError XMacFileSystemNotification::StartWatchingForChanges( const VFolder &inFolder, VFileSystemNotifier::EventKind inKindFilter, VFileSystemNotifier::IEventHandler *inHandler, sLONG inLatency )
{
// We need to get the folder's path into an array for us to pass along to the OS call.
VString posixPathString;
inFolder.GetPath( posixPathString, FPS_POSIX);
VStringConvertBuffer buffer( posixPathString, VTC_UTF_8);
std::string posixPath( buffer.GetCPointer());
CFStringRef pathRef = posixPathString.MAC_RetainCFStringCopy();
CFArrayRef pathArray = CFArrayCreate( NULL, (const void **)&pathRef, 1, NULL );
FSEventStreamContext context = { 0 };
// The latency the user passed us is expressed in milliseconds, but the OS call requires the latency to be
// expressed in seconds.
CFTimeInterval latency = (inLatency / 1000.0);
// Now we can make our change data object
XMacChangeData *data = new XMacChangeData( inFolder.GetPath(), posixPath, inKindFilter, VTask::GetCurrent(), inHandler, this);
context.info = data;
data->fStreamRef = FSEventStreamCreate( NULL, &FSEventCallback, &context, pathArray, kFSEventStreamEventIdSinceNow, latency, kFSEventStreamCreateFlagNone );
if (data->fStreamRef == NULL)
{
CFRelease( pathArray );
CFRelease( pathRef );
ReleaseRefCountable( &data);
return MAKE_NATIVE_VERROR( errno );
}
// We also need to take an initial snapshot of the directory for us to compare again
CreateDirectorySnapshot( posixPath, data->fSnapshot, true );
// Now we can add the data object we just made to our list
fOwner->PushChangeData( data);
// Next, we can schedule this to run on the main event loop
FSEventStreamScheduleWithRunLoop( data->fStreamRef, CFRunLoopGetMain(), kCFRunLoopDefaultMode );
CFRelease( pathArray );
CFRelease( pathRef );
// Now that we've scheduled the stream to run on a helper thread, all that is left is to
// start executing the stream
VError err;
if (FSEventStreamStart( data->fStreamRef ))
{
err = VE_OK;
}
else
{
err = MAKE_NATIVE_VERROR( errno );
}
ReleaseRefCountable( &data);
return err;
}
VError VProjectItemFolder::_MoveTo(const VFolder& srcFolder, VFolder& destFolder)
{
VError err = VE_OK;
if (!destFolder.Exists())
err = destFolder.CreateRecursive();
else
err = VE_UNKNOWN_ERROR; // TO DO ce n'est pas vrai : mais c'est pour le moment : 011008
// que faire : ecraser, fusionner, on attends les specs !
if (err == VE_OK)
{
for (VFolderIterator it_folder(&srcFolder, FI_WANT_FOLDERS | FI_WANT_INVISIBLES); it_folder.IsValid() && err == VE_OK; ++it_folder)
{
VFolder srcNewFolder(it_folder.Current()->GetPath());
VString srcNewFolderName;
srcNewFolder.GetName(srcNewFolderName);
VString destNewFolderPath;
destFolder.GetPath(destNewFolderPath);
destNewFolderPath += srcNewFolderName;
destNewFolderPath += FOLDER_SEPARATOR;
VFolder destNewFolder(destNewFolderPath);
err = _MoveTo(srcNewFolder, destNewFolder);
}
for (VFileIterator it_file(&srcFolder, FI_WANT_FILES | FI_WANT_INVISIBLES); it_file.IsValid() && err == VE_OK; ++it_file)
{
VFile srcNewFile(it_file.Current()->GetPath());
VString srcNewFileName;
srcNewFile.GetName(srcNewFileName);
VString destNewFilePath;
destFolder.GetPath(destNewFilePath);
destNewFilePath += srcNewFileName;
VFile destNewFile(destNewFilePath);
VProjectItemFile projectItemFile;
VURL srcURL = VURL(srcNewFile.GetPath());
VURL destURL = VURL(destNewFile.GetPath());
projectItemFile.MoveTo(srcURL, destURL);
}
}
if (err == VE_OK)
{
err = srcFolder.Delete(true);
}
return err;
}
VError XWinFolder::Move( const VFolder& inNewParent, VFolder** outFolder ) const
{
XBOX::VString name;
VFilePath newPath( inNewParent.GetPath() );
DWORD winErr;
if (newPath.IsValid())
{
VString name;
fOwner->GetName(name);
newPath.ToSubFolder(name);
XWinFullPath oldWinPath( fOwner->GetPath() );
XWinFullPath newWinPath( newPath );
winErr = ::MoveFileW( oldWinPath, newWinPath) ? 0 : ::GetLastError();
}
else
{
winErr = ERROR_INVALID_NAME;
}
if (outFolder)
{
*outFolder = (winErr == 0) ? new VFolder( newPath) : NULL;
}
return MAKE_NATIVE_VERROR( winErr);
}
VFolder::VFolder( const VFolder& inParentFolder, const VString& inFolderName)
{
fPath = inParentFolder.GetPath();
xbox_assert( fPath.IsFolder());
fPath.ToSubFolder( inFolderName);
xbox_assert( fPath.IsFolder());
fFolder.Init( this);
}
VError VFolder::CopyTo( const VFolder& inDestinationFolder, VFolder **outFolder, FileCopyOptions inOptions) const
{
VError err = VE_OK;
VFolder *folder = NULL;
if (IsSameFolder( &inDestinationFolder) || inDestinationFolder.GetPath().IsChildOf( GetPath()))
{
StThrowFileError errThrow( this, VE_CANNOT_COPY_ON_ITSELF);
errThrow->SetString( "destination", inDestinationFolder.GetPath().GetPath());
err = errThrow.GetError();
}
else
{
VString name;
GetName( name);
folder = new VFolder( inDestinationFolder, name);
if (folder != NULL)
{
if ( ( (inOptions & FCP_Overwrite) != 0) && folder->Exists() )
err = folder->Delete( true);
if (err == VE_OK)
err = CopyContentsTo( *folder, inOptions);
}
else
{
err = VE_MEMORY_FULL;
}
}
if (outFolder != NULL)
{
*outFolder = folder;
folder = NULL;
}
ReleaseRefCountable( &folder);
return err;
}
VError XWinFileSystemNotification::StartWatchingForChanges( const VFolder &inFolder, VFileSystemNotifier::EventKind inKindFilter, VFileSystemNotifier::IEventHandler *inHandler, sLONG inLatency )
{
VString path;
inFolder.GetPath( path );
VError err = VE_OK;
// Now that we know we need to care about this folder, let's see if we can create an entry for it. First,
// we will try to open a handle to the folder.
HANDLE hFolder = ::CreateFileW( path.GetCPointer(), FILE_LIST_DIRECTORY | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL );
if (hFolder == INVALID_HANDLE_VALUE)
{
// We were unable to open the folder, so we need to bail out
return MAKE_NATIVE_VERROR( ::GetLastError() );
}
// launch our task if not already there
LaunchTaskIfNecessary();
// Now that we've opened the folder handle, we can add an entry to our watch list
XWinChangeData *data = new XWinChangeData( inFolder.GetPath(), inKindFilter, VTask::GetCurrent(), inHandler, this);
data->fFolderHandle = hFolder;
data->fLatency = inLatency;
data->fOverlapped.hEvent = ::CreateEvent( NULL, true, false, NULL );
data->fTimer = NULL;
if (inLatency)
data->fTimer = ::CreateWaitableTimer( NULL, FALSE, NULL );
// Add the new data to our list of things to watch for
fOwner->PushChangeData( data );
WatchForChanges( data );
ReleaseRefCountable( &data);
return VE_OK;
}
VError VFolder::CopyContentsTo( const VFolder& inDestinationFolder, FileCopyOptions inOptions) const
{
VError err = VE_OK;
if (!inDestinationFolder.Exists())
{
// this easy case should be handled by system implementation
err = inDestinationFolder.Create();
}
else if (IsSameFolder( &inDestinationFolder) || inDestinationFolder.GetPath().IsChildOf( GetPath()))
{
StThrowFileError errThrow( this, VE_CANNOT_COPY_ON_ITSELF);
errThrow->SetString( "destination", inDestinationFolder.GetPath().GetPath());
err = errThrow.GetError();
}
if (err == VE_OK)
{
bool ok = true;
for( VFolderIterator folderIterator( this, FI_WANT_FOLDERS | FI_WANT_INVISIBLES) ; folderIterator.IsValid() && ok ; ++folderIterator)
{
VError err2 = folderIterator->CopyTo( inDestinationFolder, NULL, inOptions);
if (err == VE_OK)
err = err2;
ok = (err == VE_OK) | ((inOptions & FCP_ContinueOnError) != 0);
}
for( VFileIterator fileIterator( this, FI_WANT_FILES | FI_WANT_INVISIBLES) ; fileIterator.IsValid() && ok ; ++fileIterator)
{
VError err2 = fileIterator->CopyTo( inDestinationFolder, NULL, inOptions);
if (err == VE_OK)
err = err2;
ok = (err == VE_OK) | ((inOptions & FCP_ContinueOnError) != 0);
}
}
return err;
}
XBOX::VError VProjectItemFolder::Rename( const XBOX::VString& inNewName)
{
if (fOwner == NULL)
return VE_FOLDER_CANNOT_RENAME;
VFilePath path;
if (!fOwner->GetFilePath( path))
return VE_FOLDER_CANNOT_RENAME;
VFolder *newFolder = NULL;
VFolder folder( path);
VError err = folder.Rename( inNewName, &newFolder);
if (err == VE_OK && newFolder != NULL)
{
VString folderName;
newFolder->GetName( folderName);
fOwner->SetName( folderName); // sc 26/09/2011, WAK0073011
fOwner->SetDisplayName( folderName);
if (fOwner->HasRelativePath())
{
folderName += FOLDER_SEPARATOR;
fOwner->SetRelativePath( folderName);
}
else
{
VFilePath path;
newFolder->GetPath( path);
fOwner->SetURL( VURL( path));
}
}
if (err != VE_OK)
err = VE_FOLDER_CANNOT_RENAME;
return err;
}
VFolder::VFolder( const VFolder& inSource)
{
fPath = inSource.GetPath();
xbox_assert( fPath.IsFolder());
fFolder.Init( this);
}
VError VRIAServerSolution::_Open( VSolution* inDesignSolution, VRIAServerSolutionOpeningParameters *inOpeningParameters)
{
if (fState.opened)
return VE_OK;
VError err = VE_OK;
if (!testAssert(fDesignSolution == NULL))
err = VE_UNKNOWN_ERROR;
if (err == VE_OK && inDesignSolution == NULL)
err = ThrowError( VE_RIA_INVALID_DESIGN_SOLUTION);
if (err == VE_OK)
{
fDesignSolution = inDesignSolution;
fDesignSolution->GetName( fName);
CopyRefCountable( &fOpeningParameters, inOpeningParameters);
if (fOpeningParameters == NULL)
{
fOpeningParameters = new VRIAServerSolutionOpeningParameters();
if (fOpeningParameters == NULL)
err = ThrowError( VE_MEMORY_FULL);
}
if (err == VE_OK)
fState.inMaintenance = fOpeningParameters->GetOpeningMode() == eSOM_FOR_MAINTENANCE;
if (err == VE_OK && !fState.inMaintenance)
{
VSize nNameLength = fName. GetLength ( ) * 2 + 1;
char* szchName = new char [ nNameLength ];
fName. ToCString ( szchName, nNameLength );
fprintf ( stdout, "Publishing solution \"%s\"\n", szchName );
delete [ ] szchName;
}
if (err == VE_OK && !fState.inMaintenance)
{
const VFolder * vfRoot = RetainFolder ( );
if ( vfRoot != 0 )
{
VJSGlobalContext::SetSourcesRoot ( *vfRoot );
vfRoot-> Release ( );
VJSGlobalContext::AllowDebuggerLaunch ( );
}
}
fLoggerID = L"com.wakanda-software." + fName;
if (err == VE_OK && !fState.inMaintenance)
{
// Create a messages logger
VFolder *logFolder = RetainLogFolder( true);
if (logFolder != NULL)
{
fLogger = new VLog4jMsgFileLogger( *logFolder, fName + L"_log");
if (fLogger == NULL)
{
err = ThrowError( VE_MEMORY_FULL);
}
else
{
VRIAServerApplication::Get()->SetLogger( fLogger);
fLogger->Start();
}
logFolder->Release();
}
else
{
err = ThrowError( VE_RIA_LOG_FOLDER_NOT_FOUND);
}
}
StUseLogger logger;
if (err == VE_OK && !fState.inMaintenance)
{
// Create a log file reader
fLogReader = new VLog4jMsgFileReader();
if (fLogReader == NULL)
err = ThrowError( VE_MEMORY_FULL);
else
fLogger->AttachReader( fLogReader);
}
if (err == VE_OK || fState.inMaintenance)
{
StErrorContextInstaller errContext;
VMicrosecondsCounter usCounter;
usCounter.Start();
logger.Log( fLoggerID, eL4JML_Information, L"Opening the solution");
if (err == VE_OK && !fState.inMaintenance)
{
fJSRuntimeDelegate = new VRIAServerSolutionJSRuntimeDelegate( this);
if (fJSRuntimeDelegate == NULL)
err = ThrowError( VE_MEMORY_FULL);
}
if (err == VE_OK && !fState.inMaintenance)
{
fJSContextPool = VRIAServerApplication::Get()->GetJSContextMgr()->CreateJSContextPool( err, this);
}
if (err == VE_OK || fState.inMaintenance)
{
// Load all available settings files
err = _LoadFileSettings();
if (err != VE_OK)
err = ThrowError( VE_RIA_CANNOT_LOAD_SETTINGS_FILES);
}
if (err == VE_OK || fState.inMaintenance)
{
// Load the database settings
err = _LoadDatabaseSettings();
if (err != VE_OK)
err = ThrowError( VE_RIA_CANNOT_LOAD_DATABASE_SETTINGS);
}
if (err == VE_OK || fState.inMaintenance)
{
// Load users and groups directory
fUAGDirectory = _OpenUAGDirectory( err);
if (err != VE_OK)
err = ThrowError( VE_RIA_CANNOT_LOAD_UAG_DIRECTORY);
}
if (err == VE_OK || fState.inMaintenance)
{
// Build the ServerAdmin project file path
VFilePath serverAdminProjectPath;
VFolder *folder = VRIAServerApplication::Get()->RetainApplicationResourcesFolder();
if (folder != NULL)
{
folder->GetPath( serverAdminProjectPath);
serverAdminProjectPath.ToSubFolder( L"Default Solution");
serverAdminProjectPath.ToSubFolder( L"Admin"); // sc 18/02/2011 "ServerAdmin" become "Admin"
serverAdminProjectPath.SetFileName( L"ServerAdmin", false);
serverAdminProjectPath.SetExtension( RIAFileKind::kProjectFileExtension);
}
ReleaseRefCountable( &folder);
// Opening the applications
if (fApplicationsMutex.Lock())
{
// Note: the ServerAdmin project may be the project of the default solution
// or the ServerAdmin project added to a solution which has none admin project.
bool hasAdmin = false;
VProject *serverAdminProject = fDesignSolution->GetProjectFromFilePathOfProjectFile( serverAdminProjectPath);
bool ignoreProjectOpeningErrors = !fSettings.GetStopIfProjectFails();
fGarbageCollect = fSettings.GetGarbageCollect();
VectorOfProjects designProjects;
fDesignSolution->GetVectorOfProjects( designProjects);
for (VectorOfProjects::iterator iter = designProjects.begin() ; iter != designProjects.end() && (err == VE_OK || fState.inMaintenance) ; ++iter)
{
if (*iter != NULL)
{
VRIAServerProject *application = NULL;
// Create opening parameters
VRIAServerProjectOpeningParameters *projectOpeningParams = new VRIAServerProjectOpeningParameters();
if (projectOpeningParams != NULL)
{
projectOpeningParams->SetOpeningMode( fState.inMaintenance ? ePOM_FOR_MAINTENANCE : ePOM_FOR_RUNNING);
sLONG defaultAdminPort = 0;
if (*iter == serverAdminProject && fOpeningParameters->GetCustomAdministratorHttpPort( defaultAdminPort))
projectOpeningParams->SetCustomHttpPort( defaultAdminPort);
// for Default solution, pass the WebAdmin opening parameters
application = VRIAServerProject::OpenProject( err, this, *iter, projectOpeningParams);
if ((application != NULL) && (err == VE_OK || fState.inMaintenance))
{
VUUID uuid;
xbox_assert(application->GetUUID( uuid));
fApplicationsCollection.push_back( VRefPtr<VRIAServerProject>(application));
fApplicationsMap[uuid] = VRefPtr<VRIAServerProject>(application);
hasAdmin |= application->IsAdministrator();
if (!fState.inMaintenance)
{
VString vstrHostName;
VString vstrIP;
sLONG nPort = 0;
VString vstrPattern;
VString vstrPublishName;
VError vErrorS = application-> GetPublicationSettings ( vstrHostName, vstrIP, nPort, vstrPattern, vstrPublishName );
xbox_assert ( vErrorS == VE_OK );
vstrPublishName. Clear ( );
application-> GetName ( vstrPublishName );
VString vstrMessage;
vstrMessage. AppendCString ( "\tProject \"" );
vstrMessage. AppendString ( vstrPublishName );
vstrMessage. AppendCString ( "\" published at " );
vstrMessage. AppendString ( vstrIP );
vstrMessage. AppendCString ( " on port " );
vstrMessage. AppendLong ( nPort );
vstrMessage. AppendCString ( "\n" );
VSize nNameLength = vstrMessage. GetLength ( ) * 2 + 1;
char* szchName = new char [ nNameLength ];
vstrMessage. ToCString ( szchName, nNameLength );
fprintf ( stdout, szchName );
delete [ ] szchName;
}
}
ReleaseRefCountable( &projectOpeningParams);
}
else
{
err = ThrowError( VE_MEMORY_FULL);
}
if (err != VE_OK)
{
VString name;
(*iter)->GetName( name);
VErrorBase *errBase = CreateErrorBase( VE_RIA_CANNOT_OPEN_PROJECT, &name, NULL);
logger.LogMessageFromErrorBase( fLoggerID, errBase);
ReleaseRefCountable( &errBase);
if (!fState.inMaintenance)
{
if (application != NULL)
application->Close();
if (ignoreProjectOpeningErrors)
err = VE_OK;
else
err = VE_RIA_CANNOT_OPEN_PROJECT;
}
}
ReleaseRefCountable( &application);
}
}
if (!hasAdmin && !fState.inMaintenance && (err == VE_OK))
{
VFile file( serverAdminProjectPath);
if (file.Exists())
{
VURL url( serverAdminProjectPath);
fDesignSolution->AddExistingProject( url, false);
VProject *designProject = fDesignSolution->GetProjectFromFilePathOfProjectFile( serverAdminProjectPath);
if (designProject != NULL)
{
VRIAServerProject *application = NULL;
// Create opening parameters
VRIAServerProjectOpeningParameters *projectOpeningParams = new VRIAServerProjectOpeningParameters();
if (projectOpeningParams != NULL)
{
projectOpeningParams->SetOpeningMode( ePOM_FOR_RUNNING);
sLONG defaultAdminPort = 0;
if (fOpeningParameters->GetCustomAdministratorHttpPort( defaultAdminPort))
projectOpeningParams->SetCustomHttpPort( defaultAdminPort);
application = VRIAServerProject::OpenProject( err, this, designProject, projectOpeningParams);
if (application != NULL && err == VE_OK)
{
VUUID uuid;
xbox_assert(application->GetUUID( uuid));
fApplicationsCollection.push_back( VRefPtr<VRIAServerProject>(application));
fApplicationsMap[uuid] = VRefPtr<VRIAServerProject>(application);
}
ReleaseRefCountable( &projectOpeningParams);
}
else
{
err = ThrowError( VE_MEMORY_FULL);
}
if (err != VE_OK)
{
VString name;
designProject->GetName( name);
VErrorBase *errBase = CreateErrorBase( VE_RIA_CANNOT_OPEN_PROJECT, &name, NULL);
logger.LogMessageFromErrorBase( fLoggerID, errBase);
ReleaseRefCountable( &errBase);
if (application != NULL)
application->Close();
if (ignoreProjectOpeningErrors)
err = VE_OK;
else
err = VE_RIA_CANNOT_OPEN_PROJECT;
}
ReleaseRefCountable( &application);
}
}
}
fApplicationsMutex.Unlock();
}
}
logger.LogMessagesFromErrorContext( fLoggerID, errContext.GetContext());
if (err == VE_OK)
{
VString logMsg;
logMsg.Printf( "Solution opened (duration: %i ms)", usCounter.Stop()/1000);
logger.Log( fLoggerID, eL4JML_Information, logMsg);
}
}
}
fState.opened = true;
return err;
}
VValueSingle *JS4D::ValueToVValue( ContextRef inContext, ValueRef inValue, ValueRef *outException)
{
if (inValue == NULL)
return NULL;
VValueSingle *value;
JSType type = JSValueGetType( inContext, inValue);
switch( type)
{
case kJSTypeUndefined:
case kJSTypeNull:
value = NULL; //new VEmpty;
break;
case kJSTypeBoolean:
value = new VBoolean( JSValueToBoolean( inContext, inValue));
break;
case kJSTypeNumber:
value = new VReal( JSValueToNumber( inContext, inValue, outException));
break;
case kJSTypeString:
{
JSStringRef jsString = JSValueToStringCopy( inContext, inValue, outException);
if (jsString != NULL)
{
VString *s = new VString;
size_t length = JSStringGetLength( jsString);
UniChar *p = (s != NULL) ? s->GetCPointerForWrite( length) : NULL;
if (p != NULL)
{
::memcpy( p, JSStringGetCharactersPtr( jsString), length * sizeof( UniChar));
s->Validate( length);
value = s;
}
else
{
delete s;
value = NULL;
}
JSStringRelease( jsString);
}
else
{
value = NULL;
}
break;
}
case kJSTypeObject:
{
if (ValueIsInstanceOf( inContext, inValue, CVSTR( "Date"), outException))
{
VTime *time = new VTime;
if (time != NULL)
{
JSObjectRef dateObject = JSValueToObject( inContext, inValue, outException);
DateObjectToVTime( inContext, dateObject, *time, outException);
value = time;
}
else
{
value = NULL;
}
}
else if (JSValueIsObjectOfClass( inContext, inValue, VJSFolderIterator::Class()))
{
value = NULL;
JS4DFolderIterator* container = static_cast<JS4DFolderIterator*>(JSObjectGetPrivate( JSValueToObject( inContext, inValue, outException) ));
if (testAssert( container != NULL))
{
VFolder* folder = container->GetFolder();
if (folder != NULL)
{
VString *s = new VString;
if (s != NULL)
folder->GetPath( *s, FPS_POSIX);
value = s;
}
}
}
else if (JSValueIsObjectOfClass( inContext, inValue, VJSFileIterator::Class()))
{
value = NULL;
JS4DFileIterator* container = static_cast<JS4DFileIterator*>(JSObjectGetPrivate( JSValueToObject( inContext, inValue, outException) ));
if (testAssert( container != NULL))
{
VFile* file = container->GetFile();
if (file != NULL)
{
VString *s = new VString;
if (s != NULL)
file->GetPath( *s, FPS_POSIX);
value = s;
}
}
}
else if (JSValueIsObjectOfClass( inContext, inValue, VJSBlob::Class()))
{
// remember File inherits from Blob so one must check File before Blob
VJSBlob::PrivateDataType* blobValue = static_cast<VJSBlob::PrivateDataType*>(JSObjectGetPrivate( JSValueToObject( inContext, inValue, outException) ));
if (testAssert( blobValue != NULL))
{
VJSDataSlice *slice = blobValue->RetainDataSlice();
VBlobWithPtr *blob = new VBlobWithPtr;
if ( (blob != NULL) && (slice != NULL) && (slice->GetDataSize() > 0) )
{
if (blob->PutData( slice->GetDataPtr(), slice->GetDataSize()) != VE_OK)
{
delete blob;
blob = NULL;
}
}
value = blob;
ReleaseRefCountable( &slice);
}
else
{
value = NULL;
}
}
#if !VERSION_LINUX // Postponed Linux Implementation !
else if (JSValueIsObjectOfClass( inContext, inValue, VJSImage::Class()))
{
VJSImage::PrivateDataType* piccontainer = static_cast<VJSImage::PrivateDataType*>(JSObjectGetPrivate( JSValueToObject( inContext, inValue, outException) ));
if (testAssert( piccontainer != NULL))
{
VPicture *vpic = piccontainer->GetPict();
value = (vpic != NULL) ? new VPicture(*vpic) : NULL;
}
else
{
value = NULL;
}
}
#endif
else
{
value = NULL;
}
break;
}
default:
value = NULL;
break;
}
return value;
}
