bool vfeSession::StopRender(const string& reason) { if (m_Frontend->GetState() <= kReady) return true; if (reason.empty() == false) { AppendStatusMessage (reason); AppendErrorMessage (reason); } try { m_Frontend->Stop() ; } catch (pov_base::Exception& e) { if (e.codevalid() && e.code() == kNotNowErr) { Delay (100) ; return (m_Frontend->GetState() == kReady); } if (m_Frontend->GetState () > kReady) { Delay (100) ; return (m_Frontend->GetState () == kReady); } } return (true); }
// Start a render. Will set m_LastError and return vfeRenderOptionsNotSet // if you didn't call vfeSession::SetOptions() first. Otherwise will attempt // to start the render; if this fails vfeFailedToSendRenderStart is returned. // If the start attempt succeeds (note this is distinct from the start itself // actually succeeding - all that the lack of a vfeFailedToSendRenderStart // error means is that the start request was successfully sent to the backend) // then a stRenderStartup notification is sent and the state is changed to // kStarting. // // If the start attempt fails (signified by the receipt of a std::exception), // the exception code will, in the case of a pov_base::Exception, be extracted // and stored in m_LastError and returned; otherwise (not pov_base::Exception), // m_LastError is set to -1. In either case, a failed status is set (so that // vfeSession::Failed() will return true), and, if a fatal error message has // not already been queued, the text of the exception will be added to both // the status and error message queues. int vfeSession::StartRender() { if (m_OptionsSet == false) return (m_LastError = vfeRenderOptionsNotSet); if (m_RenderOptions.m_Options.Exist(kPOVAttrib_CreateIni)) { // we deliberately do this twice - once here and once in SetOptions POVMSUCS2String fn = m_RenderOptions.m_Options.TryGetUCS2String(kPOVAttrib_CreateIni, ""); if (fn.empty() == false) { vfeProcessRenderOptions options(this); POVMSObject obj = *m_RenderOptions.GetOptions(); if (options.WriteFile (UCS2toASCIIString(fn).c_str(), &obj) != kNoErr) return (m_LastError = vfeFailedToWriteINI); } } try { if (!m_Frontend->Start (m_RenderOptions.m_Options)) return (m_LastError = vfeFailedToSendRenderStart) ; } catch (std::exception& e) { if (dynamic_cast<pov_base::Exception *> (&e) != NULL) m_RenderErrorCode = dynamic_cast<pov_base::Exception *> (&e)->code() ; if (m_RenderErrorCode == 0) m_RenderErrorCode = -1 ; m_Failed = true ; if (m_HadErrorMessage == false) { AppendErrorMessage (e.what()) ; AppendStatusMessage (e.what()) ; } return (m_LastError = m_RenderErrorCode) ; } NotifyEvent(stRenderStartup); // set this now in case an error causes the frontend state to return to // kReady before we pick up kStarting in vfeSession::Process(). StateChanged(kStarting) ; return (m_LastError = vfeNoError) ; }
wxString CUtils::ConstructProjectStatus(CBSLProject& bslProject) { wxString strBuffer = wxEmptyString; wxString strBuffer2 = wxEmptyString; if (bslProject.IsInterfaceSuspensionEnabled()) { AppendStatusMessage(strBuffer, _("Project suspended by volunteer")); } if (bslProject.IsTaskAccumulationDisabled()) { AppendStatusMessage(strBuffer, _("Won't get new tasks")); } if (bslProject.GetSchedulerRPCPending()) { strBuffer2.Printf( _("Scheduler request pending, %s"), ConstructRPCReason(bslProject.GetSchedulerRPCPending()).c_str() ); AppendStatusMessage(strBuffer, strBuffer2); } if (bslProject.IsSchedulerRPCInProgress()) { AppendStatusMessage(strBuffer, _("Scheduler request in progress")); } if (bslProject.IsTricklePending()) { AppendStatusMessage(strBuffer, _("Trickle up message pending")); } if (bslProject.GetSchedulerRPCMinimumTime() > wxDateTime::Now()) { wxTimeSpan tsNextRPC(bslProject.GetSchedulerRPCMinimumTime() - wxDateTime::Now()); strBuffer2.Printf( _("Communication deferred %s"), tsNextRPC.Format().c_str() ); AppendStatusMessage(strBuffer, strBuffer2); } return strBuffer; }
// Sets the options to be used on the next render. Accepts a vfeRenderOptions // instance as its only parameter, and returns any one of a number of possible // error codes (and sets m_LastError), as documented below: // // vfeFailedToInitObject - this is an internal error // vfeFailedToSetMaxThreads - self-explanatory // vfeFailedToParseINI - an INI file specified could not be parsed // vfeFailedToSetSource - the source file specified could not be set // vfeFailedToParseCommand - a command-line option was invalid // vfeNoInputFile - no input file specified either directly or via INI // vfeRenderBlockSizeTooSmall - self-explanatory // vfeFailedToWriteINI - a request to write the render options to an INI file failed // vfeUnsupportedOptionCombination - unsupported option combination // // If vfeRenderOptions explicitly specifies a source file, it will override // any set via a parsed INI file. Furthermore, any source file set via a // command-line option overrides both of the above. // // Note that it is your responsibility to add any default INI files that should // be processed to the INI file list; neither SetOptions() nor any other part // of the VFE or POV-Ray code will do that for you. This includes non-platform // specific files such as a potential povray.ini in the CWD. int vfeSession::SetOptions (vfeRenderOptions& opts) { int err; UCS2 str [MAX_PATH]; POVMSObject obj; vfeProcessRenderOptions options(this); m_OutputToFileSet = false; m_UsingAlpha = false; m_RenderingAnimation = false; m_RealTimeRaytracing = false; m_ClocklessAnimation = false; m_RenderWidth = m_RenderHeight = 0; ClearOptions(); if ((err = POVMSObject_New (&obj, kPOVObjectClass_RenderOptions)) != kNoErr) return (m_LastError = vfeFailedToInitObject) ; if ((err = POVMSUtil_SetInt (&obj, kPOVAttrib_MaxRenderThreads, opts.m_ThreadCount)) != kNoErr) return (m_LastError = vfeFailedToSetMaxThreads) ; // we set this here for potential use by the IO permissions path checking code m_InputFilename = opts.m_SourceFile; // most likely povray.ini will be the first INI file processed here (as it's included by default) for (vector<UCS2String>::iterator i = opts.m_IniFiles.begin(); i != opts.m_IniFiles.end(); i++) { // we call TestAccessAllowed() here, even though ParseFile() will do it also, since if // access is denied, the reason will not be obvious (ParseFile() just returns kCannotOpenFileErr). if (!TestAccessAllowed (Path(*i), false)) return (m_LastError = vfeIORestrictionDeny); if ((err = options.ParseFile (UCS2toASCIIString(*i).c_str(), &obj)) != kNoErr) return (m_LastError = vfeFailedToParseINI) ; // we keep this up to date since the IO permissions feature will use the current input // filename to determine the path for default read/write permission in the scene dir. int n = sizeof (str) ; if ((err = POVMSUtil_GetUCS2String (&obj, kPOVAttrib_InputFile, str, &n)) == kNoErr) if (m_InputFilename != str) m_InputFilename = str; } // m_SourceFile overrides any source file set by the INI files if (opts.m_SourceFile.empty() == false) { m_InputFilename = opts.m_SourceFile; if ((err = POVMSUtil_SetUCS2String (&obj, kPOVAttrib_InputFile, opts.m_SourceFile.c_str())) != kNoErr) return (m_LastError = vfeFailedToSetSource); } // any source file set on the command-line overrides a source file set another way for (vector<string>::iterator i = opts.m_Commands.begin(); i != opts.m_Commands.end(); i++) { if ((err = options.ParseString (i->c_str(), &obj)) != kNoErr) return (m_LastError = vfeFailedToParseCommand) ; int n = sizeof (str) ; if ((err = POVMSUtil_GetUCS2String (&obj, kPOVAttrib_InputFile, str, &n)) == kNoErr) if (m_InputFilename != str) m_InputFilename = str; } int n = sizeof (str) ; if ((err = POVMSUtil_GetUCS2String (&obj, kPOVAttrib_InputFile, str, &n)) != kNoErr) return (m_LastError = vfeNoInputFile); m_InputFilename = str; POVMSUtil_GetInt (&obj, kPOVAttrib_Width, &m_RenderWidth) ; POVMSUtil_GetInt (&obj, kPOVAttrib_Height, &m_RenderHeight) ; std::list<Path> libpaths; POVMS_Object ropts (obj) ; if (ropts.Exist (kPOVAttrib_LibraryPath)) { POVMS_List pathlist; ropts.Get (kPOVAttrib_LibraryPath, pathlist) ; // we take the opportunity to remove any duplicates that are in the path list. // it's cleaner to do that here, rather than in the INI parser, since it's table- // driven and doesn't have an explicit function for adding library paths per se. // // we use the Path equivalence operator rather than a string compare since // using Path should handle platform-specific issues like case-sensitivity (or, // rather, lack thereof). note that at the time of writing, the Path class did // not yet implement case-insensitive comparisions. // // NB while it would of course be more efficient to sort the list so searches are // faster, we'd have to make a copy of it to do that, as we can't change the order // of existing entries (that would change the include path search order). it's not // common to have a lot of include paths, so we just use linear searches. for (int i = 1; i <= pathlist.GetListSize(); i++) { POVMS_Attribute lp; pathlist.GetNth(i, lp); Path path(lp.GetUCS2String()); if (find(libpaths.begin(), libpaths.end(), path) == libpaths.end()) libpaths.push_back(path); } } if (opts.m_LibraryPaths.empty() == false) { for (vector<UCS2String>::const_iterator i = opts.m_LibraryPaths.begin(); i != opts.m_LibraryPaths.end(); i++) { Path path(*i); if (find(libpaths.begin(), libpaths.end(), path) == libpaths.end()) libpaths.push_back(path); } } if (libpaths.empty() == false) { POVMS_List pathlist; for (list<Path>::iterator i = libpaths.begin(); i != libpaths.end(); i++) { POVMS_Attribute attr((*i)().c_str()); pathlist.Append(attr); } ropts.Set (kPOVAttrib_LibraryPath, pathlist) ; } if (ropts.TryGetBool(kPOVAttrib_RealTimeRaytracing, false) == true) ropts.SetBool(kPOVAttrib_OutputToFile, false); m_OutputToFileSet = ropts.TryGetBool(kPOVAttrib_OutputToFile, true); // this is a bit messy: Grayscale_Output or OutputAlpha may be specified // in an INI file or elsewhere prior to the output file type being set. // so we can't check to see if it is supported with that file type // until all options have been parsed. if (m_OutputToFileSet) { int oft = ropts.TryGetInt(kPOVAttrib_OutputFileType, DEFAULT_OUTPUT_FORMAT); bool has16BitGrayscale = false; bool hasAlpha = false; for (int i = 0; FileTypeTable[i].internalId != 0; i ++) { if (oft == FileTypeTable[i].internalId) { has16BitGrayscale = FileTypeTable[i].has16BitGrayscale; hasAlpha = FileTypeTable[i].hasAlpha; break; } } if (ropts.TryGetBool(kPOVAttrib_GrayscaleOutput, false) && !has16BitGrayscale) { AppendStatusMessage ("Grayscale output not currently supported with selected output file type."); AppendErrorMessage ("Grayscale output not currently supported with selected output file type.") ; return (m_LastError = vfeUnsupportedOptionCombination); } if (ropts.TryGetBool(kPOVAttrib_OutputAlpha, false) && !hasAlpha) { AppendWarningMessage ("Warning: Alpha channel output currently not (or not officially) supported with selected output file type.") ; } } if (ropts.TryGetInt(kPOVAttrib_RenderBlockSize, 32) < 4) return (m_LastError = vfeRenderBlockSizeTooSmall); if ((ropts.TryGetInt(kPOVAttrib_DisplayGammaType, DEFAULT_DISPLAY_GAMMA_TYPE) == kPOVList_GammaType_PowerLaw) && (ropts.TryGetFloat(kPOVAttrib_DisplayGamma, DEFAULT_DISPLAY_GAMMA) < 0.001f)) return (m_LastError = vfeDisplayGammaTooSmall); if ((ropts.TryGetInt(kPOVAttrib_FileGammaType, DEFAULT_FILE_GAMMA_TYPE) == kPOVList_GammaType_PowerLaw) && (ropts.TryGetFloat(kPOVAttrib_FileGamma, DEFAULT_FILE_GAMMA) < 0.001f)) return (m_LastError = vfeFileGammaTooSmall); n = sizeof (str) ; if ((err = POVMSUtil_GetUCS2String (&obj, kPOVAttrib_CreateIni, str, &n)) == kNoErr && str [0] != 0) if ((err = options.WriteFile (UCS2toASCIIString(str).c_str(), &obj)) != kNoErr) return (m_LastError = vfeFailedToWriteINI); opts.m_Options = ropts; m_RenderOptions = opts ; m_OptionsSet = true; return (m_LastError = vfeNoError) ; }