#include <rhinoSdkApp.h>
Classes | |
| class | CRhMruCommandRecord |
Public Attributes | |
| HCURSOR | m_arrow_command_cursor = nullptr |
| HCURSOR | m_arrow_copy_cursor = nullptr |
| arrow with "+" More... | |
| HCURSOR | m_cen_osnap_arrow_cursor = nullptr |
| HCURSOR | m_cen_osnap_cursor = nullptr |
| HCURSOR | m_context_menu_cursor = nullptr |
| HCURSOR | m_cross_hair_copy_cursor = nullptr |
| HCURSOR | m_cross_hair_cursor = nullptr |
| HCURSOR | m_cursor = nullptr |
| current cursor More... | |
| HCURSOR | m_default_cursor = nullptr |
| Steve - I would like to eventually make these private and accessible through functions. More... | |
| HCURSOR | m_end_osnap_arrow_cursor = nullptr |
| HCURSOR | m_end_osnap_cursor = nullptr |
| HCURSOR | m_focus_osnap_cursor = nullptr |
| HCURSOR | m_hand_cursor = nullptr |
| HCURSOR | m_hand_snap_cursor = nullptr |
| HCURSOR | m_hyperlink_cursor = nullptr |
| HCURSOR | m_int_osnap_arrow_cursor = nullptr |
| HCURSOR | m_int_osnap_cursor = nullptr |
| HCURSOR | m_knot_osnap_arrow_cursor = nullptr |
| HCURSOR | m_knot_osnap_cursor = nullptr |
| HCURSOR | m_magnify_cursor = nullptr |
| HCURSOR | m_magnify_snap_cursor = nullptr |
| HCURSOR | m_mid_osnap_arrow_cursor = nullptr |
| HCURSOR | m_mid_osnap_cursor = nullptr |
| HCURSOR | m_near_osnap_arrow_cursor = nullptr |
| HCURSOR | m_near_osnap_cursor = nullptr |
| HCURSOR | m_object_perp_osnap_cursor = nullptr |
| HCURSOR | m_object_tan_osnap_cursor = nullptr |
| HCURSOR | m_oncrv_osnap_cursor = nullptr |
| HCURSOR | m_onmesh_osnap_cursor = nullptr |
| HCURSOR | m_onsrf_osnap_cursor = nullptr |
| class CRhinoAppFonts * | m_pAppFonts |
| HCURSOR | m_perp_osnap_cursor = nullptr |
| HCURSOR | m_point_osnap_arrow_cursor = nullptr |
| Current drag base point osnap cursors (arrow cursor and osnap label) More... | |
| HCURSOR | m_point_osnap_cursor = nullptr |
| Current osnap cursors. More... | |
| HCURSOR | m_prohibit_cursor = nullptr |
| circle with slash More... | |
| class CRhino3Splash * | m_pSplash = nullptr |
| HCURSOR | m_quad_osnap_arrow_cursor = nullptr |
| HCURSOR | m_quad_osnap_cursor = nullptr |
| HCURSOR | m_rotate_cursor = nullptr |
| HCURSOR | m_tan_osnap_cursor = nullptr |
| HCURSOR | m_vertex_osnap_arrow_cursor = nullptr |
| HCURSOR | m_vertex_osnap_cursor = nullptr |
| HCURSOR | m_wait_cursor = nullptr |
Protected Member Functions | |
| class CCommandControlBar * | CommandWindow () const |
| void | LoadProfile (CRhinoProfileContext &PC) |
| MAC_DEPRECATED LPCTSTR | MruMenuString () const |
| void | RegisterRhinoFactories (bool bAutomated) |
| Rhino's version of COleObjectFactory::RegisterAll() More... | |
| void | SetCommandToRepeat (const CRhinoApp::CRhMruCommandRecord &rec) |
| bool | SetDefaultRenderApp (ON_UUID &uuid, bool force) |
| Special version of SetDefaultRenderApp called by InitInstance. Not exported. More... | |
| MAC_DEPRECATED void | SetMruMenuString (HMENU hmenu, UINT id) |
| void | WinAppOnFileNew () |
| TODO: remove this, temp hack to access private CWinApp func. More... | |
Friends | |
| class | CMainFrame |
| < All friends should be here More... | |
| class | CRhAppSettingsUiWatcher |
| class | CRhino3SplashWnd |
| class | CRhinoAppFonts |
| class | CRhinoFileMenu |
| void | RhOnWmDisplayChange () |
Detailed Description
Member Enumeration Documentation
◆ anonymous enum
| anonymous enum |
Control bar bit masks...
◆ anonymous enum
◆ APP_STATE
| enum CRhinoApp::APP_STATE : unsigned int |
CRhinoApp::APP_STATE enum values mark points in the sequence of the CRhinoApp being constructed, initializing, closing, exiting, and destructed. It is critical that the enum values be listed in chronological order.
| Enumerator | |
|---|---|
| app_state_ctor_zero | app_state_ctor_* - CRhinoApp::CRhinoApp() {} status |
| app_state_ctor_begin | entered scope |
| app_state_ctor_end | last line of scope |
| app_state_ctor_exited | exited scope |
| app_state_InitInstance_begin | app_state_InitInstance_* - CRhinoApp::InitInstance() {} status entered scope |
| app_state_InitInstance_before_WinAppInit | before call to CWinApp::InitInstance() |
| app_state_InitInstance_after_WinAppInit | entering CRhinoApp::InitInstance() scope |
| app_state_InitInstance_end | last line of scope |
| app_state_InitInstance_exited | exited scope |
| app_state_OnClose_begin | app_state_OnClose_* - CMainFrame::OnClose() {} status If m_rhino_app_state >= app_state_InitInstance_exited and m_rhino_app_state < app_state_OnClose_begin, then it means CRhinoApp::InitInstance() is finished and no WM_CLOSE message has been received by the main frame. This generally means Rhino is up and running. If more detailed app status information is needed, we can consider adding it. But keep in mind, this is Rhino app state and an app can have many docs and views in many states while it is running. This is not an appropriate place to report doc or view status because as soon as there are multiple docs or multiple views, there can be more than one answer to a doc or view question. entered scope |
| app_state_OnClose_before_MDIClose | before call to CMDIFrameWnd::OnClose() |
| app_state_OnClose_UnsavedCancel | CRhinoApp::SaveAllModified() - cancel requested. |
| app_state_OnClose_after_MDIClose | ordinary close - after call to CMDIFrameWnd::OnClose() |
| app_state_OnClose_end | ordinary close - last line of scope |
| app_state_OnClose_Canceled | canceled close - cleanup in progress |
| app_state_OnClose_exited | exited scope |
| app_state_ExitInstance_begin | app_state_ExitInstance_* - CRhinoApp::InitInstance() {} status entered scope |
| app_state_ExitInstance_before_WinAppExit | before call to CWinApp::InitInstance() |
| app_state_ExitInstance_after_WinAppExit | entering CRhinoApp::InitInstance() scope |
| app_state_ExitInstance_end | last line of scope |
| app_state_ExitInstance_exited | exited scope |
| app_state_dtor_begin | entered scope |
| app_state_dtor_end | last line of scope |
| app_state_dtor_exited | exited scope |
◆ cursor_tooltip_pane
◆ installation_type
Returns: The product installation type, as seen in Rhino's ABOUT dialog box.
See Also: CRhinoApp::NodeType CRhinoApp::InstallationType
◆ node_type
| enum CRhinoApp::node_type |
Returns: The product node type, as seen in Rhino's ABOUT dialog box.
See Also: CRhinoApp::SerialNumber CRhinoApp::InstallationType
| Enumerator | |
|---|---|
| node_stand_alone | Standalone. |
| node_network | Network (obtains license from Zoo server) |
| node_network_checked_out | Network (has license checked out from Zoo server) |
| node_type_force_32_bit | |
Constructor & Destructor Documentation
◆ CRhinoApp()
| CRhinoApp::CRhinoApp | ( | class CRhApp & | ) |
Everything below must NOT be exported to the SDK. Check with Steve or Dale before you change things here or add more functions.
Do NOT add members that require a complete class definition. Use pointers and call new in CRhinoApp::InitInstance();
◆ ~CRhinoApp()
|
virtual |
Member Function Documentation
◆ AcceleratorKeyDown()
| BOOL32 CRhinoApp::AcceleratorKeyDown | ( | UINT | nChar, |
| UINT | nRepCnt, | ||
| UINT | nFlags | ||
| ) |
Description: Called by various OnKeyDown methods to assign shortcut keys Parameters: nChar - [in] - key sending the message Returns: TRUE - nChar translated to an assigned key and a macro was executed. FALSE - nChar was not a shortcut key or there was no macro associated with it.
◆ ActivateCommandWindowCaret()
| bool CRhinoApp::ActivateCommandWindowCaret | ( | ) | const |
Activates flashing caret in command prompt.
◆ ActiveCommand()
| MAC_DEPRECATED const RHINO_SDK_FUNCTION CRhinoCommand* CRhinoApp::ActiveCommand | ( | ) | const |
Returns: Pointer to currently running command.
◆ ActiveCommandStyle()
| MAC_DEPRECATED const RHINO_SDK_FUNCTION CRhinoCommandContext::COMMAND_STYLE CRhinoApp::ActiveCommandStyle | ( | ) | const |
Returns: Style of currently running command: interactive_ui, script_ui, or batch_ui
◆ ActiveDoc()
| RHINO_SDK_FUNCTION CRhinoDoc* CRhinoApp::ActiveDoc | ( | ) | const |
The CRhinoApp::ActiveDoc() function will be deleted as soon as we finish removing what calls we can and replacing the hard cases with calls to CRhinoApp::ObsoleteActiveDoc().
In the rare cases, like the layer control on the Rhino app status bar, where modeless user interface needs a document, use RhinoApp().ModelessUserInterfaceDocRuntimeSerialNumber();
In the more common case where you don't have the time to elegantly replace a call to CRhinoApp::ActiveDoc(), put in a call to CRhinoApp::ObsoleteActiveDoc() and we will deal with it later.
Instead use 1) The command or object's doc value 2) CRhinoDoc::ModelessUserInterfaceRuntimeSerialNumber() for the document modeless ui, like the layer control on the app status bar, should use. ON_DEPRECATED
◆ ActiveSpace()
| RHINO_SDK_FUNCTION ON::active_space CRhinoApp::ActiveSpace | ( | ) | const |
Description: Returns the current working space.
◆ ActiveView()
| RHINO_SDK_FUNCTION class CRhinoView* CRhinoApp::ActiveView | ( | ) | const |
Description:
Returns the active view. Returns: Pointer to active view or NULL if no views have been created. Remarks: While models are being loaded, this function will return null. Code that may be run during file reading needs to test for a NULL pointer.
◆ AddMenu()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::AddMenu | ( | HMENU | hSubMenu, |
| LPCTSTR | title, | ||
| CRhinoPlugIn * | pApp | ||
| ) |
STEVEBAERV6///< - Need to chat with John about plan for supporting menu in V6.
◆ AddMenuItem()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::AddMenuItem | ( | HMENU | hTargetMenu, |
| UINT | index, | ||
| MENUITEMINFO * | pMi, | ||
| CRhinoPlugIn * | pApp | ||
| ) |
STEVEBAERV6///< - Need to chat with John about plan for supporting menu in V6.
◆ AddMruCommand()
| MAC_DEPRECATED void CRhinoApp::AddMruCommand | ( | const wchar_t * | cmd, |
| const wchar_t * | display_string = nullptr |
||
| ) |
Description: Add MRU command to list, pop old commands off when list reaches max size. Parameters: cmd - [in] command macro to add display_string - [in] String displayed in MRU command popup menu, if NUL then displays macro.
◆ AddPageToObjectPropertiesDialog()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::AddPageToObjectPropertiesDialog | ( | class IRhinoPropertiesPanelPage * | pPage, |
| const CRhinoPlugIn * | pPlugIn | ||
| ) |
Description: Adds a new page to the object properties dialog. Parameters: pPage - [in] The page to add to the object properties dialog. pPlugIn - [in] The plug-in that is adding the page. Returns: TRUE on success. FALSE on failure. See also: CRhinoApp::RemovePageFromObjectPropertiesDialog CRhinoPlugIn::AddPagesToObjectPropertiesDialog
- Deprecated:
- Derive a class from IRhinoAddPropertiesPages in your DLL to add pages
◆ AllowActivateCommandWindowCaret()
| bool CRhinoApp::AllowActivateCommandWindowCaret | ( | ) | const |
◆ AppDefaults()
|
pure virtual |
Implemented in MRhinoApp.
◆ AppEventManager()
| class CRhEventManager* CRhinoApp::AppEventManager | ( | ) | const |
list of events (text tokens, view clicks, digitizer points, etc.
◆ AppName()
|
pure virtual |
Implemented in MRhinoApp.
◆ AppSettings()
| RHINO_SDK_FUNCTION CRhinoAppSettings& CRhinoApp::AppSettings | ( | ) |
All application settings are kept in CRhinoAppSettings. The settings are loaded in CRhinoApp::InitInstance() and saved in CRhinoApp::ExitInstance().
◆ AppState()
| RHINO_SDK_FUNCTION CRhinoApp::APP_STATE CRhinoApp::AppState | ( | ) | const |
◆ ArrangeViews()
| void CRhinoApp::ArrangeViews | ( | bool | bMakeVisible | ) |
Description: Calls CRhinoDoc::ArrangeViews(bMakeVisible) for every document. This is useful when the main window or main client is resized. Parameters: bMakeVisible - [in] bMakeVisible parameter passed to CRhinoDoc.ArrangeViews(). Remarks: ArrangeViews() does not modify any active document or active view settings and that is intentional.
◆ AskUserForRhinoLicense()
| RHINO_SDK_FUNCTION bool CRhinoApp::AskUserForRhinoLicense | ( | bool | bStandalone, |
| HWND | parent | ||
| ) |
◆ AutoSave()
| RHINO_SDK_FUNCTION bool CRhinoApp::AutoSave | ( | unsigned int | rhino_doc_sn, |
| const wchar_t * | lpsCommandName, | ||
| int | auto_save_action | ||
| ) |
Description: Auto save if necessary Parameters: rhino_doc_sn - [in] serial number of document to save lpsCommandName - [in] If command name is in the CRhinoAppFileSettings::m_always_autosave_before_commands list then force auto save. auto_save_action - [in] 1: Ignore lpsCommandName parameter and force auto save.
0: If lpsCommandName is NULL or not in always save list then save it save if enough time has elapsed since the last save. -1: delete auto-save file
◆ BeginWaitCursor()
|
pure virtual |
Implemented in MRhinoApp.
◆ Calloc()
| RHINO_SDK_FUNCTION void* CRhinoApp::Calloc | ( | size_t | , |
| size_t | |||
| ) |
◆ CanSave()
| RHINO_SDK_FUNCTION bool CRhinoApp::CanSave | ( | ) |
Returns number of saves left in save-limited Evaluation. Zero when evaluation is expired. Raises InvalidLicenseTypeException if LicenseType != EvaluationSaveLimited Returns false in an expired evaluation version or otherwise save limited state (invalid licence etc).
◆ CaptureCommandWindowPrint()
| RHINO_SDK_FUNCTION bool CRhinoApp::CaptureCommandWindowPrint | ( | bool | enabled | ) |
Description: Enable or disable command window print statements. Returns: Previous enabled state for command window print capture
◆ CaptureCommandWindowPrintEnabled()
| RHINO_SDK_FUNCTION bool CRhinoApp::CaptureCommandWindowPrintEnabled | ( | ) | const |
Description: Returns true if command window print statements are being captured for retrieval later on. Default capture state is disabled
◆ ClearCommandHistoryWindowText()
| RHINO_SDK_FUNCTION void CRhinoApp::ClearCommandHistoryWindowText | ( | ) |
Description: Clear the text from Rhino's command history window
◆ ClearCursorToolTip()
| RHINO_SDK_FUNCTION void CRhinoApp::ClearCursorToolTip | ( | ) |
Description: Clears cursor tooltip, including all tooltip panes.
◆ ClearCursorToolTipPane()
| RHINO_SDK_FUNCTION void CRhinoApp::ClearCursorToolTipPane | ( | CRhinoApp::cursor_tooltip_pane | ) |
Description: Clears one tooltip pane.
◆ ClearFileReadOptions()
| void CRhinoApp::ClearFileReadOptions | ( | ) |
◆ CloseAllDocuments()
| void CRhinoApp::CloseAllDocuments | ( | BOOL32 | bEndSession | ) |
◆ CommandCanceled()
| RHINO_SDK_FUNCTION bool CRhinoApp::CommandCanceled | ( | ) | const |
Returns: True if a command is running and the user has pressed the escape key to cancel a command.
◆ CommandManager()
| class CRhCommandManager& CRhinoApp::CommandManager | ( | ) |
'Manager' helper classes - do NOT export to SDK
◆ CommandToRepeat()
| const CRhMruCommandRecord* CRhinoApp::CommandToRepeat | ( | ) | const |
◆ CommandWindow()
|
protected |
◆ CommandWindowCapturedStrings()
| RHINO_SDK_FUNCTION void CRhinoApp::CommandWindowCapturedStrings | ( | ON_ClassArray< ON_wString > & | strings, |
| bool | clearBuffer | ||
| ) |
Description: Get buffer of strings sent to RhinoApp().Print(...) This will only return a list of strings if CaptureCommandWindowPrintEnabled is true. Parameters: strings: list of strings that have been sent to RhinoApp().Print(...) clearBuffer: set to true to clear the existing buffer of print strings
◆ CreateOsnapCursors()
| void CRhinoApp::CreateOsnapCursors | ( | int | ) |
◆ CreateRhinoView()
| unsigned int CRhinoApp::CreateRhinoView | ( | unsigned int | rhino_doc_sn, |
| const ON_3dmView * | view, | ||
| CRuntimeClass * | pMfcViewRuntimeClass, | ||
| bool | bShowView | ||
| ) |
Description: Creates an new CRhinoView.
Parameters: rhino_doc_sn - [in] Runtime serial number of the document being viewed. view - [in] null or information about the view type and projection. pMfcViewRuntimeClass - [in] null or an MFC runtime class for a class derived from CRhinoView. plugin_id - [in] nil Core Rhino is creating the view. id of a plug-in A plug-in is using CRhinoDoc.CreateRhinoView() to create a view. (It is intentional that plug-ins cannot call CRhinoApp.CreateRhinoView().) bShowView - [in] If false, the view will not be shown. This is what you should do if you need to perform additional initialization on the view before it appears. If true, the view will be shown and updated. Returns: Runtime serial number of the new view which will be a class derived from CRhinoView. CRhinoView::FromRuntimeSerialNumber(...) can be used to get a pointer to this class.
◆ CurrentRenderPlugIn()
| CRhinoRenderPlugIn* CRhinoApp::CurrentRenderPlugIn | ( | ) |
◆ CustomMenuManager()
| class CRhCustomMenuManager& CRhinoApp::CustomMenuManager | ( | ) |
◆ DaysUntilExpiration()
| RHINO_SDK_FUNCTION int CRhinoApp::DaysUntilExpiration | ( | ) |
Returns number of days until license expires. Zero when license is expired. Raises InvalidLicenseTypeException if LicenseExpires would return false.
◆ DigitizerManager()
| RHINO_SDK_FUNCTION class CRhinoDigitizerManager& CRhinoApp::DigitizerManager | ( | ) |
◆ DispatchPluginMenuCommand()
| int CRhinoApp::DispatchPluginMenuCommand | ( | HMENU | hmenu, |
| WPARAM | wParam, | ||
| LPARAM | lParam | ||
| ) |
◆ DocViewManager()
| class CRhDocViewManager& CRhinoApp::DocViewManager | ( | ) |
◆ DoHelp()
| RHINO_SDK_FUNCTION bool CRhinoApp::DoHelp | ( | const wchar_t * | helpTopicLink | ) | const |
Description: Show help topic. Parameters: helpTopicLink - [in] if null or empty string, the help topic for the active command is displayed otherwise; helpTopicLink specifies a help topic URL. Returns: TRUE - help topic found FALSE - help topic not found
◆ Echo()
| RHINO_SDK_FUNCTION bool CRhinoApp::Echo | ( | ) | const |
Returns: True if echo is enabled. Scripts that begin with "noecho" or "_noecho" turn off echo.
◆ EchoCommand()
| void CRhinoApp::EchoCommand | ( | const wchar_t * | ) | const |
◆ EchoPrompt()
| void CRhinoApp::EchoPrompt | ( | const wchar_t * | ) | const |
◆ EmergencyExit()
| void CRhinoApp::EmergencyExit | ( | int | ) |
See source code comments for usage. Do not.
◆ EndWaitCursor()
|
pure virtual |
Implemented in MRhinoApp.
◆ EnterCommand()
| void CRhinoApp::EnterCommand | ( | CRhinoDoc & | doc, |
| const CRhinoCommand * | , | ||
| unsigned int * | undo_record_sn | ||
| ) |
◆ ExecutableFolder()
| RHINO_SDK_FUNCTION bool CRhinoApp::ExecutableFolder | ( | ON_wString & | result | ) | const |
Description: Get Rhino's executable folder Parameters: result - [out] - Folder name placed in this object Returns: TRUE if result updated otherwise FALSE.
◆ ExecuteCommand()
| RHINO_SDK_FUNCTION CRhinoCommand::result CRhinoApp::ExecuteCommand | ( | unsigned int | rhino_doc_sn, |
| const wchar_t * | cmd_name | ||
| ) |
Description: In general, you should use CRhinoApp::RunScript to run commands unless you are trying to modify the Rhino model from a modeless dialog. See the example below for how to handle the modeless dialog situation.
This is a low level tool that searches for a command (a instance of a class derived from CRhinoCommand) with a matching command name, if it finds a command, runs that command by calling the virtual CRhinoCommand::RunCommand() member function.
The command name can be prefaced with a combination of underscore (_), hyphen (-), or right single quote ('). If an underscore is present, then the command name search looks for a matching English command name. If the underscore is not present, the command name search looks for a matching localized command name. If the hyphen is present, then the command is run in script mode; otherwise the command is run in interactive mode. The right single quote is ignored by ExecuteCommand. It is used in scripts to indicate that the text token must be treated as a command name and is important to upstream text token parsing.
Example:
CMyCommand : pubic CRhinoCommand
{
public:
RunCommand(...);
type1 m_my_info1;
type2 m_my_info2;
bool m_bOkToRunCommand;
};
CMyCommand::CMyCommand()
{
m_bOkToRunCommand = false;
}
CMyCommand theMyCommand;
CMyCommand::RunCommand(...)
{
if (!m_bOkToRunCommand)
{
RhinoMessageBox(L"Use the MyDialog button to run this command");
return CRhinoCommand::failure;
}
/ the dialog has filled in m_my_info1 and m_my_info2. / Use this as the "input" to the command and then / do whatever you need to as if the command were / an ordinary command.
...
return CRhinoCommand::success;
}
...
CMyDialog::OnButtonDown(...)
{
/ fill in the parameters theMyCommand.m_my_info1 = ...; theMyCommand.m_my_info2 = ...; theMyCommand.m_bOkToRunCommand = true; RhinoApp().ExectueCommand(theMyCommand.LocalCommandName());
theMyCommand.m_bOkToRunCommand = false; }
Returns: Command return code indicating if the command worked, failed, or was canceled by the user.
◆ ExeServiceRelease()
| RHINO_SDK_FUNCTION int CRhinoApp::ExeServiceRelease | ( | ) | const |
Returns: Service release version of Rhino executable (0, 1, 2, ...)
The integer is the service release number of Rhino. For example, this function returns "0" if Rhino V6SR0 is running and returns "1" if Rhino V6SR1 is running. See Also: CRhinoApp::SdkVersion CRhinoApp::SdkServiceRelease CRhinoApp::ExeVersion
◆ ExeVersion()
| RHINO_SDK_FUNCTION int CRhinoApp::ExeVersion | ( | ) | const |
Returns: Major version of Rhino executable 4, 5, 6, ... See Also: CRhinoApp::SdkVersion CRhinoApp::SdkServiceRelease CRhinoApp::ExeServiceRelease
◆ ExitCommand()
| void CRhinoApp::ExitCommand | ( | unsigned int | rhino_doc_sn0, |
| unsigned int | rhino_doc_sn1, | ||
| const CRhinoCommand * | , | ||
| unsigned int | undo_record_sn | ||
| ) |
Parameters: rhino_doc_sn0 - [in] Document passed to command. rhino_doc_sn1 - [in] Document command worked on (Some command delete the input doc and make a new one.)
◆ ExitInstance()
| int CRhinoApp::ExitInstance | ( | ) |
◆ ExitRhino()
| BOOL32 CRhinoApp::ExitRhino | ( | ) |
◆ FileImport()
| bool CRhinoApp::FileImport | ( | unsigned int | rhino_doc_sn, |
| const wchar_t * | file_name_to_read, | ||
| bool | bUseDialogs, | ||
| bool | bSelectNewObjects, | ||
| ON_wString * | file_name_read | ||
| ) |
Description: Import the contents of a file into the specified document. Parameters: rhino_doc_sn - [in] document to import into file_name_to_read - [in] name of file to read. If null, the user is asked to select a file. bUseDialogs - [in] true if user dialogs can be used. Otherwise a predictable scripting interface is used. file_name_read - [out] If not null, the name of the file that is actually read is returned here. Returns: True if the file was successfully read.
◆ FileNew()
| unsigned int CRhinoApp::FileNew | ( | bool | bUseDialogs | ) |
◆ FileOpen()
| unsigned int CRhinoApp::FileOpen | ( | const wchar_t * | file_name_to_read, |
| bool | bUseDialogs, | ||
| bool | bCreateEmptyDocOnFailure, | ||
| ON_wString * | file_name_read | ||
| ) |
Description: Create a new document and read a file into the new document. Parameters: file_name_to_read - [in] Name of file to read. If null, the file dialog is used to select a file. bUseDialogs - [in] true to use dialogs false to use script interface bCreateEmptyDocOnFailure - [in] true if an empty document should be created when the file reading fails. file_name_read - [out] If not null, the name of the read file is returned here. If the file reading fails, an empty string is returned. Returns: Serial number of the document that is created.
- Parameters
-
file_name_to_read null to use file dialog [out] file_name_read [out] returns name of file read
◆ FileReadOptions() [1/2]
| RHINO_SDK_FUNCTION CRhinoFileReadOptions& CRhinoApp::FileReadOptions | ( | ) |
◆ FileReadOptions() [2/2]
| const RHINO_SDK_FUNCTION CRhinoFileReadOptions& CRhinoApp::FileReadOptions | ( | ) | const |
Returns: Current file reading options set by various UI dialogs and functions. Remarks: If you need to save and restore current read options, use an instance of a CRhinoSaveAndRestoreAppFileReadOptions class on the stack.
This is a foolish place to store these file reading settings and to specify how files should be read, but it cannot be changed in V5 without breaking the public SDK. So, as a plug-in developer, use the FileReadOptions() functions and use only references (rather than local instances of CRhinoFileReadOptions classes) and changes you make will actually be used by core Rhino file reading code.
◆ FileReadOptionsEx()
| class CRhFileReadOptions& CRhinoApp::FileReadOptionsEx | ( | ) |
do not export this function
◆ FileReference()
| bool CRhinoApp::FileReference | ( | ON_wString & | FileName, |
| bool | bUseDialog = true, |
||
| HWND | hWndParent = nullptr |
||
| ) |
◆ FindCommand() [1/2]
| RHINO_SDK_FUNCTION CRhinoCommand* CRhinoApp::FindCommand | ( | const wchar_t * | command_name | ) | const |
Description: Use a command's name to find a command. Parameters: command_name - [in] command name. Use the "_" prefix if you want to lookup the English command name. If no "_" prefix is present, then this will search for the local command name.. Returns: Pointer to the command or NULL if no command was found.
◆ FindCommand() [2/2]
| RHINO_SDK_FUNCTION CRhinoCommand* CRhinoApp::FindCommand | ( | ON_UUID | command_uuid | ) | const |
Description: Use a command's UUID to find a command. Parameters: command_uuid - [in] command UUID. Returns: Pointer to the command or NULL if no command was found.
◆ FindGripsEnabler()
| RHINO_SDK_FUNCTION CRhinoGripsEnabler* CRhinoApp::FindGripsEnabler | ( | ON_UUID | grips_id | ) | const |
◆ FindMenuItem()
| RHINO_SDK_FUNCTION int CRhinoApp::FindMenuItem | ( | HMENU | hmenu, |
| LPCTSTR | string, | ||
| MENUITEMINFO * | pMi | ||
| ) |
STEVEBAERV6///< - Need to chat with John about plan for supporting menu in V6.
Description: Finds a menu item ( may be a sub-menu) in a menu. Fills in the MENUITEMINFO and returns the index or -1 if not found MENUITEMINFO must be initialized and have dwTypeData pointing to a buffer and cch set to the buffer's length if you want a string back If you don't care about dwTypeData, you don't have to init the structure
◆ FindRhinoMenuItem()
| RHINO_SDK_FUNCTION bool CRhinoApp::FindRhinoMenuItem | ( | const wchar_t * | sEnglishMenuPath, |
| HMENU & | hParentMenuHandle, | ||
| int & | nMenuItemIndex | ||
| ) |
STEVEBAERV6///< - Need to chat with John about plan for supporting menu in V6.
Description: FindMenuItem searches the Rhino menu structure for a certain item. On success the hParentMenuHandle contains the HMENU of the menu containing the sought item and nMenuItemIndex is the index of the item within hParentMenuHandle.
Parameters: sEnglishMenuPath - [in] Double-colon separated full path to menu example: Too&ls::&Commands The & characters (used for keyboard acceleration) must be specified correctly for this call to work on localized versions of Rhino. hParentMenuHandle - [out] the handle of the menu that contains the menu item. nMenuItemIndex - [out] the index of the menu item in hParentMenuHandle
Returns: true on success. false on failure.
◆ FrameWindowProc()
Description: Called by CMainFrame or CInPlaceFrame Parameters: Standard Windows procedure parameters. bInPlace [in] - True if called from CInPlaceFrame Returns: TRUE - Frame window will call default procedure FALSE - Frame will not call default procedure
◆ Free()
| RHINO_SDK_FUNCTION void CRhinoApp::Free | ( | void * | ) |
◆ FullscreenEscapeDisabled()
| RHINO_SDK_FUNCTION bool CRhinoApp::FullscreenEscapeDisabled | ( | ) | const |
◆ GetApplicationName() [1/2]
| RHINO_SDK_FUNCTION void CRhinoApp::GetApplicationName | ( | ON_3dmApplication & | app_name | ) | const |
◆ GetApplicationName() [2/2]
| RHINO_SDK_FUNCTION void CRhinoApp::GetApplicationName | ( | ON_wString & | app_name | ) | const |
◆ GetAutoSave()
| class CRhAutoSave& CRhinoApp::GetAutoSave | ( | ) | const |
◆ GetBuildDate() [1/3]
| RHINO_SDK_FUNCTION void CRhinoApp::GetBuildDate | ( | int & | nYear, |
| int & | nMonth, | ||
| int & | nDate | ||
| ) | const |
Description: Get build date information from VERSIONINFO block of the EXE Parameters: nYear - [out] Gets filled in with four digit year nMonth - [out] Gets filled in with month nDate - [out] Gets filled in with the day of the month
◆ GetBuildDate() [2/3]
| RHINO_SDK_FUNCTION void CRhinoApp::GetBuildDate | ( | ON_wString & | wBuildDate | ) | const |
Description: Get build date formatted for use in registry Parameters: wBuildDate - [out] L"YYYY-MM-DD"
◆ GetBuildDate() [3/3]
| RHINO_SDK_FUNCTION void CRhinoApp::GetBuildDate | ( | ON_wString & | wYear, |
| ON_wString & | wMonth, | ||
| ON_wString & | wDate | ||
| ) | const |
Description: Get build date information from VERSIONINFO block of the EXE Parameters: wYear - [out] Gets filled in with four digit year wMonth - [out] Gets filled in with first 3 chars of the month wDate - [out] Gets filled in with the day of the month
◆ GetCommandHistoryWindowText()
| RHINO_SDK_FUNCTION void CRhinoApp::GetCommandHistoryWindowText | ( | ON_wString & | wstr | ) | const |
Description: Returns the text from Rhino's command history window Parameters: wstr - [out] - The command history window text.
◆ GetCommandLineScript()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetCommandLineScript | ( | ON_wString & | wScript | ) |
Description: Parse command line arguments passed to Rhino.exe on startup. Parameters: wScript - [out] A string containing a space-delimited series of commands and command arguments that are run when Rhino starts. These commands are executed immediately after the commands specified by the user as "Startup" commands in the General tab of the Options dialog box. Returns: Returns true if wScript is not empty, indicating that there are commands to run. Returns false if wScript is empty, indicating that there are not commands to run.
◆ GetCommandNameList()
| void CRhinoApp::GetCommandNameList | ( | ON_TextLog & | ) | const |
◆ GetCommandPrompt()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetCommandPrompt | ( | ON_wString & | prompt | ) | const |
Description: Get Rhino command prompt string. Parameters: prompt - [out] Prompt display string. Returns: Returns true on success.
◆ GetCommandPromptEx()
| bool CRhinoApp::GetCommandPromptEx | ( | ON_wString & | prompt, |
| ON_wString & | prompt_default, | ||
| ON_ClassArray< CRhinoCommandOption > & | options | ||
| ) |
◆ GetDefaultRenderApp()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::GetDefaultRenderApp | ( | ) | const |
Description: Get the application ID for the default render plug-in
◆ GetDocument()
| RHINO_SDK_FUNCTION CRhinoDoc* CRhinoApp::GetDocument | ( | UINT_PTR | doc_sn | ) | const |
Description: Find the document with this serial number. Returns: A pointer to the document if it exists. Null if no living document has this serial number. Remarks: Use CRhinoDoc::FromRuntimeSerialNumber().
◆ GetMRUCommands()
| RHINO_SDK_FUNCTION int CRhinoApp::GetMRUCommands | ( | ON_ClassArray< ON_wString > & | display_strings, |
| ON_ClassArray< ON_wString > & | macros | ||
| ) | const |
Description: Get a list of all of the recently run macros/commands Parameters: display_strings, macros: two lists that MRU command information is added to in parallel Returns: number of items added to the lists
◆ GetNetCoreRuntimeVersion()
| void CRhinoApp::GetNetCoreRuntimeVersion | ( | ON_wString & | wVersion | ) |
◆ GetPlugInObjectInterface()
| RHINO_SDK_FUNCTION LPUNKNOWN CRhinoApp::GetPlugInObjectInterface | ( | const ON_UUID & | plugin_uuid, |
| const ON_UUID & | interface_uuid | ||
| ) |
Description: Returns the pointer to an interface object in a plug-in. Parameter: plugin_uuid [in] - The plug-in to query. interface_uuid [in] - The requested interface. Return: The IUnknown pointer of the requested interface, if successful. Return NULL on error or if the interface is not supported. Notes: It is the responsibility of the application calling this function to increment and decrement the object's reference count using AddRef() and Release().
◆ GetPOSIXLocaleIdentifier()
|
pure virtual |
Implemented in MRhinoApp.
◆ GetPOSIXLocaleName()
|
pure virtual |
ON_RUNTIME_WIN.
Implemented in MRhinoApp.
◆ GetProtocolHandlerUrl()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetProtocolHandlerUrl | ( | ON_wString & | protocolHandlerUrl | ) |
Description: Gets the URL passed to Rhino by the protocol handler registered with the system. The URL is in the full form protocol://verb/path (rhino7://package/search/<package name>)
Parameters: protocolHandlerUrl - [out] the URL Returns: true if protocolHandlerUrl is set; false otherwise
◆ GetRhinoGlobalOptionsRegistryPath()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetRhinoGlobalOptionsRegistryPath | ( | bool | bFullPath, |
| ON_wString & | result | ||
| ) | const |
Description: Get the global options registry key path. Parameters: bFullPath - [in] If true, the result begins with "Software\McNeel\Rhinoceros<version>. result - [out] If bFullPath is true, then result is "Software\McNeel\Rhinoceros\<version>\Global Options". If bFullPath is false, then result is "Global Options".
◆ GetRhinoPlugInsRegistryPath()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetRhinoPlugInsRegistryPath | ( | bool | bFullPath, |
| ON_wString & | result | ||
| ) | const |
Description: Get the plug-ins registry key path. Parameters: bFullPath - [in] If true, the result begins with "Software\McNeel\Rhinoceros<version>. result - [out] In release builds: If bFullPath is true, then result is "Software\McNeel\Rhinoceros\<version>\Plug-Ins". If bFullPath is false, then result is "Plug-Ins". In debug builds: If bFullPath is true, then result is "Software\McNeel\Rhinoceros\<version>\Plug-Ins_DebugBuild". If bFullPath is false, then result is "Plug-Ins_DebugBuild". Remarks: The reason release and debug builds use different locations is because release Rhino will not load debug plug-ins and vice versa. Using different locations for debug and release builds means developers do not have to constantly re-register plug-ins when they switch between running debug and release versions.
◆ GetRhinoProfileContext()
| RHINO_SDK_FUNCTION CRhinoProfileContext& CRhinoApp::GetRhinoProfileContext | ( | CRhinoProfileContext::context_location | location | ) |
Description: For expert use only. Use profile contexts for reading and writing information that should persist between Rhino sessions. The profile contexts are platform and location independent.
Appropriate profile contexts are: RhinoApp().m_pc_scheme_current_user RhinoApp().m_pc_global_current_user RhinoApp().m_pc_root_local_machine RhinoApp().m_pc_plugins_current_user RhinoApp().m_pc_plugins_local_machine
Parameters: location - [in] see CRhinoProfileContext::context_location for options Returns: CRhinoProfileContext reference to requested profile context.
◆ GetRhinoRegistryKey()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::GetRhinoRegistryKey | ( | ON_wString & | result | ) | const |
- Deprecated:
- use GetRhinoRootRegistryPath, GetRhinoPlugInsRegistryPath, GetRhinoSchemeRegistryPath, or GetRhinoGlobalOptionsRegistryPath
◆ GetRhinoRootRegistryPath()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetRhinoRootRegistryPath | ( | ON_wString & | result | ) | const |
Parameters: result - [out] "Software\McNeel\Rhinoceros\<version>" Remarks: In shipping builds <version> is something like "5.0". In developer builds <version> is something like 5.0-Developer-Debug and 5.0-Developer-Release. The reason for the difference is so developer builds do not damage the shipping product registry and so plug-ins used by developer debug and release have clear and separate registry areas. There are very few cases when a plug-in developer should use GetRhinoRootRegistryPath(). In general, you should use GetRhinoPlugInsRegistryPath(), GetRhinoSchemeRegistryPath() and GetRhinoGlobalOptionsRegistryPath().
◆ GetRhinoSchemeRegistryPath()
| RHINO_SDK_FUNCTION bool CRhinoApp::GetRhinoSchemeRegistryPath | ( | bool | bFullPath, |
| ON_wString & | result | ||
| ) | const |
Description: Get the global options registry key path. Parameters: bFullPath - [in] If true, the result begins with "Software\McNeel\Rhinoceros<version>. result - [out] If bFullPath is true, then result is "Software\McNeel\Rhinoceros\<version>\Scheme: <name>". If bFullPath is false, then result is "Scheme: <name>".
◆ GetSystemInformation()
| RHINO_SDK_FUNCTION void CRhinoApp::GetSystemInformation | ( | ON_TextLog & | log | ) | const |
◆ GetUniqueMenuItemID()
| RHINO_SDK_FUNCTION UINT CRhinoApp::GetUniqueMenuItemID | ( | HMENU | hMenu | ) |
STEVEBAERV6///< - Need to chat with John about plan for supporting menu in V6.
◆ HideControlBars()
| RHINO_SDK_FUNCTION bool CRhinoApp::HideControlBars | ( | UINT | nCBMask = 0xFFFFFFFF, |
| int | nDockState = 0, |
||
| bool | bRedraw = true, |
||
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Hides the control bars based on the passed in bit mask and dock state...See above list that describes the control bars that are currently supported and their corresponding mask value: Parameters: nCBMask [in]: Control bar bit mask indicating which control bars to hide. If the corresponding bit is ON, then that control bar will be hidden (see description above for control bar bit values). nDockState [in]: 0 = hide control bars regardless of dock state 1 = hide only DOCKED control bars 2 = hide only FLOATING control bars bRedraw [in]: true = redraw and recalculate the main window and layout false = don't do anything after the toolbars have been hidden. pDoc [in]: Pointer to the document whose toolbars should be restored. nullptr is used to indicate the current document Returns: true - if any toolbars with specified state were hidden. false - if nothing was hidden. See Also: CRhinoApp::RestoreControlBars()
◆ HideToolBars()
| RHINO_SDK_FUNCTION bool CRhinoApp::HideToolBars | ( | int | nDockState = 0, |
| bool | bRedraw = true, |
||
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Hides the toolbars based on the passed in flag... Parameters: nDockState [in]: 0 = hide ALL toolbars regardless of dock state 1 = hide only DOCKED toolbars 2 = hide only FLOATING toolbars bRedraw [in]: true = redraw and recalculate the main window and layout false = don't do anything after the toolbars have been hidden. Returns: true - if any toolbars with specified state were hidden. false - if nothing was hidden. See Also: CRhinoApp::RestoreToolBars()
◆ HideWindowBars()
| RHINO_SDK_FUNCTION bool CRhinoApp::HideWindowBars | ( | UINT | nWBMask = 0xFFFFFFFF, |
| bool | bRedraw = true, |
||
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Hides the main window's window bars based on the passed in bit mask. See above list that describes the different types of window bars that are currently supported and their corresponding mask value. Parameters: nWBMask [in]: Window bar bit mask indicating which window bars to hide. If the corresponding bit is ON, then that window bar will be hidden (see description above for window bar bit values). bRedraw [in]: true = redraw and recalculate the main window and layout false = don't do anything after the bars have been hidden. pDoc [in]: Pointer to the document whose control bars should be restored. nullptr is used to indicate the current document Returns: true - if any bars specified were hidden. false - if nothing was hidden. See Also: CRhinoApp::RestoreWindowBars()
◆ InAppMode()
| RHINO_SDK_FUNCTION bool CRhinoApp::InAppMode | ( | ) | const |
◆ InCommand()
| RHINO_SDK_FUNCTION int CRhinoApp::InCommand | ( | bool | bIgnoreScriptRunnerCommands = false | ) | const |
Description: This is a low level tool to determine if Rhino is currently running a command.
Parameters: bIgnoreScriptRunnerCommands - [in] if true, script running commands like "ReadCommandFile" and the RhinoScript plug-ins "RunScript" are not counted. Returns: Number of active commands.
◆ InConstructor()
| RHINO_SDK_FUNCTION bool CRhinoApp::InConstructor | ( | ) | const |
Returns true
- The single instance of the CRhinoApp class is being constructed.
- The code in CRhinoApp::CRhinoApp() is running.
- CRhinoApp.m_app_status <= CRhinoApp::APP_STATUS::app_status_ctor_end
◆ IncrementRhinoAppTicker()
| RHINO_SDK_FUNCTION void CRhinoApp::IncrementRhinoAppTicker | ( | ) |
Description: Every time Rhino does something critical, like running a command, Rhino calls CRhinoApp::IncrementRhinoAppTicker() so the code that detects when Rhino is "idle" can do a good job of knowing how long Rhino has been idle.
◆ InDestructor()
| RHINO_SDK_FUNCTION bool CRhinoApp::InDestructor | ( | ) | const |
Returns
- The code in CRhinoApp::~CRhinoApp() is running.
- CRhinoApp.m_app_status >= CRhinoApp::APP_STATUS::app_status_dtor_begin
◆ InExitInstance()
| RHINO_SDK_FUNCTION bool CRhinoApp::InExitInstance | ( | ) | const |
Returns true
- The code in CRhinoApp::ExitInstance() is running.
- CRhinoApp.m_app_status >= CRhinoApp::APP_STATUS::app_status_ExitInstance_begin
- CRhinoApp.m_app_status <= CRhinoApp::APP_STATUS::app_status_ExitInstance_end
◆ InFullscreen()
| RHINO_SDK_FUNCTION bool CRhinoApp::InFullscreen | ( | ) | const |
◆ InInitInstance()
| RHINO_SDK_FUNCTION bool CRhinoApp::InInitInstance | ( | ) | const |
Returns true The code in CRhinoApp::InitInstance() is running. CRhinoApp.m_app_status >= CRhinoApp::APP_STATUS::app_status_InitInstance_begin CRhinoApp.m_app_status <= CRhinoApp::APP_STATUS::app_status_InitInstance_end
◆ InitCursorToolTip()
| void CRhinoApp::InitCursorToolTip | ( | ) |
Description: Used internally for initializing the cursor tooltip.
◆ InitInstance()
| BOOL32 CRhinoApp::InitInstance | ( | ) |
◆ InMainFrameOnClose()
| RHINO_SDK_FUNCTION bool CRhinoApp::InMainFrameOnClose | ( | ) | const |
Returns true
- The code in CMainFrame::OnClose() is running.
- CRhinoApp.m_app_status <= CRhinoApp::APP_STATUS::app_status_OnClose_begin
- CRhinoApp.m_app_status < CRhinoApp::APP_STATUS::app_status_OnClose_exited
◆ InScriptRunnerCommand()
| RHINO_SDK_FUNCTION bool CRhinoApp::InScriptRunnerCommand | ( | ) | const |
Description: This is a low level tool to determine if Rhino is currently running a script running command like "ReadCommandFile" or the RhinoScript plug-in's "RunScript". Returns: True if a script running command is active.
◆ InstallationType()
| RHINO_SDK_FUNCTION installation_type CRhinoApp::InstallationType | ( | ) |
◆ InstallationTypeString()
| RHINO_SDK_FUNCTION ON_wString CRhinoApp::InstallationTypeString | ( | ) |
Returns: The type of installation (product edition) of the license or lease.
◆ InstallFolder()
| RHINO_SDK_FUNCTION bool CRhinoApp::InstallFolder | ( | ON_wString & | result | ) |
Description: Get Rhino's installation folder Parameters: result - [out] - Folder name placed in this object Returns: TRUE if result updated otherwise FALSE.
◆ IsAutomated()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsAutomated | ( | ) | const |
◆ IsClosing()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsClosing | ( | ) | const |
Returns True if Rhino is processing a close application message or later. Closing can be canceled.
- CRhinoApp.m_app_status >= CRhinoApp::APP_STATUS::app_status_OnClose_begin See Also: CRhinoApp::InMainFrameOnClose()
◆ IsCloudZooNode()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsCloudZooNode | ( | ) |
Returns: true if Rhino currently uses the Cloud Zoo lease false otherwise
◆ IsDontRepeatCommand()
| bool CRhinoApp::IsDontRepeatCommand | ( | wchar_t * | token | ) |
◆ IsExiting()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsExiting | ( | ) | const |
Returns true
- we have entered CRhinoApp::ExitInstance() or later.
- CRhinoApp.m_app_status >= CRhinoApp::APP_STATUS::app_status_ExitInstance_begin
◆ IsHeadless()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsHeadless | ( | ) | const |
◆ IsInitializing()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsInitializing | ( | ) | const |
Returns true
- We have not completed CRhinoApp::InInitInstance().
- This means the state is someplace between being constructed and being initialized.
- CRhinoApp.m_app_status <= CRhinoApp::APP_STATUS::app_status_ExitInstance_end
◆ IsInternetAccessAllowed()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsInternetAccessAllowed | ( | ) |
Returns: true if Rhino is allowed to access the Internet, false otherwise Some large corporations require that Rhino be silent, and not try to access the Internet. All Rhino components that try to access the Internet should check this setting before initiating an outbound connection.
◆ IsLicenseValidated()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsLicenseValidated | ( | ) |
Returns true if the license is validated false otherwise
◆ IsParentWindowDesktop()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsParentWindowDesktop | ( | ) | const |
Description: The parent of a top-level window is the desktop window. Some applications like to re-parent Rhino's main window to a window they provide. Use this method to determine if Rhino is in such a condition. Note, method is only valid on Windows. Returns: True if Rhino's parent window is the desktop, false otherwise.
◆ IsPreRelease()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsPreRelease | ( | ) |
◆ IsRhino2UUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhino2UUID | ( | const | ON_UUID | ) | const |
◆ IsRhino3UUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhino3UUID | ( | const | ON_UUID | ) | const |
◆ IsRhino4UUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhino4UUID | ( | const | ON_UUID | ) | const |
◆ IsRhino5UUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhino5UUID | ( | const | ON_UUID | ) | const |
◆ IsRhino6UUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhino6UUID | ( | const | ON_UUID | ) | const |
◆ IsRhino7UUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhino7UUID | ( | const | ON_UUID | ) | const |
◆ IsRhinoAllowedToRun()
| bool CRhinoApp::IsRhinoAllowedToRun | ( | ) | const |
Description: Checks to see if Rhino is allowed to run. Returns: True if Rhino can run; false otherwise.
◆ IsRhinoUUID()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsRhinoUUID | ( | const | ON_UUID | ) | const |
◆ IsSafeModeEnabled()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsSafeModeEnabled | ( | ) | const |
Returns whether not Rhino was launched with the /safemode command line parameter.
◆ IsSingleDocApp()
| bool CRhinoApp::IsSingleDocApp | ( | ) | const |
Returns: True if Rhino should act like a single doc application.
◆ IsSkinned()
| RHINO_SDK_FUNCTION bool CRhinoApp::IsSkinned | ( | ) | const |
Returns true if Rhino is using a custom, user-interface Skin. For more information on Skins, see: http://developer.rhino3d.com/guides/cpp/creating-a-skin/ http://developer.rhino3d.com/guides/rhinocommon/creating-a-skin/
◆ LicenseExpires()
| RHINO_SDK_FUNCTION bool CRhinoApp::LicenseExpires | ( | ) |
Returns: true if the license will expire false otherwise
◆ LicenseManager()
| class CRhinoLicenseManager& CRhinoApp::LicenseManager | ( | ) |
◆ LicenseUserName()
| RHINO_SDK_FUNCTION ON_wString CRhinoApp::LicenseUserName | ( | ) |
Returns: The owner of the license or lease.
◆ LicenseUserOrganization()
| RHINO_SDK_FUNCTION ON_wString CRhinoApp::LicenseUserOrganization | ( | ) |
Returns: The organization the user owning the license or lease belongs to.
◆ LoadCursor()
|
pure virtual |
◆ LoadProfile()
|
protected |
This should only be called one time by CRhinoApp::InitInstance. Use this to initialize CRhinoApp properties
◆ LookupView()
| RHINO_SDK_FUNCTION CRhinoView* CRhinoApp::LookupView | ( | ON_UUID | main_viewport_id | ) | const |
Use CRhinoView::FromMainViewportId() to find CRhinoView from its main id or use CRhinoViewport::FromViewportId() to find a CRhinoViewport (model, page, or detail) ON_DEPRECATED
◆ MainFrame()
| CMainFrame* CRhinoApp::MainFrame | ( | ) | const |
Use to get main frame - can return a NULL when Rhino is embedded in other applications.
If you call this function, then you MUST CAREFULLY TEST your code by making sure it works when Rhino is embedded in Microsoft Word, PowerPoint and Internet Explorer. That's THREE tests you must perform - NO SLACKING. Will return NULL when Rhino is embedded in another application.
See Also: CRhinoApp::MainWnd(); or CRhinoApp::MainWindow();
◆ MainHMenu()
| HMENU CRhinoApp::MainHMenu | ( | ) | const |
◆ MainWindow()
| CWnd* CRhinoApp::MainWindow | ( | ) | const |
Return main window pointer, this pointer may be a CMainFrame or CInPlaceFrame object, will return CInPlaceFrame if Rhino is embedded in another application. Use pointer->IsKindOf( RUNTIME_CLASS( CMainFrame)) if you care or call CRhinoApp::MainFrame() if you absolutely need a CMainFrame object.
◆ MainWnd()
| RHINO_SDK_FUNCTION HWND CRhinoApp::MainWnd | ( | ) | const |
Description: Get Rhino main window. Returns: Rhino application's AfxGetMainWnd(). See Also: CRhinoApp::MainFrame
◆ Malloc()
| RHINO_SDK_FUNCTION void* CRhinoApp::Malloc | ( | size_t | ) |
main application memory pool tools
◆ Memdup()
| RHINO_SDK_FUNCTION void* CRhinoApp::Memdup | ( | const void * | , |
| size_t | |||
| ) |
◆ MonitorRects()
| RHINO_SDK_FUNCTION ON_SimpleArray<ON_4iRect> CRhinoApp::MonitorRects | ( | ) | const |
Description: Call this method to get a sorted list of monitor display rectangles associated with the currently installed monitors. The array will be sorted by the left edge. Returns: Reference to the monitor rectangles.
◆ MruCommandList()
| const ON_ClassArray<CRhMruCommandRecord>& CRhinoApp::MruCommandList | ( | ) | const |
◆ MruMenuString()
|
protected |
◆ NoCancelOnMainFrameClose()
| bool CRhinoApp::NoCancelOnMainFrameClose | ( | ) | const |
◆ NodeType()
| RHINO_SDK_FUNCTION node_type CRhinoApp::NodeType | ( | ) |
◆ ObjectManager()
| RHINO_SDK_FUNCTION class IRhinoObjectManager& CRhinoApp::ObjectManager | ( | void | ) |
◆ ObsoleteActiveDoc()
| RHINO_SDK_FUNCTION CRhinoDoc* CRhinoApp::ObsoleteActiveDoc | ( | ) | const |
ON_DEPRECATED.
As we work on V6 and developers find "ActiveDoc()" calls that cannot be easily removed or reasonably replaced with a call to RhinoApp().ModelessUserInterfaceDocRuntimeSerialNumber(), that call to ActiveDoc() will be replaced with ObsoleteActiveDoc(). This makes it easy for people who are going through Rhino and removing ActiveDoc() to ignore calls to this function that other developers have already worked on.
◆ OnAppAbout()
| void CRhinoApp::OnAppAbout | ( | ) |
Call RhinoAbout() externally.
◆ OnAppFileNew()
| void CRhinoApp::OnAppFileNew | ( | ) |
◆ OnEscapeKeyDown()
| bool CRhinoApp::OnEscapeKeyDown | ( | ) |
Does the "generic" ESCAPE key handling that should happen if nothing specific applies.
◆ OnFileClose()
| void CRhinoApp::OnFileClose | ( | ) |
◆ OnFileNew()
| void CRhinoApp::OnFileNew | ( | ) |
◆ OnFileOpen()
| void CRhinoApp::OnFileOpen | ( | ) |
◆ OnIdle()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::OnIdle | ( | LONG | lCount | ) |
◆ OnInitMenuPopup()
| void CRhinoApp::OnInitMenuPopup | ( | WPARAM | wparam, |
| LPARAM | lparam | ||
| ) |
◆ OnOpenRecentFile()
| BOOL32 CRhinoApp::OnOpenRecentFile | ( | UINT | nID | ) |
◆ OnSysKeyDown()
| bool CRhinoApp::OnSysKeyDown | ( | UINT | nChar, |
| UINT | nRepCnt, | ||
| UINT | nFlags | ||
| ) |
Does the "generic" Alt+Fx and F10 key handling.
◆ OnSysKeyUp()
| bool CRhinoApp::OnSysKeyUp | ( | UINT | nChar, |
| UINT | nRepCnt, | ||
| UINT | nFlags | ||
| ) |
Needed for Alt + arrow key input buffer cleanup when nudging.
◆ OpenDocumentFile() [1/2]
| CDocument* CRhinoApp::OpenDocumentFile | ( | LPCTSTR | lpszFileName | ) |
◆ OpenDocumentFile() [2/2]
| CDocument* CRhinoApp::OpenDocumentFile | ( | LPCTSTR | lpszFileName, |
| BOOL32 | bAddToMRU | ||
| ) |
◆ OsnapName()
| const RHINO_SDK_FUNCTION wchar_t* CRhinoApp::OsnapName | ( | CRhinoAppSettings::osnap_mode | ) |
Description: Returns the localized osnap name.
◆ PlugInManager()
| class CRhPlugInManager& CRhinoApp::PlugInManager | ( | ) |
◆ PopMainMenu()
| bool CRhinoApp::PopMainMenu | ( | ) |
◆ PostRhinoWindowsMessage()
| bool CRhinoApp::PostRhinoWindowsMessage | ( | WPARAM | wParam, |
| LPARAM | lParam | ||
| ) |
DO NOT PUT THIS FUNCTION IN THE PUBLIC SDK.
◆ PreTranslateMessage()
| BOOL32 CRhinoApp::PreTranslateMessage | ( | MSG * | pMsg | ) |
◆ Print() [1/2]
| RHINO_SDK_FUNCTION void ON_VARGS_FUNC_CDECL CRhinoApp::Print | ( | const char * | format, |
| ... | |||
| ) | const |
Print formatted text in the command window.
See ON_String::Format for a description of string formatting.
◆ Print() [2/2]
| RHINO_SDK_FUNCTION void ON_VARGS_FUNC_CDECL CRhinoApp::Print | ( | const wchar_t * | format, |
| ... | |||
| ) | const |
See ON_wString::Format for a description of string formatting.
◆ PrintCommandNameList()
| void CRhinoApp::PrintCommandNameList | ( | bool | is_interactive | ) | const |
Gets a list of command names from Rhino and plug-ins then sorts it and sends it off to be printer.
◆ PrintManager()
| class CRhPrintManager& CRhinoApp::PrintManager | ( | ) |
◆ ProfileContext()
| RHINO_SDK_FUNCTION CRhinoProfileContext& CRhinoApp::ProfileContext | ( | ) |
Description: For expert use only. Gets the default profile context used by Rhino. This is currently the same as calling GetRhinoProfileContext(CRhinoProfileContext::cl_scheme_current_user) Returns: CRhinoProfileContext reference.
◆ ProfileName()
|
pure virtual |
Implemented in MRhinoApp.
◆ PurgeCommand()
| RHINO_SDK_FUNCTION bool CRhinoApp::PurgeCommand | ( | CRhinoCommand * | pCommand, |
| ON_UUID | password | ||
| ) |
Description: Expert user tool to remove commands. Parameters: pCommand - [in] command to purge. password - [in] Contact developer support for the value. Your request must include a working plug-in that demonstrates exactly what the command will do and include a well written justification for why your command should be allowed to replace another command. In addition, you must demonstrate the ability to provide high quality electronic support and rapid electronic updates. If any crashes or unusual things happen when we test your plug-in, your request will be denied. If your request is denied three times, no more requests will be processed. Returns: True if the command is successfully purged.
◆ PushMainMenu()
| bool CRhinoApp::PushMainMenu | ( | ) |
◆ PushStatusBarButton()
Description: Set status bar push button state Parameters: nBntID - [in] Pane ID bIn - [in] TRUE means depress the button otherwise pop it out Returns: TRUE - Status bar exist, nID is valid and state changed FALSE - Status bar window not created or nID is invalid
◆ Realloc()
| RHINO_SDK_FUNCTION void* CRhinoApp::Realloc | ( | void * | , |
| size_t | |||
| ) |
◆ RecordInitInstanceTime()
| RHINO_SDK_FUNCTION void CRhinoApp::RecordInitInstanceTime | ( | const wchar_t * | ) | const |
Plug-in support for startup /stopwatch command line option.
◆ RefreshRhinoLicense()
| RHINO_SDK_FUNCTION bool CRhinoApp::RefreshRhinoLicense | ( | ) |
◆ RegisterCommand()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::RegisterCommand | ( | CRhinoCommand * | pCommand | ) |
Description: Add a command to Rhino. Parameters: pCommand - [in] pointer to a command. This class must NEVER be destroyed. Returns: True if successful. False if command was not added because the pointer was NULL or it was attempting to replace a command with the same UUID, English name, or local name.
◆ RegisterGripsEnabler()
| RHINO_SDK_FUNCTION bool CRhinoApp::RegisterGripsEnabler | ( | CRhinoGripsEnabler * | pCustomGripsInformation | ) |
Description: Add a custom grips updater to Rhino. Parameters: pCustomGripsInformation - [in] Pointer to a CRhinoGripsEnabler class. The class must NEVER be destroyed. Returns: True if successful. False if updater was not added because the UUID was NULL or in use.
◆ RegisterRhinoFactories()
|
protected |
Rhino's version of COleObjectFactory::RegisterAll()
◆ RegistryKey()
|
pure virtual |
Implemented in MRhinoApp.
◆ RegistrySchemeName()
| RHINO_SDK_FUNCTION LPCTSTR CRhinoApp::RegistrySchemeName | ( | ) | const |
Description: String that gets appended to end of build name when opening registry keys.
◆ RememberCopyOption()
| RHINO_SDK_FUNCTION bool CRhinoApp::RememberCopyOption | ( | ) | const |
◆ RemovePageFromObjectPropertiesDialog()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::RemovePageFromObjectPropertiesDialog | ( | class IRhinoPropertiesPanelPage * | pPage | ) |
Description: Remove an existing page page from the object properties dialog. Parameters: pPage - [in] The page to remove from the object properties dialog. Returns: TRUE on success. FALSE on failure. Remarks: The removed page is destroyed with a call to DestroyWindow, but the page is not deleted. The caller is responsible of deleting the page. See also: CRhinoApp::AddPageToObjectPropertiesDialog CRhinoPlugIn::AddPagesToObjectPropertiesDialog
- Deprecated:
- Derive a class from IRhinoAddPropertiesPages in your DLL to add pages, the destructor will remove them automatically
◆ RemovePlugInAddedMenu()
| RHINO_SDK_FUNCTION BOOL32 CRhinoApp::RemovePlugInAddedMenu | ( | HMENU | hmenu, |
| CRhinoPlugIn * | plug_in | ||
| ) |
STEVEBAERV6///< - Need to chat with John about plan for supporting menu in V6.
◆ RepeatCommand()
| MAC_DEPRECATED RHINO_SDK_FUNCTION void CRhinoApp::RepeatCommand | ( | ) |
repeats previous command
◆ RespondToRhinoWindowsMessage()
| bool CRhinoApp::RespondToRhinoWindowsMessage | ( | WPARAM | wParam, |
| LPARAM | lParam | ||
| ) |
DO NOT PUT THIS FUNCTION IN THE PUBLIC SDK.
◆ RestoreControlBars()
| RHINO_SDK_FUNCTION bool CRhinoApp::RestoreControlBars | ( | bool | bRedraw = true, |
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Restores the control bars to their previous state prior to calling "HideControlBars" Parameters: bRedraw [in]: true = redraw and recalculate the main window and layout false = don't do anything after the control bars have been hidden. pDoc [in]: Pointer to the document whose control bars should be hidden. nullptr is used to indicate the current document Returns: true - if any control bars were restored. false - if nothing was done. See Also: CRhinoApp::HideControlBars()
◆ RestoreFullscreen()
| RHINO_SDK_FUNCTION bool CRhinoApp::RestoreFullscreen | ( | const CRhinoDoc * | pDoc = nullptr | ) |
Description: Resets Rhino's main window from fullscreen mode, which got set previously by a call to SetFullscreen()... Parameters: pDoc [in]: Pointer to the document to be shown full screen. nullptr is used to indicated the current document Returns: true - if successfully restored from fullscreen mode. false - if failed to come out of fullscreen mode...or if fullscreen wasn't active in the first place... See Also: CRhinoApp::SetFullscreen() CRhinoApp::RestoreToolBars() CRhinoApp::RestoreeControlBars() CRhinoApp::RestoreWindowBars()
◆ RestoreToolBars()
| RHINO_SDK_FUNCTION bool CRhinoApp::RestoreToolBars | ( | bool | bRedraw = true, |
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Restores the toolbars to their previous state prior to calling "HideToolBars" Parameters: bRedraw [in]: true = redraw and recalculate the main window and layout false = don't do anything after the toolbars have been hidden. pDoc [in]: Pointer to the document whose toolbars should be hidden. nullptr is used to indicate the current document Returns: true - if any toolbars were restored. false - if nothing was done. See Also: CRhinoApp::HideToolBars()
◆ RestoreWindowBars()
| RHINO_SDK_FUNCTION bool CRhinoApp::RestoreWindowBars | ( | bool | bRedraw = true, |
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Restores the window bars to their previous state prior to calling "HideWindowBars" Parameters: bRedraw [in]: true = redraw and recalculate the main window and layout false = don't do anything after the window bars have been hidden. Returns: true - if any window bars were restored. false - if nothing was done. See Also: CRhinoApp::HideWindowBars()
◆ Rhino2_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino2_UUID | ( | ) | const |
◆ Rhino3_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino3_UUID | ( | ) | const |
◆ Rhino4_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino4_UUID | ( | ) | const |
◆ Rhino5_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino5_UUID | ( | ) | const |
◆ Rhino6_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino6_UUID | ( | ) | const |
◆ Rhino7_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino7_UUID | ( | ) | const |
◆ Rhino8_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::Rhino8_UUID | ( | ) | const |
◆ RhinoAbout()
| RHINO_SDK_FUNCTION void CRhinoApp::RhinoAbout | ( | bool | bForceRhinoAbout = false | ) | const |
Description: Call this method to display the Rhino or RhinoSkin about box. Parameters: bForceRhinoAbout - [in] This parameter is only used if Rhino is running in skin mode, see CRhinoSkin for details. If Rhino is in skin mode and this is true then the Rhino about box will display otherwise the skin splash screen will display. See Also: CRhinoSkin class
◆ RhinoCommandLine()
| RHINO_SDK_FUNCTION LPCTSTR CRhinoApp::RhinoCommandLine | ( | ) | const |
Description: Gets the command line used to launch Rhino. Returns: A string like '"C:\Program Files\Rhino 6\System\Rhino.exe" /nosplash "filename.3dm"'.
◆ RhinoCommandManager()
| RHINO_SDK_FUNCTION class CRhinoCommandManager& CRhinoApp::RhinoCommandManager | ( | ) |
Description: The command manager lets you find commands from names and uuids. Returns: Reference to the command manager tool.
◆ RhinoCurrent_UUID()
| RHINO_SDK_FUNCTION ON_UUID CRhinoApp::RhinoCurrent_UUID | ( | ) | const |
RhinoCurrent_UUID() returns the id of "this" version of Rhino. For V5 it is the same as Rhino5_UUID() For V6 it will be the new V6 uuid.
◆ RhinoDirectoryManager()
| RHINO_SDK_FUNCTION CRhinoDirectoryManager& CRhinoApp::RhinoDirectoryManager | ( | ) |
◆ RhinoGetAppRegistryKeyEx()
| RHINO_SDK_FUNCTION HKEY CRhinoApp::RhinoGetAppRegistryKeyEx | ( | int | nMode, |
| int | nProfile = CRhinoProfileContext::cl_scheme_current_user |
||
| ) |
Description: For expert use only. Use profile contexts for reading and writing information that should persist between Rhino sessions. The profile contexts are platform and location independent.
Appropriate profile contexts are: RhinoApp().m_pc_scheme_current_user RhinoApp().m_pc_global_current_user RhinoApp().m_pc_root_local_machine RhinoApp().m_pc_plugins_current_user RhinoApp().m_pc_plugins_local_machine
Get HKEY for \HKEY_LOCAL_MACHINE\Software\McNeel\Rhinoceros<Version><BuildDate> Parameters: nMode - [in] RHINO_READ_REG_MODE = open key for reading only RHINO_WRITE_REG_MODE = open key for writing nProfile - [in] the desired profile type for this registry key. See CRhinoProfileContext::context_location enum for details. Returns: HKEY on success, NULL on error Caller must close returned HKEY with ::RegCloseKey()
◆ RhinoGetGlobalOptionsRegistryKeyEx()
| RHINO_SDK_FUNCTION HKEY CRhinoApp::RhinoGetGlobalOptionsRegistryKeyEx | ( | int | nMode, |
| int | nProfile = CRhinoProfileContext::cl_scheme_current_user |
||
| ) |
Description: For expert use only. Use profile contexts for reading and writing information that should persist between Rhino sessions. The profile contexts are platform and location independent.
Appropriate profile contexts are: RhinoApp().m_pc_scheme_current_user RhinoApp().m_pc_global_current_user RhinoApp().m_pc_root_local_machine RhinoApp().m_pc_plugins_current_user RhinoApp().m_pc_plugins_local_machine
Get HKEY for \HKEY_LOCAL_MACHINE\Software\McNeel\Rhinoceros<Version>\Options Parameters: nMode - [in] RHINO_READ_REG_MODE = open key for reading only RHINO_WRITE_REG_MODE = open key for writing nProfile - [in] the desired profile type for this registry key. See CRhinoProfileContext::context_location enum for details. Returns: HKEY on success, NULL on error Caller must close returned HKEY with ::RegCloseKey()
◆ RhinoGetRootRegistryKeyEx()
| RHINO_SDK_FUNCTION HKEY CRhinoApp::RhinoGetRootRegistryKeyEx | ( | int | nMode, |
| int | nProfile = CRhinoProfileContext::cl_scheme_current_user |
||
| ) |
Description: For expert use only. Use profile contexts for reading and writing information that should persist between Rhino sessions. The profile contexts are platform and location independent.
Appropriate profile contexts are: RhinoApp().m_pc_scheme_current_user RhinoApp().m_pc_global_current_user RhinoApp().m_pc_root_local_machine RhinoApp().m_pc_plugins_current_user RhinoApp().m_pc_plugins_local_machine
Get HKEY for \HKEY_LOCAL_MACHINE\Software\McNeel\Rhinoceros<Version>\ Parameters: nMode - [in] RHINO_READ_REG_MODE = open key for reading only RHINO_WRITE_REG_MODE = open key for writing nProfile - [in] the desired profile type for this registry key. See CRhinoProfileContext::context_location enum for details. Returns: HKEY on success, NULL on error Caller must close returned HKEY with ::RegCloseKey()
◆ RhinoGetSectionKey()
| RHINO_SDK_FUNCTION HKEY CRhinoApp::RhinoGetSectionKey | ( | LPCTSTR | lpszSection, |
| int | nProfile = CRhinoProfileContext::cl_scheme_current_user |
||
| ) |
Description: For expert use only. Use profile contexts for reading and writing information that should persist between Rhino sessions. The profile contexts are platform and location independent.
Appropriate profile contexts are: RhinoApp().m_pc_scheme_current_user RhinoApp().m_pc_global_current_user RhinoApp().m_pc_root_local_machine RhinoApp().m_pc_plugins_current_user RhinoApp().m_pc_plugins_local_machine
Get HKEY for \HKEY_LOCAL_MACHINE\Software\McNeel\Rhinoceros<Version><BuildDate><lpsSectionName> Parameters: lpszSection - [in] - sub key to create or open nProfile - [in] the desired profile type for this registry key. See CRhinoProfileContext::context_location enum for details. Returns: HKEY on success, NULL on error Caller must close returned HKEY with ::RegCloseKey()
◆ RhinoGetSectionKeyEx()
| RHINO_SDK_FUNCTION HKEY CRhinoApp::RhinoGetSectionKeyEx | ( | LPCTSTR | lpszSection, |
| int | nMode, | ||
| int | nProfile = CRhinoProfileContext::cl_scheme_current_user |
||
| ) |
Description: For expert use only. Use profile contexts for reading and writing information that should persist between Rhino sessions. The profile contexts are platform and location independent.
Appropriate profile contexts are: RhinoApp().m_pc_scheme_current_user RhinoApp().m_pc_global_current_user RhinoApp().m_pc_root_local_machine RhinoApp().m_pc_plugins_current_user RhinoApp().m_pc_plugins_local_machine
Get HKEY for \HKEY_LOCAL_MACHINE\Software\McNeel\Rhinoceros<Version><BuildDate><lpsSectionName> Parameters: lpszSection - [in] - sub key to create or open nMode - [in] RHINO_READ_REG_MODE = open key for reading only RHINO_WRITE_REG_MODE = open key for writing nProfile - [in] the desired profile type for this registry key. See CRhinoProfileContext::context_location enum for details. Returns: HKEY on success, NULL on error Caller must close returned HKEY with ::RegCloseKey()
◆ RhinoInstanceHandle()
| RHINO_SDK_FUNCTION HINSTANCE CRhinoApp::RhinoInstanceHandle | ( | ) | const |
Description: Get Rhino HINSTANCE Returns: Rhino application's HINSTANCE
◆ RhinoMfcDocTemplate()
| CDocTemplate* CRhinoApp::RhinoMfcDocTemplate | ( | ) |
Returns: For the Rhino application there is a single CDocTemplate. and this function returns a pointer to that MFC CDocTemplate. The CDocTemplate class is needed in low level application code that manages CRhinoDoc objects.
Remarks: Do not export this function. If we ever end up having two or more document templates, this function will be deleted and all code that uses this function will need to be upgraded.
◆ RhinoModuleState()
| RHINO_SDK_FUNCTION AFX_MODULE_STATE* CRhinoApp::RhinoModuleState | ( | ) | const |
Description: Gets the module state of the Rhino core executable. Using this information is for advanced, skilled, and very careful developers. You are probably best off pretending this does not exist. It is exported just in case somebody needs this low level information in a plug-in situation that we have yet to discover. Returns: Rhino core executable module state.
◆ RhinoRenderPlugInUUID()
| RHINO_SDK_FUNCTION UUID CRhinoApp::RhinoRenderPlugInUUID | ( | ) | const |
Return UUID for the one and only Rhino system render plug-in.
◆ RhinoResourceHandle()
| HINSTANCE CRhinoApp::RhinoResourceHandle | ( | ) |
◆ RhinoUiManager()
| RHINO_SDK_FUNCTION class CRhinoAppUiManager& CRhinoApp::RhinoUiManager | ( | ) | const |
Description: Rhino UI library, paint and tool/control bar managers.
◆ RhinoUiPaintManager()
| RHINO_SDK_FUNCTION class CRhinoUiPaintManager& CRhinoApp::RhinoUiPaintManager | ( | ) | const |
Description: Rhino UI library paint manager
◆ RhinoUiResourceManager()
| RHINO_SDK_FUNCTION class CRhinoAppUiResourceManager& CRhinoApp::RhinoUiResourceManager | ( | ) | const |
Description: Rhino UI library resource manager
◆ RhSkin()
| RHINO_SDK_FUNCTION class CRhSkin& CRhinoApp::RhSkin | ( | ) | const |
◆ RunAsServer()
| RHINO_SDK_FUNCTION bool CRhinoApp::RunAsServer | ( | ) |
Description: Determines if Rhino is running as a server. If Rhino.exe is started with the command line switch "/server" then Rhino will run in server mode. This means that no UI or command Windows task bar icon are displayed.
It is assumed that the caller is running a script or plug-in that will close Rhino when finished. Rhino will not close itself. Returns: Returns true if Rhino is running invisibly as a server. Otherwise false.
◆ RunMenuScript() [1/2]
| RHINO_SDK_FUNCTION bool CRhinoApp::RunMenuScript | ( | const wchar_t * | script | ) |
Description: Run a Rhino menu item script. Will add the selected menu string to the MRU command menu. Parameters: script - [in] script to run Remarks: Rhino acts as if each character in the script string had been typed in the command prompt.
◆ RunMenuScript() [2/2]
| RHINO_SDK_FUNCTION bool CRhinoApp::RunMenuScript | ( | unsigned int | rhino_doc_sn, |
| const wchar_t * | script | ||
| ) |
◆ RunMruCommand()
| MAC_DEPRECATED void CRhinoApp::RunMruCommand | ( | int | cmd_index | ) |
Description: Called by CMruCommandMenu::MruCmd() to run a m_mru_command_list command macro. Will move the macro from its current list position to top of display list. Parameters: cmd_index - [in] command macro to run
◆ RunMruFavoriteCommand()
| MAC_DEPRECATED void CRhinoApp::RunMruFavoriteCommand | ( | int | cmd_index | ) |
Description: Called by CMruCommandMenu::Favorite() to run a CRhinoAppGeneralSettings.m_popup_favorites macro. Will make sure command does not show up on the MRU list Parameters: cmd - [in] m_mru_command_list index of command to run
◆ RunningCommand()
| MAC_DEPRECATED const RHINO_SDK_FUNCTION CRhinoCommand* CRhinoApp::RunningCommand | ( | int | i | ) | const |
Description: When script running or nestable commands are running, there can be more than one command running at a given time. The private array m_running_commands_stack[] keeps track of all the commands that are running. The one on the end of the array is the "active" command. You really should not be using this function, except when you are forced to hack around a sticky situation that requires you to know when a certain command (like a base level script running command) may be active. Parameters: i - [in] 0 based index. Returns: Pointer to command.
◆ RunScript() [1/2]
| RHINO_SDK_FUNCTION bool CRhinoApp::RunScript | ( | const CRhinoScriptContext & | script_context | ) |
◆ RunScript() [2/2]
| RHINO_SDK_FUNCTION bool CRhinoApp::RunScript | ( | unsigned int | rhino_doc_sn, |
| const wchar_t * | script, | ||
| int | echo_mode = 1 |
||
| ) |
Description: Run a Rhino command script. Parameters: rhino_doc_sn - [in] 0: document unknown - used application default >0: document to begin script in (a script can create and destroy many docs) script - [in] script to run echo_mode - [in] Controls how the script is echoed in the command output window. 0 = silent - nothing is echoed 1 = verbatim - the script is echoed literally Remarks: Rhino acts as if each character in the script string had been typed in the command prompt. When RunScript is called from a "script runner" command, it completely runs the script before returning. When RunScript is called outside of a command, it returns and the script is run. This way menus and buttons can use RunScript to execute complicated functions.
◆ RunScriptEx()
| RHINO_SDK_FUNCTION bool CRhinoApp::RunScriptEx | ( | unsigned int | rhino_doc_sn, |
| const wchar_t * | script, | ||
| const wchar_t * | mruDisplayString, | ||
| int | echo_mode = 1 |
||
| ) |
Description: Run a Rhino command script. Parameters: rhino_doc_sn - [in] 0: document unknown - used application default >0: document to begin script in (a script can create and destroy many docs) script - [in] script to run mruDisplayString - [in] If this is a valid string then the macro is added to the MRU command list using this string, if it is NULL or an empty string then false is returned. echo_mode - [in] Controls how the script is echoed in the command output window. 0 = silent - nothing is echoed 1 = verbatim - the script is echoed literally Remarks: Rhino acts as if each character in the script string had been typed in the command prompt. When RunScript is called from a "script runner" command, it completely runs the script before returning. When RunScript is called outside of a command, it returns and the script is run. This way menus and buttons can use RunScript to execute complicated functions.
◆ SaveAllModified()
| BOOL32 CRhinoApp::SaveAllModified | ( | ) |
save before exit
◆ SavedMainMenu()
| HMENU CRhinoApp::SavedMainMenu | ( | ) | const |
◆ SdkServiceRelease()
| RHINO_SDK_FUNCTION unsigned int CRhinoApp::SdkServiceRelease | ( | ) | const |
Description: Service release of the Rhino SDK supported by this executable. Rhino will only load plug-ins that require a service release of <= this release number.
For example, SR1 will load all plug-ins made with any SDK released up through and including the SR1 SDK. But, SR1 will not load a plug-in built using the SR2 SDK. If an "old" Rhino tries to load a "new" plug-in, the user is told that they have to get a free Rhino.exe update in order for the plug-in to load. Rhino.exe updates are available from http://www.rhino3d.com. Returns: Rhino SDK 9 digit SDK service release number in the form YYYYMMDDn See Also: CRhinoApp::SdkVersion CRhinoApp::ExeVersion CRhinoApp::ExeServiceRelease
◆ SdkVersion()
| RHINO_SDK_FUNCTION unsigned int CRhinoApp::SdkVersion | ( | ) | const |
Description: Base version of the Rhino SDK supported by this Rhino executable. Rhino will only load plug-ins that were build with exactly the same version of the SDK. Returns: Rhino SDK 9 digit SDK version number in the form YYYYMMDDn See Also: CRhinoApp::SdkServiceRelease CRhinoApp::ExeVersion CRhinoApp::ExeServiceRelease
◆ SendCharToCommandWnd()
| void CRhinoApp::SendCharToCommandWnd | ( | UINT | nChar, |
| UINT | nRepCnt, | ||
| UINT | nFlags | ||
| ) | const |
low level tool used to send keyboard events to command window
◆ SendCommandWindowPrintToConsole()
| RHINO_SDK_FUNCTION bool CRhinoApp::SendCommandWindowPrintToConsole | ( | bool | enabled | ) |
Description: Enable or disable console output for print statements Returns: Previous enabled state for console printing
◆ SendCommandWindowPrintToConsoleEnabled()
| RHINO_SDK_FUNCTION bool CRhinoApp::SendCommandWindowPrintToConsoleEnabled | ( | ) | const |
Description: Returns true if command window print statements are being sent to the console. Useful for headless mode
◆ SendKeyDownToCommandWnd()
| void CRhinoApp::SendKeyDownToCommandWnd | ( | UINT | nChar, |
| UINT | nRepCnt, | ||
| UINT | nFlags | ||
| ) | const |
◆ SerialNumber()
| RHINO_SDK_FUNCTION ON_wString CRhinoApp::SerialNumber | ( | ) |
Returns: The product serial number, as seen in Rhino's ABOUT dialog box.
See Also: CRhinoApp::NodeType CRhinoApp::InstallationType
◆ SetActiveView()
| RHINO_SDK_FUNCTION void CRhinoApp::SetActiveView | ( | CRhinoView * | ) | const |
Active view (can be NULL if a file is being read and no views have been created)
◆ SetActiveViewport()
| RHINO_SDK_FUNCTION void CRhinoApp::SetActiveViewport | ( | ON_UUID | viewport_id | ) |
Description: Set the active viewport by id (may be the viewport id of a detail object on a page) Note: This can be much slower than the SetActiveView() command. If you can get away with just calling SetActiveView(), do that.
◆ SetAllowActivateCommandWindowCaret()
| bool CRhinoApp::SetAllowActivateCommandWindowCaret | ( | bool | b = true | ) |
◆ SetAppName()
|
pure virtual |
Implemented in MRhinoApp.
◆ SetCommandPrompt() [1/2]
| RHINO_SDK_FUNCTION void CRhinoApp::SetCommandPrompt | ( | const wchar_t * | prompt, |
| const wchar_t * | prompt_default, | ||
| const ON_ClassArray< CRhinoCommandOption > & | options | ||
| ) |
Description: Set Rhino command prompt. Parameters: prompt - [in] prompt prompt_default - [in] text that appears in angle brackets and indicates what will happen if the user pressed ENTER. options - [in] command options
◆ SetCommandPrompt() [2/2]
| RHINO_SDK_FUNCTION void CRhinoApp::SetCommandPrompt | ( | const wchar_t * | prompt, |
| const wchar_t * | prompt_default = nullptr |
||
| ) |
Description: Set Rhino command prompt. Parameters: prompt - [in] prompt prompt_default - [in] text that appears in angle brackets and indicates what will happen if the user pressed ENTER.
◆ SetCommandPromptMessage()
| RHINO_SDK_FUNCTION void CRhinoApp::SetCommandPromptMessage | ( | const wchar_t * | sMessage | ) |
Setting command window prompt.
Description: Set the text that appears in the Rhino command prompt. Parameters: sMessage - [in] literal text for the command prompt window. Remarks: In general, you should use the CRhinoApp::SetCommandPrompt functions. The create a prompt that is correctly formatted. In rare cases, like worker thread messages, the message that appears in the prompt has non-standard formatting. In these rare cases, SetCommandPromptMessage can be used to literally specify the text that appears in the command prompt window.
◆ SetCommandToRepeat()
|
protected |
◆ SetCommandWindowText()
| void CRhinoApp::SetCommandWindowText | ( | const wchar_t * | = nullptr | ) |
◆ SetCursorToolTip()
| RHINO_SDK_FUNCTION void CRhinoApp::SetCursorToolTip | ( | const ON_wString & | ) |
Description: Sets a cursor tool-tip string shown next to the mouse cursor. Overrides all cursor tool-tip panes.
◆ SetCursorToolTipNumberPane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetCursorToolTipNumberPane | ( | double | d, |
| bool | bAutoFormatDistance = true |
||
| ) |
Description: Sets tooltip number pane.
◆ SetCursorToolTipOsnapPane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetCursorToolTipOsnapPane | ( | CRhinoAppSettings::osnap_mode | ) |
Description: Sets tooltip osnap pane.
◆ SetCursorToolTipPane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetCursorToolTipPane | ( | CRhinoApp::cursor_tooltip_pane | , |
| const ON_wString & | |||
| ) |
Description: Sets tooltip pane. Can be used as an override to set any pane to any string.
◆ SetCursorToolTipPointPane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetCursorToolTipPointPane | ( | ON_3dPoint | point, |
| const ON_Plane * | plane = nullptr |
||
| ) |
Description: Sets tooltip point pane.
◆ SetCursorToolTipPromptPane()
| void CRhinoApp::SetCursorToolTipPromptPane | ( | const ON_wString & | ) |
Description: Sets tooltip prompt pane.
◆ SetDefaultRenderApp() [1/2]
| RHINO_SDK_FUNCTION bool CRhinoApp::SetDefaultRenderApp | ( | ON_UUID & | uuid | ) |
Description: Set default render application Parameters: uuid - [in] ID of render plug-in. Returns: true - If plug-in found and loaded successfully false - If ID is invalid or was unable to load plug-in
◆ SetDefaultRenderApp() [2/2]
|
protected |
Special version of SetDefaultRenderApp called by InitInstance. Not exported.
◆ SetFileReadOptions()
| void CRhinoApp::SetFileReadOptions | ( | const class CRhFileReadOptions & | ) |
◆ SetFullscreen()
| RHINO_SDK_FUNCTION bool CRhinoApp::SetFullscreen | ( | UINT | nCBMask, |
| UINT | nWBMask, | ||
| int | nDockState, | ||
| const CRhinoDoc * | pDoc = nullptr |
||
| ) |
Description: Sets Rhino's main window fullscreen mode. Parameters: nCBMask [in]: Control bar bit mask indicating which control bars to hide. If the corresponding bit is ON, then that control bar will be hidden (see description above for control bar bit values). nWBMask [in]: Window bar bit mask indicating which window bars to hide. If the corresponding bit is ON, then that window bar will be hidden (see description above for window bar bit values). nDockState [in]: 0 = hide control bars regardless of dock state 1 = hide only DOCKED control bars 2 = hide only FLOATING control bars pDoc [in]: Pointer to the document to be shown full screen. nullptr is used to indicate the current document Returns: true - if fullscreen mode was successfully set. false - if fullscreen mode failed to get set.
See Also: CRhinoApp::RestoreFullscreen() CRhinoApp::HideToolBars() CRhinoApp::HideControlBars() CRhinoApp::HideWindowBars()
◆ SetMruMenuString()
|
protected |
◆ SetNoCancelOnMainFrameClose()
| void CRhinoApp::SetNoCancelOnMainFrameClose | ( | bool | b | ) |
◆ SetRememberCopyOption()
| RHINO_SDK_FUNCTION void CRhinoApp::SetRememberCopyOption | ( | bool | b | ) |
◆ SetStatusBarDistancePane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetStatusBarDistancePane | ( | double | dist, |
| bool | bAutoFormatDistancePane = true |
||
| ) |
Setting command window prompt.
◆ SetStatusBarMessagePane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetStatusBarMessagePane | ( | const wchar_t * | ) |
pass NULL to clear message pane
◆ SetStatusBarNumberPane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetStatusBarNumberPane | ( | double | angle | ) |
◆ SetStatusBarPointPane()
| RHINO_SDK_FUNCTION void CRhinoApp::SetStatusBarPointPane | ( | const ON_3dPoint & | , |
| const ON_Plane * | pPane = nullptr |
||
| ) |
◆ StartedAsRhinoExe()
| RHINO_SDK_FUNCTION bool CRhinoApp::StartedAsRhinoExe | ( | ) | const |
Description: Returns true if Rhino was started as a standalone executable application (Rhino.exe). Returns false if Rhino was started by another application or process (Rhino.Inside).
◆ StatusBar()
| class CRhinoStatusBar* CRhinoApp::StatusBar | ( | ) | const |
◆ StatusBarProgressMeterEnd()
| RHINO_SDK_FUNCTION void CRhinoApp::StatusBarProgressMeterEnd | ( | ) |
Description: Ends, or hides, Rhino's status bar progress meter. See Also: CRhinoApp::StatusBarProgressMeterStart CRhinoApp::StatusBarProgressMeterPos
◆ StatusBarProgressMeterPos()
| RHINO_SDK_FUNCTION int CRhinoApp::StatusBarProgressMeterPos | ( | int | nPos, |
| bool | bAbsolute = true |
||
| ) |
Description: Sets the current position of Rhino's status bar progress meter. Parameters: nPos - [in] The position. bAbsolute - [in] If true, then the progress meter is moved to nPos (absolute). If false, then the progress meter is moved nPos from the current position (relative). Returns: The previous position if successful. See Also: CRhinoApp::StatusBarProgressMeterStart CRhinoApp::StatusBarProgressMeterEnd
◆ StatusBarProgressMeterStart()
| RHINO_SDK_FUNCTION int CRhinoApp::StatusBarProgressMeterStart | ( | int | nLower, |
| int | nUpper, | ||
| const wchar_t * | pszLabel = nullptr, |
||
| bool | bEmbedLabel = true, |
||
| bool | bShowPercent = true |
||
| ) |
Description: Starts, or shows, Rhino's status bar progress meter. Parameters: nLower - [in] The lower limit of the progress meter's range. nUpper - [in] The upper limit of the progress meter's range. pszLabel - [in] The short description of the progress (e.g. "Calculating", "Meshing", etc). bEmbedLabel - [in] If true, then the label will be embedded in the progress meter. If false, then the label will appear to the left of the progress meter. bShowPercent - [in] If true, then the percent complete will appear in the progress meter. Returns: 1 - The progress meter was created successfully. 0 - The progress meter was not created. -1 - The progress meter was not created because some other process has already created it. See Also: CRhinoApp::StatusBarProgressMeterPos CRhinoApp::StatusBarProgressMeterEnd
◆ StringTables()
| class CStringTableCollection& CRhinoApp::StringTables | ( | ) |
◆ StringTablesInitialized()
| bool CRhinoApp::StringTablesInitialized | ( | ) | const |
◆ TextureManager()
| RHINO_SDK_FUNCTION class CRhTextureManager& CRhinoApp::TextureManager | ( | ) |
Description: Rhino central Texture manager.
◆ ThreadManager()
|
pure virtual |
Implemented in MRhinoApp.
◆ UpdateCursorToolTipLocation()
| bool CRhinoApp::UpdateCursorToolTipLocation | ( | const ON_2iPoint & | pt | ) |
Description: Updates cursor tooltip location. Called internally by CRhinoView::OnMouseMove.
◆ UpdateNotesWindow()
| void CRhinoApp::UpdateNotesWindow | ( | unsigned int | rhino_doc_sn | ) |
Description: Make contents of Notes dialog match doc's notes
◆ UpdatesAndStatisticsStatus()
| RHINO_SDK_FUNCTION int CRhinoApp::UpdatesAndStatisticsStatus | ( | ) |
Returns: 2 if Updates and Statistics are disabled by administrator 1 if Updates and Statistics are disabled by current user 0 if Updates and Statistics are enabled
◆ UseNetCoreRuntime()
| bool CRhinoApp::UseNetCoreRuntime | ( | ) |
◆ ValidationGracePeriodDaysLeft()
| RHINO_SDK_FUNCTION int CRhinoApp::ValidationGracePeriodDaysLeft | ( | ) |
Returns number of days within which validation must occur. Zero when validation grace period has expired. Raises InvalidLicenseTypeException if LicenseType is one of: EvaluationSaveLimited EvaluationTimeLimited Viewer Unknown
◆ ViewDisableSetActiveView()
| bool CRhinoApp::ViewDisableSetActiveView | ( | ) | const |
◆ ViewerOnlyMode()
|
inline |
Description: 29-November 2012 This flag gets set by starting Rhino with the "/viewer" switch, if this is true then Rhino will NOT allow you to save anything, it will act similar to an expired evaluation version. Returns: Returns true if Rhino is running as a viewer only otherwise; returns false. BG 2012-12-06: Let's not export this yet, as we may get rid of it completely RHINO_SDK_FUNCTION
◆ ViewSetDisableSetActiveView()
| bool CRhinoApp::ViewSetDisableSetActiveView | ( | bool | b | ) |
◆ ViewWndClassName()
| LPCTSTR CRhinoApp::ViewWndClassName | ( | ) | const |
CRhinoView window class name.
◆ Wait()
| RHINO_SDK_FUNCTION void CRhinoApp::Wait | ( | DWORD | dwMilliseconds | ) |
Description: Pause for specified time but keep Windows message pump alive so views will update and windows will repaint Parameters: dwMilliseconds - [in] - wait time in milliseconds
◆ WinAppOnFileNew()
|
protected |
TODO: remove this, temp hack to access private CWinApp func.
◆ WindowPositionsProfileContext()
| RHINO_SDK_FUNCTION CRhinoProfileContext& CRhinoApp::WindowPositionsProfileContext | ( | ) |
Description: For expert use only. Gets the profile context used by Rhino when saving window and dock bar position information. Returns: CRhinoProfileContext reference.
◆ WorkSession()
| class CRhWorkSession* CRhinoApp::WorkSession | ( | ) | const |
Temporary - this should not be on CRhinoApp.
Friends And Related Function Documentation
◆ CMainFrame
|
friend |
< All friends should be here
◆ CRhAppSettingsUiWatcher
|
friend |
◆ CRhino3SplashWnd
|
friend |
◆ CRhinoAppFonts
|
friend |
◆ CRhinoFileMenu
|
friend |
◆ RhOnWmDisplayChange
|
friend |
Member Data Documentation
◆ m_activate_command_caret
|
protected |
Enable/disable focus shift from view to
◆ m_app_fro
|
protected |
The CRhinoApp::FileReadOptions() functions return references to m_app_fro which is the V5 replacement for CRhinoApp::m_FileReadeOptions. See comments at the beginning of CRhinoApp::CRhinoApp() for more details.
◆ m_app_fro_buffer
|
protected |
◆ m_arrow_command_cursor
| HCURSOR CRhinoApp::m_arrow_command_cursor = nullptr |
◆ m_arrow_copy_cursor
| HCURSOR CRhinoApp::m_arrow_copy_cursor = nullptr |
arrow with "+"
◆ m_bCursorToolTip
|
protected |
◆ m_bInFullscreen
|
protected |
command rich edit control. Used mainly by dialogs that allow view manipulation (semi-modal dialogs)
◆ m_bInViewNavigation
|
protected |
◆ m_bNoCancelOnMainFrameClose
|
protected |
◆ m_bRememberCopyOption
|
protected |
This looks like it should be on app settings.
◆ m_bRestoreFromFullscreen
|
protected |
◆ m_bSafeModeEnabled
|
protected |
◆ m_cen_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_cen_osnap_arrow_cursor = nullptr |
◆ m_cen_osnap_cursor
| HCURSOR CRhinoApp::m_cen_osnap_cursor = nullptr |
◆ m_command_manager
|
protected |
◆ m_CommandLineLoadGrasshopperFileName
|
protected |
◆ m_CommandLineLoadScriptFileName
|
protected |
Initialized by CRhinoApp::RhinoProcessShellCommand if a RVB file is passed to the Rhino executable at start-up. This file will get loaded after InitInstance completes successfully by CRhinoApp::RespondToRhinoWindowsMessage()
◆ m_context_menu_cursor
| HCURSOR CRhinoApp::m_context_menu_cursor = nullptr |
◆ m_cross_hair_copy_cursor
| HCURSOR CRhinoApp::m_cross_hair_copy_cursor = nullptr |
◆ m_cross_hair_cursor
| HCURSOR CRhinoApp::m_cross_hair_cursor = nullptr |
◆ m_cursor
| HCURSOR CRhinoApp::m_cursor = nullptr |
current cursor
◆ m_custom_grips
|
protected |
◆ m_default_cursor
| HCURSOR CRhinoApp::m_default_cursor = nullptr |
Steve - I would like to eventually make these private and accessible through functions.
◆ m_default_render_plug_in
|
protected |
◆ m_dir_manager
|
protected |
◆ m_disable_set_active_view
|
protected |
used by CRhinoView::OnMouseMove to disable setting active view when tracking mouse
◆ m_end_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_end_osnap_arrow_cursor = nullptr |
◆ m_end_osnap_cursor
| HCURSOR CRhinoApp::m_end_osnap_cursor = nullptr |
◆ m_FileMenu
|
protected |
File menu options;.
◆ m_focus_osnap_cursor
| HCURSOR CRhinoApp::m_focus_osnap_cursor = nullptr |
◆ m_hand_cursor
| HCURSOR CRhinoApp::m_hand_cursor = nullptr |
◆ m_hand_snap_cursor
| HCURSOR CRhinoApp::m_hand_snap_cursor = nullptr |
◆ m_hParentMenu
|
protected |
◆ m_hyperlink_cursor
| HCURSOR CRhinoApp::m_hyperlink_cursor = nullptr |
◆ m_int_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_int_osnap_arrow_cursor = nullptr |
◆ m_int_osnap_cursor
| HCURSOR CRhinoApp::m_int_osnap_cursor = nullptr |
◆ m_knot_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_knot_osnap_arrow_cursor = nullptr |
◆ m_knot_osnap_cursor
| HCURSOR CRhinoApp::m_knot_osnap_cursor = nullptr |
◆ m_lazyptr_app_settings
|
protected |
lazyptr classes are created the first time they are requested more of the above items should be lazily created... work in progress
◆ m_lazyptr_autosave
|
protected |
◆ m_lazyptr_custom_menu_manager
|
protected |
◆ m_lazyptr_digitizer_manager
|
protected |
◆ m_lazyptr_docview_manager
|
protected |
◆ m_lazyptr_license_manager
|
protected |
◆ m_lazyptr_palette_manager
|
protected |
◆ m_lazyptr_plug_in_manager
|
protected |
◆ m_lazyptr_print_manager
|
protected |
◆ m_lazyptr_texture_manager
|
protected |
◆ m_lazyptr_work_session
|
protected |
◆ m_magnify_cursor
| HCURSOR CRhinoApp::m_magnify_cursor = nullptr |
◆ m_magnify_snap_cursor
| HCURSOR CRhinoApp::m_magnify_snap_cursor = nullptr |
◆ m_mid_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_mid_osnap_arrow_cursor = nullptr |
◆ m_mid_osnap_cursor
| HCURSOR CRhinoApp::m_mid_osnap_cursor = nullptr |
◆ m_near_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_near_osnap_arrow_cursor = nullptr |
◆ m_near_osnap_cursor
| HCURSOR CRhinoApp::m_near_osnap_cursor = nullptr |
◆ m_object_perp_osnap_cursor
| HCURSOR CRhinoApp::m_object_perp_osnap_cursor = nullptr |
◆ m_object_tan_osnap_cursor
| HCURSOR CRhinoApp::m_object_tan_osnap_cursor = nullptr |
◆ m_oncrv_osnap_cursor
| HCURSOR CRhinoApp::m_oncrv_osnap_cursor = nullptr |
◆ m_onmesh_osnap_cursor
| HCURSOR CRhinoApp::m_onmesh_osnap_cursor = nullptr |
◆ m_onsrf_osnap_cursor
| HCURSOR CRhinoApp::m_onsrf_osnap_cursor = nullptr |
◆ m_pAppFonts
| class CRhinoAppFonts* CRhinoApp::m_pAppFonts |
◆ m_pc_scheme_current_user
|
protected |
Moving profile context to protected section, these should be accessed using the CRhinoApp::GetRhinoProfileContext(CRhinoProfileContext::context_location) method
◆ m_pc_window_positions
|
protected |
Attaches to the CRhAppSettings::WindowPostions() settings.
◆ m_pCursorToolTip
|
protected |
◆ m_perp_osnap_cursor
| HCURSOR CRhinoApp::m_perp_osnap_cursor = nullptr |
◆ m_PlugInFileExportDisplayList
|
protected |
◆ m_PlugInFileImportDisplayList
|
protected |
◆ m_point_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_point_osnap_arrow_cursor = nullptr |
Current drag base point osnap cursors (arrow cursor and osnap label)
◆ m_point_osnap_cursor
| HCURSOR CRhinoApp::m_point_osnap_cursor = nullptr |
Current osnap cursors.
◆ m_pRhinoSkin
|
protected |
◆ m_pRhinoUiManager
|
protected |
◆ m_prohibit_cursor
| HCURSOR CRhinoApp::m_prohibit_cursor = nullptr |
circle with slash
◆ m_pSplash
| class CRhino3Splash* CRhinoApp::m_pSplash = nullptr |
◆ m_quad_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_quad_osnap_arrow_cursor = nullptr |
◆ m_quad_osnap_cursor
| HCURSOR CRhinoApp::m_quad_osnap_cursor = nullptr |
◆ m_rhino_app_ticker
|
protected |
When something happens, like a command is run or lots of other stuff, the value of m_rhino_app_ticker is incremented by calling CRhinoApp::IncrementRhinoAppTicker(). The value of m_rhino_app_ticker is used to determine when Rhino has been "idle" long enough that we can risk calling "onidle" event watchers.
◆ m_rotate_cursor
| HCURSOR CRhinoApp::m_rotate_cursor = nullptr |
◆ m_RunAsViewerOnly
|
protected |
29-November 2012 John Morse - If true then run like an expired evaluation version (no saves) This is set with the "/viewer" command line switch and is "false" by default
◆ m_save_menu
|
protected |
◆ m_sCurrentMenuLabel
|
protected |
◆ m_sParentMenuLabel
|
protected |
◆ m_sSchemeName
|
protected |
◆ m_string_tables
|
protected |
◆ m_sViewWndClass
|
protected |
◆ m_tan_osnap_cursor
| HCURSOR CRhinoApp::m_tan_osnap_cursor = nullptr |
◆ m_tiCursorToolTip
|
protected |
◆ m_unused
|
protected |
◆ m_vertex_osnap_arrow_cursor
| HCURSOR CRhinoApp::m_vertex_osnap_arrow_cursor = nullptr |
◆ m_vertex_osnap_cursor
| HCURSOR CRhinoApp::m_vertex_osnap_cursor = nullptr |
◆ m_wait_cursor
| HCURSOR CRhinoApp::m_wait_cursor = nullptr |
◆ m_wCursorToolTip
|
protected |
◆ m_wCursorToolTipPanes
|
protected |
◆ m_WP
|
protected |
WARNING: Do not add public data fields to CRhinoApp below this line.
TODO: Steve. work with John M to see if m_WP is really needed at all anymore. It does not appear to be saved between sessions.
