Changeset 75361 in vbox

Timestamp:

Nov 9, 2018 12:56:40 PM (6 years ago)

Author:

vboxsync

Message:

Recording/Main: Renamed the IRecord* interfaces again to IRecording* to make it more standardized.

Location:

trunk

Files:

• include/VBox/log.h (modified) (2 diffs)
• include/VBox/settings.h (modified) (8 diffs)
• src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp (modified) (2 diffs)
• src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp (modified) (10 diffs)
• src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp (modified) (2 diffs)
• src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp (modified) (7 diffs)
• src/VBox/Frontends/VirtualBox/src/globals/UIMainEventListener.cpp (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/src/manager/details/UIDetailsElements.cpp (modified) (2 diffs)
• src/VBox/Frontends/VirtualBox/src/runtime/UIConsoleEventHandler.cpp (modified) (1 diff)
• src/VBox/Frontends/VirtualBox/src/runtime/UIIndicatorsPool.cpp (modified) (4 diffs)
• src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp (modified) (2 diffs)
• src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp (modified) (2 diffs)
• src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp (modified) (10 diffs)
• src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotDetailsWidget.cpp (modified) (2 diffs)
• src/VBox/Main/Makefile.kmk (modified) (1 diff)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (21 diffs)
• src/VBox/Main/include/ConsoleImpl.h (modified) (2 diffs)
• src/VBox/Main/include/DrvAudioRec.h (modified) (2 diffs)
• src/VBox/Main/include/MachineImpl.h (modified) (5 diffs)
• src/VBox/Main/include/Recording.h (modified) (5 diffs)
• src/VBox/Main/include/RecordingScreenSettingsImpl.h (moved) (moved from trunk/src/VBox/Main/include/RecordScreenSettingsImpl.h ) (8 diffs)
• src/VBox/Main/include/RecordingSettingsImpl.h (moved) (moved from trunk/src/VBox/Main/include/RecordSettingsImpl.h ) (4 diffs)
• src/VBox/Main/include/RecordingStream.h (modified) (5 diffs)
• src/VBox/Main/include/SessionImpl.h (modified) (1 diff)
• src/VBox/Main/src-client/ConsoleImpl.cpp (modified) (12 diffs)
• src/VBox/Main/src-client/DisplayImpl.cpp (modified) (2 diffs)
• src/VBox/Main/src-client/DrvAudioRec.cpp (modified) (2 diffs)
• src/VBox/Main/src-client/Recording.cpp (modified) (6 diffs)
• src/VBox/Main/src-client/RecordingStream.cpp (modified) (16 diffs)
• src/VBox/Main/src-client/SessionImpl.cpp (modified) (1 diff)
• src/VBox/Main/src-server/MachineImpl.cpp (modified) (12 diffs)
• src/VBox/Main/src-server/RecordingScreenSettingsImpl.cpp (moved) (moved from trunk/src/VBox/Main/src-server/RecordScreenSettingsImpl.cpp ) (51 diffs)
• src/VBox/Main/src-server/RecordingSettingsImpl.cpp (moved) (moved from trunk/src/VBox/Main/src-server/RecordSettingsImpl.cpp ) (31 diffs)
• src/VBox/Main/src-server/SnapshotImpl.cpp (modified) (2 diffs)
• src/VBox/Main/xml/Settings.cpp (modified) (18 diffs)

trunk/include/VBox/log.h

@@ -594 +594 @@
     /** Main group, IProgressTaskCompletedEvent. */
     LOG_GROUP_MAIN_PROGRESSTASKCOMPLETEDEVENT,
-    /** Main group, IRecordChangedEvent. */
-    LOG_GROUP_MAIN_RECORDCHANGEDEVENT,
-    /** Main group, IRecordSettings. */
-    LOG_GROUP_MAIN_RECORDSETTINGS,
-    /** Main group, IRecordScreenSettings. */
-    LOG_GROUP_MAIN_RECORDSCREENSETTINGS,
+    /** Main group, IRecordingChangedEvent. */
+    LOG_GROUP_MAIN_RECORDINGCHANGEDEVENT,
+    /** Main group, IRecordingSettings. */
+    LOG_GROUP_MAIN_RECORDINGSETTINGS,
+    /** Main group, IRecordingScreenSettings. */
+    LOG_GROUP_MAIN_RECORDINGSCREENSETTINGS,
     /** Main group, IReusableEvent. */
     LOG_GROUP_MAIN_REUSABLEEVENT,
@@ -1124 +1124 @@
     "MAIN_PROGRESSPERCENTAGECHANGEDEVENT", \
     "MAIN_PROGRESSTASKCOMPLETEDEVENT", \
-    "MAIN_RECORDCHANGEDEVENT", \
-    "MAIN_RECORDSETTINGS", \
-    "MAIN_RECORDSCREENSETTINGS", \
+    "MAIN_RECORDINGCHANGEDEVENT", \
+    "MAIN_RECORDINGSETTINGS", \
+    "MAIN_RECORDINGSCREENSETTINGS", \
     "MAIN_REUSABLEEVENT", \
     "MAIN_RUNTIMEERROREVENT", \

trunk/include/VBox/settings.h

@@ -482 +482 @@
 
 /** List for keeping a recording feature list. */
-typedef std::map<RecordFeature_T, bool> RecordFeatureMap;
-
-struct RecordScreenSettings
-{
-    RecordScreenSettings();
-
-    virtual ~RecordScreenSettings();
+typedef std::map<RecordingFeature_T, bool> RecordingFeatureMap;
+
+struct RecordingScreenSettings
+{
+    RecordingScreenSettings();
+
+    virtual ~RecordingScreenSettings();
 
     void applyDefaults(void);
@@ -494 +494 @@
     bool areDefaultSettings(void) const;
 
-    bool isFeatureEnabled(RecordFeature_T enmFeature) const;
-
-    bool operator==(const RecordScreenSettings &d) const;
-
-    bool                 fEnabled;       // requires settings version 1.14 (VirtualBox 4.3)
-    RecordDestination_T enmDest;        // new since VirtualBox 6.0.
-    RecordFeatureMap    featureMap;     // new since VirtualBox 6.0.
-    uint32_t             ulMaxTimeS;     // requires settings version 1.14 (VirtualBox 4.3)
-    com::Utf8Str         strOptions;     // new since VirtualBox 5.2.
+    bool isFeatureEnabled(RecordingFeature_T enmFeature) const;
+
+    bool operator==(const RecordingScreenSettings &d) const;
+
+    bool                   fEnabled;   // requires settings version 1.14 (VirtualBox 4.3)
+    RecordingDestination_T enmDest;    // new since VirtualBox 6.0.
+    RecordingFeatureMap    featureMap; // new since VirtualBox 6.0.
+    uint32_t               ulMaxTimeS; // requires settings version 1.14 (VirtualBox 4.3)
+    com::Utf8Str           strOptions; // new since VirtualBox 5.2.
 
     struct Audio
     {
         Audio()
-            : enmAudioCodec(RecordAudioCodec_Opus)
+            : enmAudioCodec(RecordingAudioCodec_Opus)
             , uHz(22050)
             , cBits(16)
@@ -513 +513 @@
 
         /** The audio codec type to use. */
-        RecordAudioCodec_T enmAudioCodec; // new since VirtualBox 6.0.
+        RecordingAudioCodec_T enmAudioCodec; // new since VirtualBox 6.0.
         /** Hz rate. */
-        uint16_t            uHz;           // new since VirtualBox 6.0.
+        uint16_t              uHz;           // new since VirtualBox 6.0.
         /** Bits per sample. */
-        uint8_t             cBits;         // new since VirtualBox 6.0.
+        uint8_t               cBits;         // new since VirtualBox 6.0.
         /** Number of audio channels. */
-        uint8_t             cChannels;     // new since VirtualBox 6.0.
+        uint8_t               cChannels;     // new since VirtualBox 6.0.
     } Audio;
 
@@ -525 +525 @@
     {
         Video()
-            : enmCodec(RecordVideoCodec_VP8)
+            : enmCodec(RecordingVideoCodec_VP8)
             , ulWidth(1024)
             , ulHeight(768)
@@ -531 +531 @@
             , ulFPS(25) { }
 
-        RecordVideoCodec_T  enmCodec;  // new since VirtualBox 6.0.
-        uint32_t             ulWidth;   // requires settings version 1.14 (VirtualBox 4.3)
-        uint32_t             ulHeight;  // requires settings version 1.14 (VirtualBox 4.3)
-        uint32_t             ulRate;    // requires settings version 1.14 (VirtualBox 4.3)
-        uint32_t             ulFPS;     // requires settings version 1.14 (VirtualBox 4.3)
+        RecordingVideoCodec_T enmCodec;  // new since VirtualBox 6.0.
+        uint32_t              ulWidth;   // requires settings version 1.14 (VirtualBox 4.3)
+        uint32_t              ulHeight;  // requires settings version 1.14 (VirtualBox 4.3)
+        uint32_t              ulRate;    // requires settings version 1.14 (VirtualBox 4.3)
+        uint32_t              ulFPS;     // requires settings version 1.14 (VirtualBox 4.3)
     } Video;
 
@@ -549 +549 @@
 
 /** Map for keeping settings per virtual screen. */
-typedef std::map<uint32_t, RecordScreenSettings> RecordScreenMap;
-
-/**
- * NOTE: If you add any fields in here, you must update a) the constructor and b)
- * the operator== which is used by MachineConfigFile::operator==(), or otherwise
- * your settings might never get saved.
- */
-struct RecordSettings
-{
-    RecordSettings();
+typedef std::map<uint32_t, RecordingScreenSettings> RecordingScreenMap;
+
+/**
+ * NOTE: If you add any fields in here, you must update a) the constructor and b)
+ * the operator== which is used by MachineConfigFile::operator==(), or otherwise
+ * your settings might never get saved.
+ */
+struct RecordingSettings
+{
+    RecordingSettings();
 
     void applyDefaults(void);
@@ -564 +564 @@
     bool areDefaultSettings(void) const;
 
-    bool operator==(const RecordSettings &d) const;
-
-    bool            fEnabled;       // requires settings version 1.14 (VirtualBox 4.3)
-    RecordScreenMap mapScreens;
+    bool operator==(const RecordingSettings &d) const;
+
+    bool               fEnabled;       // requires settings version 1.14 (VirtualBox 4.3)
+    RecordingScreenMap mapScreens;
 };
 
@@ -1039 +1039 @@
 
     BIOSSettings        biosSettings;
-    RecordSettings      recordSettings;
+    RecordingSettings   recordingSettings;
     USB                 usbSettings;
     NetworkAdaptersList llNetworkAdapters;

trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp

@@ -961 +961 @@
         if (fRecordEnabled)
         {
-            ComPtr<IRecordSettings> RecordSettings;
-            CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
-            CHECK_ERROR_BREAK(RecordSettings, COMSETTER(Enabled)(TRUE));
-
-            SafeIfaceArray <IRecordScreenSettings> saRecordScreenScreens;
-            CHECK_ERROR_BREAK(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
+            ComPtr<IRecordingSettings> recordingSettings;
+            CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
+            CHECK_ERROR_BREAK(recordingSettings, COMSETTER(Enabled)(TRUE));
+
+            SafeIfaceArray <IRecordingScreenSettings> saRecordScreenScreens;
+            CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
 
             /* Note: For now all screens have the same configuration. */
@@ -1232 +1232 @@
             if (!machine.isNull())
             {
-                ComPtr<IRecordSettings> RecordSettings;
-                CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
-                CHECK_ERROR_BREAK(RecordSettings, COMSETTER(Enabled)(FALSE));
+                ComPtr<IRecordingSettings> recordingSettings;
+                CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
+                CHECK_ERROR_BREAK(recordingSettings, COMSETTER(Enabled)(FALSE));
             }
         }

trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

@@ -1864 +1864 @@
             }
 
-            ComPtr<IRecordSettings> RecordSettings;
-            CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
-
-            SafeIfaceArray <IRecordScreenSettings> saRecordScreenScreens;
-            CHECK_ERROR_BREAK(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
+            ComPtr<IRecordingSettings> recordingSettings;
+            CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
+
+            SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
+            CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)));
 
             /* Note: For now all screens have the same configuration. */
@@ -1878 +1878 @@
             if (!strcmp(a->argv[2], "on"))
             {
-                CHECK_ERROR_RET(RecordSettings, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
+                CHECK_ERROR_RET(recordingSettings, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
             }
             else if (!strcmp(a->argv[2], "off"))
             {
-                CHECK_ERROR_RET(RecordSettings, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
+                CHECK_ERROR_RET(recordingSettings, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
             }
             else if (!strcmp(a->argv[2], "screens"))
@@ -1930 +1930 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(saScreens[i]));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(saScreens[i]));
             }
             else if (!strcmp(a->argv[2], "filename"))
@@ -1942 +1942 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(FileName)(Bstr(a->argv[2]).raw()));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(FileName)(Bstr(a->argv[2]).raw()));
             }
             else if (   !strcmp(a->argv[2], "videores")
@@ -1972 +1972 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                {
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoWidth)(uVal));
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoHeight)(uVal));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                {
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uVal));
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uVal));
                 }
             }
@@ -1996 +1996 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoRate)(uVal));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoRate)(uVal));
             }
             else if (!strcmp(a->argv[2], "videofps"))
@@ -2017 +2017 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoFPS)(uVal));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(uVal));
             }
             else if (!strcmp(a->argv[2], "maxtime"))
@@ -2038 +2038 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(MaxTime)(uVal));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(MaxTime)(uVal));
             }
             else if (!strcmp(a->argv[2], "maxfilesize"))
@@ -2059 +2059 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(MaxFileSize)(uVal));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(uVal));
             }
             else if (!strcmp(a->argv[2], "opts"))
@@ -2071 +2071 @@
                 }
 
-                for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                    CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Options)(Bstr(a->argv[3]).raw()));
+                for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                    CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Options)(Bstr(a->argv[3]).raw()));
             }
         }

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -2379 +2379 @@
 # endif
 
-        ComPtr<IRecordSettings> RecordSettings;
-        CHECK_ERROR_RET(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()), rc);
-
-        SafeIfaceArray <IRecordScreenSettings> saCaptureScreenScreens;
-        CHECK_ERROR_RET(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saCaptureScreenScreens)), rc);
+        ComPtr<IRecordingSettings> recordingSettings;
+        CHECK_ERROR_RET(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()), rc);
+
+        SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
+        CHECK_ERROR_RET(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)), rc);
 
         /* For now all screens have the same configuration; so take screen 0 and work with that. */
         ULONG fFeatures;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(Features)(&fFeatures), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Features)(&fFeatures), rc);
         ULONG Width;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(VideoWidth)(&Width), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoWidth)(&Width), rc);
         ULONG Height;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(VideoHeight)(&Height), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoHeight)(&Height), rc);
         ULONG Rate;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(VideoRate)(&Rate), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoRate)(&Rate), rc);
         ULONG Fps;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(VideoFPS)(&Fps), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoFPS)(&Fps), rc);
         Bstr  bstrFile;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(FileName)(bstrFile.asOutParam()), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(FileName)(bstrFile.asOutParam()), rc);
         Bstr  bstrOptions;
-        CHECK_ERROR_RET(saCaptureScreenScreens[0], COMGETTER(Options)(bstrOptions.asOutParam()), rc);
+        CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Options)(bstrOptions.asOutParam()), rc);
 
         Utf8Str strOptions(bstrOptions);
@@ -2423 +2423 @@
 # endif
         szValue[0] = '\0';
-        for (size_t i = 0, off = 0; i < saCaptureScreenScreens.size(); i++)
+        for (size_t i = 0, off = 0; i < saRecordingScreenScreens.size(); i++)
         {
             BOOL fEnabled;
-            CHECK_ERROR_RET(saCaptureScreenScreens[i], COMGETTER(Enabled)(&fEnabled), rc);
+            CHECK_ERROR_RET(saRecordingScreenScreens[i], COMGETTER(Enabled)(&fEnabled), rc);
             if (fEnabled && off < sizeof(szValue) - 3)
                 off += RTStrPrintf(&szValue[off], sizeof(szValue) - off, off ? ",%zu" : "%zu", i);

trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

@@ -2950 +2950 @@
             case MODIFYVM_RECORD_OPTIONS:
             {
-                ComPtr<IRecordSettings> RecordSettings;
-                CHECK_ERROR_BREAK(machine, COMGETTER(RecordSettings)(RecordSettings.asOutParam()));
-                SafeIfaceArray <IRecordScreenSettings> saRecordScreenScreens;
-                CHECK_ERROR_BREAK(RecordSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
+                ComPtr<IRecordingSettings> recordingSettings;
+                CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
+                SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
+                CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)));
 
                 switch (c)
@@ -2959 +2959 @@
                     case MODIFYVM_RECORD:
                     {
-                        CHECK_ERROR(RecordSettings, COMSETTER(Enabled)(ValueUnion.f));
+                        CHECK_ERROR(recordingSettings, COMSETTER(Enabled)(ValueUnion.f));
                         break;
                     }
@@ -2974 +2974 @@
                         }
 
-                        if (cMonitors > saRecordScreenScreens.size()) /* Paranoia. */
-                            cMonitors = (ULONG)saRecordScreenScreens.size();
+                        if (cMonitors > saRecordingScreenScreens.size()) /* Paranoia. */
+                            cMonitors = (ULONG)saRecordingScreenScreens.size();
 
                         for (size_t i = 0; i < cMonitors; ++i)
-                            CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(screens[i]));
+                            CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(screens[i]));
                         break;
                     }
@@ -2998 +2998 @@
                         }
 
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(FileName)(bstr.raw()));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(FileName)(bstr.raw()));
                         break;
                     }
                     case MODIFYVM_RECORD_VIDEO_WIDTH:
                     {
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32));
                         break;
                     }
                     case MODIFYVM_RECORD_VIDEO_HEIGHT:
                     {
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32));
                         break;
                     }
@@ -3034 +3034 @@
                         }
 
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
                         {
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
                         }
                         break;
@@ -3043 +3043 @@
                     case MODIFYVM_RECORD_VIDEO_RATE:
                     {
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32));
                         break;
                     }
                     case MODIFYVM_RECORD_VIDEO_FPS:
                     {
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32));
                         break;
                     }
                     case MODIFYVM_RECORD_MAXTIME:
                     {
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32));
                         break;
                     }
                     case MODIFYVM_RECORD_MAXSIZE:
                     {
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32));
                         break;
                     }
@@ -3068 +3068 @@
                     {
                         Bstr bstr(ValueUnion.psz);
-                        for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
-                            CHECK_ERROR(saRecordScreenScreens[i], COMSETTER(Options)(bstr.raw()));
+                        for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
+                            CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Options)(bstr.raw()));
                         break;
                     }

trunk/src/VBox/Frontends/VirtualBox/src/globals/UIMainEventListener.cpp

@@ -375 +375 @@
             break;
         }
-        case KVBoxEventType_OnRecordChanged:
+        case KVBoxEventType_OnRecordingChanged:
         {
             emit sigRecordingChange();

trunk/src/VBox/Frontends/VirtualBox/src/manager/details/UIDetailsElements.cpp

@@ -44 +44 @@
 # include "CMediumAttachment.h"
 # include "CAudioAdapter.h"
-# include "CRecordSettings.h"
-# include "CRecordScreenSettings.h"
+# include "CRecordingSettings.h"
+# include "CRecordingScreenSettings.h"
 # include "CNetworkAdapter.h"
 # include "CSerialPort.h"
@@ -450 +450 @@
 
         /* Recording info: */
-        CRecordSettings comRecordingSettings = machine.GetRecordSettings();
+        CRecordingSettings comRecordingSettings = machine.GetRecordingSettings();
         if (comRecordingSettings.GetEnabled())
         {
             /* For now all screens have the same config: */
-            CRecordScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
+            CRecordingScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
 
             /** @todo r=andy Refine these texts (wrt audio and/or video). */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIConsoleEventHandler.cpp

@@ -188 +188 @@
         << KVBoxEventType_OnVRDEServerChanged
         << KVBoxEventType_OnVRDEServerInfoChanged
-        << KVBoxEventType_OnRecordChanged
+        << KVBoxEventType_OnRecordingChanged
         << KVBoxEventType_OnUSBControllerChanged
         << KVBoxEventType_OnUSBDeviceStateChanged

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIIndicatorsPool.cpp

@@ -43 +43 @@
 /* COM includes: */
 # include "CAudioAdapter.h"
-# include "CRecordSettings.h"
-# include "CRecordScreenSettings.h"
+# include "CRecordingSettings.h"
+# include "CRecordingScreenSettings.h"
 # include "CConsole.h"
 # include "CMachine.h"
@@ -884 +884 @@
 
         /* Update indicator state early: */
-        CRecordSettings comRecordingSettings = comMachine.GetRecordSettings();
+        CRecordingSettings comRecordingSettings = comMachine.GetRecordingSettings();
         Assert(comRecordingSettings.isOk());
         if (!comRecordingSettings.GetEnabled())
@@ -918 +918 @@
 
                 /* For now all screens have the same config: */
-                CRecordScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
+                CRecordingScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
                 Assert(comRecordingScreen0Settings.isOk());
 
@@ -955 +955 @@
             return;
 
-        CRecordSettings comRecordingSettings = comMachine.GetRecordSettings();
+        CRecordingSettings comRecordingSettings = comMachine.GetRecordingSettings();
         /* For now all screens have the same config: */
-        CRecordScreenSettings recordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
-        if (recordingScreen0Settings.IsFeatureEnabled(KRecordFeature_Video))
+        CRecordingScreenSettings recordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
+        if (recordingScreen0Settings.IsFeatureEnabled(KRecordingFeature_Video))
             m_enmRecordingMode = (UIIndicatorStateRecordingMode)((int)m_enmRecordingMode | (int)UIIndicatorStateRecordingMode_Video);
 
-        if (recordingScreen0Settings.IsFeatureEnabled(KRecordFeature_Audio))
+        if (recordingScreen0Settings.IsFeatureEnabled(KRecordingFeature_Audio))
             m_enmRecordingMode = (UIIndicatorStateRecordingMode)((int)m_enmRecordingMode | (int)UIIndicatorStateRecordingMode_Audio);
     }

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

@@ -77 +77 @@
 /* COM includes: */
 # include "CAudioAdapter.h"
-# include "CRecordSettings.h"
+# include "CRecordingSettings.h"
 # include "CVirtualBoxErrorInfo.h"
 # include "CMachineDebugger.h"
@@ -2104 +2104 @@
 
     /* Make sure something had changed: */
-    CRecordSettings comRecordingSettings = machine().GetRecordSettings();
+    CRecordingSettings comRecordingSettings = machine().GetRecordingSettings();
     if (comRecordingSettings.GetEnabled() == static_cast<BOOL>(fEnabled))
         return;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

@@ -60 +60 @@
 /* COM includes: */
 # include "CAudioAdapter.h"
-# include "CRecordSettings.h"
+# include "CRecordingSettings.h"
 # include "CSystemProperties.h"
 # include "CStorageController.h"
@@ -724 +724 @@
 void UISession::sltRecordingChange()
 {
-    CRecordSettings comRecordingSettings = machine().GetRecordSettings();
+    CRecordingSettings comRecordingSettings = machine().GetRecordingSettings();
 
     /* Check/Uncheck Capture action depending on feature status: */

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp

@@ -31 +31 @@
 
 /* COM includes: */
-# include "CRecordSettings.h"
-# include "CRecordScreenSettings.h"
+# include "CRecordingSettings.h"
+# include "CRecordingScreenSettings.h"
 # include "CExtPack.h"
 # include "CExtPackManager.h"
@@ -383 +383 @@
 
     /* Gather old 'Recording' data: */
-    CRecordSettings recordingSettings = m_machine.GetRecordSettings();
+    CRecordingSettings recordingSettings = m_machine.GetRecordingSettings();
     Assert(recordingSettings.isNotNull());
     oldDisplayData.m_fRecordingEnabled = recordingSettings.GetEnabled();
 
     /* For now we're using the same settings for all screens; so get settings from screen 0 and work with that. */
-    CRecordScreenSettings recordingScreen0Settings = recordingSettings.GetScreenSettings(0);
+    CRecordingScreenSettings recordingScreen0Settings = recordingSettings.GetScreenSettings(0);
     if (!recordingScreen0Settings.isNull())
     {
@@ -400 +400 @@
     }
 
-    CRecordScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
+    CRecordingScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
     oldDisplayData.m_vecRecordingScreens.resize(recordingScreenSettingsVector.size());
     for (int iScreenIndex = 0; iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
     {
-        CRecordScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
+        CRecordingScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
         if (!recordingScreenSettings.isNull())
             oldDisplayData.m_vecRecordingScreens[iScreenIndex] = recordingScreenSettings.GetEnabled();
@@ -1511 +1511 @@
         const UIDataSettingsMachineDisplay &newDisplayData = m_pCache->data();
 
-        CRecordSettings recordingSettings = m_machine.GetRecordSettings();
+        CRecordingSettings recordingSettings = m_machine.GetRecordingSettings();
         Assert(recordingSettings.isNotNull());
 
@@ -1533 +1533 @@
                 if (fSuccess)
                 {
-                    CRecordScreenSettingsVector RecordScreenSettingsVector = recordingSettings.GetScreens();
+                    CRecordingScreenSettingsVector RecordScreenSettingsVector = recordingSettings.GetScreens();
                     for (int iScreenIndex = 0; fSuccess && iScreenIndex < RecordScreenSettingsVector.size(); ++iScreenIndex)
                     {
@@ -1539 +1539 @@
                             continue;
 
-                        CRecordScreenSettings recordingScreenSettings = RecordScreenSettingsVector.at(iScreenIndex);
+                        CRecordingScreenSettings recordingScreenSettings = RecordScreenSettingsVector.at(iScreenIndex);
                         recordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
                         fSuccess = recordingScreenSettings.isOk();
@@ -1548 +1548 @@
             else
             {
-                CRecordScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
+                CRecordingScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
                 for (int iScreenIndex = 0; fSuccess && iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
                 {
@@ -1554 +1554 @@
                         continue;
 
-                    CRecordScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
+                    CRecordingScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
 
                     // We should save all the options *before* 'Recording' activation.
@@ -1623 +1623 @@
         else
         {
-            CRecordScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
+            CRecordingScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
             for (int iScreenIndex = 0; fSuccess && iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
             {
@@ -1629 +1629 @@
                     continue;
 
-                CRecordScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
+                CRecordingScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
 
                 /* Save recording file path: */

trunk/src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotDetailsWidget.cpp

@@ -48 +48 @@
 /* COM includes: */
 # include "CAudioAdapter.h"
-# include "CRecordSettings.h"
-# include "CRecordScreenSettings.h"
+# include "CRecordingSettings.h"
+# include "CRecordingScreenSettings.h"
 # include "CMachine.h"
 # include "CMedium.h"
@@ -1748 +1748 @@
     QStringList aReport;
     /* Acquire recording status: */
-    CRecordSettings comRecordingSettings = comMachine.GetRecordSettings();
+    CRecordingSettings comRecordingSettings = comMachine.GetRecordingSettings();
     /* For now all screens have the same config: */
-    CRecordScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
+    CRecordingScreenSettings comRecordingScreen0Settings = comRecordingSettings.GetScreenSettings(0);
     if (comRecordingScreen0Settings.GetEnabled())
     {

trunk/src/VBox/Main/Makefile.kmk

@@ -457 +457 @@
         src-server/BandwidthGroupImpl.cpp \
         src-server/BIOSSettingsImpl.cpp \
-        src-server/RecordSettingsImpl.cpp \
-        src-server/RecordScreenSettingsImpl.cpp \
+        src-server/RecordingSettingsImpl.cpp \
+        src-server/RecordingScreenSettingsImpl.cpp \
         src-server/ClientWatcher.cpp \
         src-server/ClientToken.cpp \

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -4690 +4690 @@
 
   <enum
-    name="RecordDestination"
-    uuid="F52E217E-CA05-41BA-8851-0FA38B3BA38B"
+    name="RecordingDestination"
+    uuid="11E3F06B-DEC1-48B9-BDC4-1E618D72893C"
     >
     <desc>
@@ -4706 +4706 @@
 
   <enum
-    name="RecordFeature"
-    uuid="52AEC901-4EF5-4E04-8CA3-EF1478BB0930"
+    name="RecordingFeature"
+    uuid="A7DDC6A5-DAA8-4485-B860-E9F2E98A7794"
     >
     <desc>
@@ -4725 +4725 @@
 
   <enum
-    name="RecordAudioCodec"
-    uuid="B72DD288-0D3F-4652-AE66-D6F621D2F275"
+    name="RecordingAudioCodec"
+    uuid="0AEFF775-053A-42F8-9C00-E445107DBED8"
     >
     <desc>
@@ -4745 +4745 @@
 
   <enum
-    name="RecordVideoCodec"
-    uuid="823F3AD4-151F-4BDB-AFF9-F7C998E46105"
+    name="RecordingVideoCodec"
+    uuid="663BFC39-AFFF-49FA-98DD-322A857E877B"
     >
     <desc>
@@ -4767 +4767 @@
 
   <enum
-    name="RecordVideoScalingMethod"
-    uuid="8D656085-BAE6-4F63-86F9-616776EB3773"
+    name="RecordingVideoScalingMethod"
+    uuid="5576D890-48EE-449A-A81B-B776233598B7"
     >
     <desc>
@@ -4808 +4808 @@
 
   <interface
-    name="IRecordScreenSettings" extends="$unknown"
-    uuid="7811A5C6-11DB-4F9A-8FAE-1CE238AB4B73"
+    name="IRecordingScreenSettings" extends="$unknown"
+    uuid="41E56E39-C36D-440E-867B-FB80C4CE6FAA"
     wsmap="managed"
     >
 
     <desc>
-      The IRecordScreenSettings interface represents recording settings of a
-      single virtual screen. This is used only in the <link to="IRecordSettings" />
+      The IRecordingScreenSettings interface represents recording settings of a
+      single virtual screen. This is used only in the <link to="IRecordingSettings" />
       interface.
     </desc>
@@ -4822 +4822 @@
       <desc>Returns whether a particular recording feature is enabled for this
         screen or not.</desc>
-      <param name="feature" type="RecordFeature" dir="in">
+      <param name="feature" type="RecordingFeature" dir="in">
         <desc>Feature to check for.</desc>
       </param>
@@ -4847 +4847 @@
     </attribute>
 
-    <attribute name="destination" type="RecordDestination">
+    <attribute name="destination" type="RecordingDestination">
       <desc>This setting determines the recording destination for this
         screen.</desc>
@@ -4906 +4906 @@
     </attribute>
 
-    <attribute name="audioCodec" type="RecordAudioCodec">
+    <attribute name="audioCodec" type="RecordingAudioCodec">
       <desc>
         Determines the audio codec to use for encoding the
@@ -4937 +4937 @@
     </attribute>
 
-    <attribute name="videoCodec" type="RecordVideoCodec">
+    <attribute name="videoCodec" type="RecordingVideoCodec">
       <desc>
         Determines the video codec to use for encoding the recorded video data.
@@ -4982 +4982 @@
     </attribute>
 
-    <attribute name="videoScalingMethod" type="RecordVideoScalingMethod">
+    <attribute name="videoScalingMethod" type="RecordingVideoScalingMethod">
       <desc>
         Determines the video scaling method to use.
@@ -4992 +4992 @@
 
   <interface
-    name="IRecordSettings" extends="$unknown"
-    uuid="7202BACF-2BFE-46AA-AEF6-69B32FDDE236"
+    name="IRecordingSettings" extends="$unknown"
+    uuid="D88F2A5A-47C7-4A3F-AAE1-1B516817DB41"
     wsmap="managed"
     >
 
     <desc>
-      The IRecordSettings interface represents recording settings of the virtual
+      The IRecordingSettings interface represents recording settings of the virtual
       machine. This is used only in the <link to="IMachine::recordSettings" />
       attribute.
@@ -5008 +5008 @@
         <desc>Screen ID to retrieve recording screen settings for.</desc>
       </param>
-      <param name="recordScreenSettings" type="IRecordScreenSettings" dir="return">
+      <param name="recordScreenSettings" type="IRecordingScreenSettings" dir="return">
         <desc>Recording screen settings for the requested screen.</desc>
       </param>
@@ -5019 +5019 @@
     </attribute>
 
-    <attribute name="screens" type="IRecordScreenSettings" readonly="yes" safearray="yes">
+    <attribute name="screens" type="IRecordingScreenSettings" readonly="yes" safearray="yes">
       <desc>
         This setting returns an array for recording settings of all configured
@@ -5221 +5221 @@
   <interface
     name="IMachine" extends="$unknown"
-    uuid="7210DD84-2301-4C3B-8DB3-72DEBD3B91F9"
+    uuid="BD65ADC6-7F47-4F69-B881-96EA06CF9924"
     wsmap="managed"
     wrap-hint-server-addinterfaces="IInternalMachineControl"
@@ -5506 +5506 @@
     </attribute>
 
-    <attribute name="recordSettings" type="IRecordSettings" readonly="yes">
+    <attribute name="recordingSettings" type="IRecordingSettings" readonly="yes">
       <desc>Object containing all recording settings.</desc>
     </attribute>
@@ -20652 +20652 @@
   <interface
     name="IInternalSessionControl" extends="$unknown"
-    uuid="5CEB7885-5DD5-48E4-96C1-EEF4F4FD9FAC"
+    uuid="DE773CFC-B679-4225-8EAE-938D294B73D2"
     internal="yes"
     wsmap="suppress"
@@ -20952 +20952 @@
     </method>
 
-    <method name="onRecordChange">
+    <method name="onRecordingChange">
       <desc>
         Triggered when recording settings have changed.
@@ -22777 +22777 @@
   <enum
     name="VBoxEventType"
-    uuid="b2ddb312-2f9e-4e69-98df-7235e43b2149"
+    uuid="822087CA-4703-49E4-B20D-C6D794E67969"
     >
 
@@ -23136 +23136 @@
       </desc>
     </const>
-    <const name="OnRecordChanged" value="91">
-      <desc>
-        See <link to="IRecordChangedEvent">IRecordChangeEvent</link>.
+    <const name="OnRecordingChanged" value="91">
+      <desc>
+        See <link to="IRecordingChangedEvent">IRecordingChangeEvent</link>.
       </desc>
     </const>
@@ -24523 +24523 @@
 
   <interface
-    name="IRecordChangedEvent" extends="IEvent"
-    uuid="DA51AA0C-E642-4AA0-9DDD-B07E2911188B"
-    wsmap="managed" autogen="VBoxEvent" id="OnRecordChanged"
+    name="IRecordingChangedEvent" extends="IEvent"
+    uuid="B5DDB370-08A7-4C8F-910D-47AABD67253A"
+    wsmap="managed" autogen="VBoxEvent" id="OnRecordingChanged"
     >
     <desc>

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -145 +145 @@
     void i_recordingDestroy(void);
     int i_recordingEnable(BOOL fEnable, util::AutoWriteLock *pAutoLock);
-    int i_recordingGetSettings(settings::RecordSettings &Settings);
+    int i_recordingGetSettings(settings::RecordingSettings &Settings);
     int i_recordingStart(void);
     int i_recordingStop(void);
@@ -179 +179 @@
     HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
     HRESULT i_onVRDEServerChange(BOOL aRestart);
-    HRESULT i_onRecordChange();
+    HRESULT i_onRecordingChange();
     HRESULT i_onUSBControllerChange();
     HRESULT i_onSharedFolderChange(BOOL aGlobal);

trunk/src/VBox/Main/include/DrvAudioRec.h

@@ -45 +45 @@
 public:
 
-    int applyConfiguration(const settings::RecordSettings &Settings);
+    int applyConfiguration(const settings::RecordingSettings &Settings);
 
 public:
@@ -61 +61 @@
     struct DRVAUDIORECORDING         *mpDrv;
     /** Capturing configuration used for configuring the driver. */
-    struct settings::RecordSettings mVideoRecCfg;
+    struct settings::RecordingSettings mVideoRecCfg;
 };
 

trunk/src/VBox/Main/include/MachineImpl.h

@@ -32 +32 @@
 #include "ParallelPortImpl.h"
 #include "BIOSSettingsImpl.h"
-#include "RecordSettingsImpl.h"
+#include "RecordingSettingsImpl.h"
 #include "StorageControllerImpl.h"          // required for MachineImpl.h to compile on Windows
 #include "USBControllerImpl.h"              // required for MachineImpl.h to compile on Windows
@@ -266 +266 @@
         GraphicsControllerType_T mGraphicsControllerType;
         ULONG               mVRAMSize;
-        settings::RecordSettings mRecordSettings;
+        settings::RecordingSettings mRecordSettings;
         ULONG               mMonitorCount;
         BOOL                mHWVirtExEnabled;
@@ -777 +777 @@
     const ComObjPtr<USBDeviceFilters>  mUSBDeviceFilters;
     const ComObjPtr<BIOSSettings>      mBIOSSettings;
-    const ComObjPtr<RecordSettings>    mRecordSettings;
+    const ComObjPtr<RecordingSettings> mRecordingSettings;
     const ComObjPtr<BandwidthControl>  mBandwidthControl;
 
@@ -825 +825 @@
 
     friend class Appliance;
-    friend class RecordSettings;
-    friend class RecordScreenSettings;
+    friend class RecordingSettings;
+    friend class RecordingScreenSettings;
     friend class SessionMachine;
     friend class SnapshotMachine;
@@ -880 +880 @@
     HRESULT setMonitorCount(ULONG aMonitorCount);
     HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
-    HRESULT getRecordSettings(ComPtr<IRecordSettings> &aRecordSettings);
+    HRESULT getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings);
     HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
     HRESULT setFirmwareType(FirmwareType_T aFirmwareType);

trunk/src/VBox/Main/include/Recording.h

@@ -41 +41 @@
     RecordingContext(Console *pConsole);
 
-    RecordingContext(Console *pConsole, const settings::RecordSettings &a_Settings);
+    RecordingContext(Console *pConsole, const settings::RecordingSettings &a_Settings);
 
     virtual ~RecordingContext(void);
@@ -47 +47 @@
 public:
 
-    const settings::RecordSettings &GetConfig(void) const;
+    const settings::RecordingSettings &GetConfig(void) const;
     RecordingStream *GetStream(unsigned uScreen) const;
     size_t GetStreamCount(void) const;
 
-    int Create(const settings::RecordSettings &a_Settings);
+    int Create(const settings::RecordingSettings &a_Settings);
     int Destroy(void);
 
@@ -64 +64 @@
 public:
 
-    bool IsFeatureEnabled(RecordFeature_T enmFeature) const;
+    bool IsFeatureEnabled(RecordingFeature_T enmFeature) const;
     bool IsReady(void) const;
     bool IsReady(uint32_t uScreen, uint64_t uTimeStampMs) const;
@@ -72 +72 @@
 protected:
 
-    int createInternal(const settings::RecordSettings &a_Settings);
+    int createInternal(const settings::RecordingSettings &a_Settings);
     int startInternal(void);
     int stopInternal(void);
@@ -104 +104 @@
     Console                  *pConsole;
     /** Used recording configuration. */
-    settings::RecordSettings  Settings;
+    settings::RecordingSettings  Settings;
     /** The current state. */
     RECORDINGSTS              enmState;

trunk/src/VBox/Main/include/RecordingScreenSettingsImpl.h

@@ -3 +3 @@
 /** @file
  *
- * VirtualBox COM class implementation - Capture settings of one virtual screen.
+ * VirtualBox COM class implementation - Recording settings of one virtual screen.
  */
 
@@ -18 +18 @@
  */
 
-#ifndef ____H_RecordScreenSettings
-#define ____H_RecordScreenSettings
+#ifndef ____H_RecordingScreenSettings
+#define ____H_RecordingScreenSettings
 
-#include "RecordScreenSettingsWrap.h"
+#include "RecordingScreenSettingsWrap.h"
 
-class RecordSettings;
+class RecordingSettings;
 
 namespace settings
 {
-    struct RecordScreenSettings;
+    struct RecordingScreenSettings;
 }
 
-class ATL_NO_VTABLE RecordScreenSettings :
-    public RecordScreenSettingsWrap
+class ATL_NO_VTABLE RecordingScreenSettings :
+    public RecordingScreenSettingsWrap
 {
 public:
 
-    DECLARE_EMPTY_CTOR_DTOR(RecordScreenSettings)
+    DECLARE_EMPTY_CTOR_DTOR(RecordingScreenSettings)
 
     HRESULT FinalConstruct();
@@ -41 +41 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init(RecordSettings *aParent, uint32_t uScreenId, const settings::RecordScreenSettings& data);
-    HRESULT init(RecordSettings *aParent, RecordScreenSettings *that);
-    HRESULT initCopy(RecordSettings *aParent, RecordScreenSettings *that);
+    HRESULT init(RecordingSettings *aParent, uint32_t uScreenId, const settings::RecordingScreenSettings& data);
+    HRESULT init(RecordingSettings *aParent, RecordingScreenSettings *that);
+    HRESULT initCopy(RecordingSettings *aParent, RecordingScreenSettings *that);
     void uninit();
 
     // public methods only for internal purposes
-    HRESULT i_loadSettings(const settings::RecordScreenSettings &data);
-    HRESULT i_saveSettings(settings::RecordScreenSettings &data);
+    HRESULT i_loadSettings(const settings::RecordingScreenSettings &data);
+    HRESULT i_saveSettings(settings::RecordingScreenSettings &data);
 
     void i_rollback();
     void i_commit();
-    void i_copyFrom(RecordScreenSettings *aThat);
+    void i_copyFrom(RecordingScreenSettings *aThat);
     void i_applyDefaults();
 
 private:
 
-    // wrapped IRecordScreenSettings methods
-    HRESULT isFeatureEnabled(RecordFeature_T aFeature, BOOL *aEnabled);
+    // wrapped IRecordingScreenSettings methods
+    HRESULT isFeatureEnabled(RecordingFeature_T aFeature, BOOL *aEnabled);
 
-    // wrapped IRecordScreenSettings properties
+    // wrapped IRecordingScreenSettings properties
     HRESULT getId(ULONG *id);
     HRESULT getEnabled(BOOL *enabled);
@@ -66 +66 @@
     HRESULT getFeatures(ULONG *aFeatures);
     HRESULT setFeatures(ULONG aFeatures);
-    HRESULT getDestination(RecordDestination_T *aDestination);
-    HRESULT setDestination(RecordDestination_T aDestination);
+    HRESULT getDestination(RecordingDestination_T *aDestination);
+    HRESULT setDestination(RecordingDestination_T aDestination);
 
     HRESULT getFileName(com::Utf8Str &aFileName);
@@ -78 +78 @@
     HRESULT setOptions(const com::Utf8Str &aOptions);
 
-    HRESULT getAudioCodec(RecordAudioCodec_T *aCodec);
-    HRESULT setAudioCodec(RecordAudioCodec_T aCodec);
+    HRESULT getAudioCodec(RecordingAudioCodec_T *aCodec);
+    HRESULT setAudioCodec(RecordingAudioCodec_T aCodec);
     HRESULT getAudioHz(ULONG *aHz);
     HRESULT setAudioHz(ULONG aHz);
@@ -87 +87 @@
     HRESULT setAudioChannels(ULONG aChannels);
 
-    HRESULT getVideoCodec(RecordVideoCodec_T *aCodec);
-    HRESULT setVideoCodec(RecordVideoCodec_T aCodec);
+    HRESULT getVideoCodec(RecordingVideoCodec_T *aCodec);
+    HRESULT setVideoCodec(RecordingVideoCodec_T aCodec);
     HRESULT getVideoWidth(ULONG *aVideoWidth);
     HRESULT setVideoWidth(ULONG aVideoWidth);
@@ -99 +99 @@
     HRESULT getVideoFPS(ULONG *aVideoFPS);
     HRESULT setVideoFPS(ULONG aVideoFPS);
-    HRESULT getVideoScalingMethod(RecordVideoScalingMethod_T *aMode);
-    HRESULT setVideoScalingMethod(RecordVideoScalingMethod_T aMode);
+    HRESULT getVideoScalingMethod(RecordingVideoScalingMethod_T *aMode);
+    HRESULT setVideoScalingMethod(RecordingVideoScalingMethod_T aMode);
 
 private:
@@ -113 +113 @@
 };
 
-#endif // ____H_RecordScreenSettings
+#endif // ____H_RecordingScreenSettings
 

trunk/src/VBox/Main/include/RecordingSettingsImpl.h

@@ -21 +21 @@
 #define ____H_RecordSettings
 
-#include "RecordSettingsWrap.h"
+#include "RecordingSettingsWrap.h"
 
 namespace settings
 {
-    struct RecordSettings;
-    struct RecordScreenSettings;
+    struct RecordingSettings;
+    struct RecordingScreenSettings;
 }
 
-class RecordScreenSettings;
+class RecordingScreenSettings;
 
-class ATL_NO_VTABLE RecordSettings :
-    public RecordSettingsWrap
+class ATL_NO_VTABLE RecordingSettings :
+    public RecordingSettingsWrap
 {
 public:
 
-    DECLARE_EMPTY_CTOR_DTOR(RecordSettings)
+    DECLARE_EMPTY_CTOR_DTOR(RecordingSettings)
 
     HRESULT FinalConstruct();
@@ -43 +43 @@
     // public initializer/uninitializer for internal purposes only
     HRESULT init(Machine *parent);
-    HRESULT init(Machine *parent, RecordSettings *that);
-    HRESULT initCopy(Machine *parent, RecordSettings *that);
+    HRESULT init(Machine *parent, RecordingSettings *that);
+    HRESULT initCopy(Machine *parent, RecordingSettings *that);
     void uninit();
 
     // public methods only for internal purposes
-    HRESULT i_loadSettings(const settings::RecordSettings &data);
-    HRESULT i_saveSettings(settings::RecordSettings &data);
+    HRESULT i_loadSettings(const settings::RecordingSettings &data);
+    HRESULT i_saveSettings(settings::RecordingSettings &data);
 
     void i_rollback();
     void i_commit();
-    void i_copyFrom(RecordSettings *aThat);
+    void i_copyFrom(RecordingSettings *aThat);
     void i_applyDefaults(void);
 
@@ -63 +63 @@
 
     /** Map of screen settings objects. The key specifies the screen ID. */
-    typedef std::map <uint32_t, ComObjPtr<RecordScreenSettings> > RecordScreenSettingsMap;
+    typedef std::map <uint32_t, ComObjPtr<RecordingScreenSettings> > RecordScreenSettingsMap;
 
     void i_reset(void);
     int i_syncToMachineDisplays(void);
-    int i_createScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId, const settings::RecordScreenSettings &data);
+    int i_createScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId, const settings::RecordingScreenSettings &data);
     int i_destroyScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId);
     int i_destroyAllScreenObj(RecordScreenSettingsMap &screenSettingsMap);
@@ -73 +73 @@
 private:
 
-    // wrapped IRecordSettings properties
+    // wrapped IRecordingSettings properties
     HRESULT getEnabled(BOOL *enabled);
     HRESULT setEnabled(BOOL enable);
-    HRESULT getScreens(std::vector<ComPtr<IRecordScreenSettings> > &aRecordScreenSettings);
+    HRESULT getScreens(std::vector<ComPtr<IRecordingScreenSettings> > &aRecordScreenSettings);
 
-    // wrapped IRecordSettings methods
-    HRESULT getScreenSettings(ULONG uScreenId, ComPtr<IRecordScreenSettings> &aRecordScreenSettings);
+    // wrapped IRecordingSettings methods
+    HRESULT getScreenSettings(ULONG uScreenId, ComPtr<IRecordingScreenSettings> &aRecordScreenSettings);
 
 private:

trunk/src/VBox/Main/include/RecordingStream.h

@@ -111 +111 @@
     RecordingStream(RecordingContext *pCtx);
 
-    RecordingStream(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings);
+    RecordingStream(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings);
 
     virtual ~RecordingStream(void);
@@ -117 +117 @@
 public:
 
-    int Init(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings);
+    int Init(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings);
     int Uninit(void);
 
@@ -124 +124 @@
                        uint32_t uSrcWidth, uint32_t uSrcHeight, uint8_t *puSrcData, uint64_t uTimeStampMs);
 
-    const settings::RecordScreenSettings &GetConfig(void) const;
+    const settings::RecordingScreenSettings &GetConfig(void) const;
     bool IsLimitReached(uint64_t tsNowMs) const;
     bool IsReady(void) const;
@@ -130 +130 @@
 protected:
 
-    int open(const settings::RecordScreenSettings &Settings);
+    int open(const settings::RecordingScreenSettings &Settings);
     int close(void);
 
-    int initInternal(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings);
+    int initInternal(RecordingContext *pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings);
     int uninitInternal(void);
 
@@ -205 +205 @@
     } Video;
 
-    settings::RecordScreenSettings ScreenSettings;
+    settings::RecordingScreenSettings ScreenSettings;
     /** Common set of recording (data) blocks, needed for
      *  multiplexing to all recording streams. */

trunk/src/VBox/Main/include/SessionImpl.h

@@ -102 +102 @@
     HRESULT onCPUExecutionCapChange(ULONG aExecutionCap);
     HRESULT onVRDEServerChange(BOOL aRestart);
-    HRESULT onRecordChange();
+    HRESULT onRecordingChange();
     HRESULT onUSBControllerChange();
     HRESULT onSharedFolderChange(BOOL aGlobal);

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

@@ -5632 +5632 @@
 # ifdef VBOX_WITH_AUDIO_RECORDING
                     /* Attach the video recording audio driver if required. */
-                    if (   Recording.mpCtx->IsFeatureEnabled(RecordFeature_Audio)
+                    if (   Recording.mpCtx->IsFeatureEnabled(RecordingFeature_Audio)
                         && Recording.mAudioRec)
                     {
@@ -5667 +5667 @@
 #endif /* VBOX_WITH_RECORDING */
 
-HRESULT Console::i_onRecordChange()
+HRESULT Console::i_onRecordingChange()
 {
     AutoCaller autoCaller(this);
@@ -5680 +5680 @@
     if (ptrVM.isOk())
     {
-        ComPtr<IRecordSettings> RecordSettings;
-        rc = mMachine->COMGETTER(RecordSettings)(RecordSettings.asOutParam());
+        ComPtr<IRecordingSettings> recordingSettings;
+        rc = mMachine->COMGETTER(RecordingSettings)(recordingSettings.asOutParam());
         AssertComRCReturnRC(rc);
 
         BOOL fEnabled;
-        rc = RecordSettings->COMGETTER(Enabled)(&fEnabled);
+        rc = recordingSettings->COMGETTER(Enabled)(&fEnabled);
         AssertComRCReturnRC(rc);
 
@@ -5692 +5692 @@
         {
             alock.release();
-            fireRecordChangedEvent(mEventSource);
+            fireRecordingChangedEvent(mEventSource);
         }
 
@@ -6882 +6882 @@
 
     if (   Recording.mpCtx->IsStarted()
-        && Recording.mpCtx->IsFeatureEnabled(RecordFeature_Audio))
+        && Recording.mpCtx->IsFeatureEnabled(RecordingFeature_Audio))
     {
         return Recording.mpCtx->SendAudioFrame(pvData, cbData, uTimestampMs);
@@ -6892 +6892 @@
 
 #ifdef VBOX_WITH_RECORDING
-int Console::i_recordingGetSettings(settings::RecordSettings &Settings)
+int Console::i_recordingGetSettings(settings::RecordingSettings &Settings)
 {
     Assert(mMachine.isNotNull());
@@ -6898 +6898 @@
     Settings.applyDefaults();
 
-    ComPtr<IRecordSettings> pRecordSettings;
-    HRESULT hrc = mMachine->COMGETTER(RecordSettings)(pRecordSettings.asOutParam());
+    ComPtr<IRecordingSettings> pRecordSettings;
+    HRESULT hrc = mMachine->COMGETTER(RecordingSettings)(pRecordSettings.asOutParam());
     AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
 
@@ -6907 +6907 @@
     Settings.fEnabled = RT_BOOL(fTemp);
 
-    SafeIfaceArray<IRecordScreenSettings> paRecordingScreens;
+    SafeIfaceArray<IRecordingScreenSettings> paRecordingScreens;
     hrc = pRecordSettings->COMGETTER(Screens)(ComSafeArrayAsOutParam(paRecordingScreens));
     AssertComRCReturn(hrc, VERR_INVALID_PARAMETER);
@@ -6913 +6913 @@
     for (unsigned long i = 0; i < (unsigned long)paRecordingScreens.size(); ++i)
     {
-        settings::RecordScreenSettings RecordScreenSettings;
-        ComPtr<IRecordScreenSettings> pRecordScreenSettings = paRecordingScreens[i];
+        settings::RecordingScreenSettings RecordScreenSettings;
+        ComPtr<IRecordingScreenSettings> pRecordScreenSettings = paRecordingScreens[i];
 
         hrc = pRecordScreenSettings->COMGETTER(Enabled)(&fTemp);
@@ -6971 +6971 @@
     }
 
-    settings::RecordSettings Settings;
+    settings::RecordingSettings Settings;
     rc = i_recordingGetSettings(Settings);
     if (RT_SUCCESS(rc))
@@ -7043 +7043 @@
             mDisplay->i_recordingScreenChanged(uScreen);
 
-        ComPtr<IRecordSettings> pRecordSettings;
-        HRESULT hrc = mMachine->COMGETTER(RecordSettings)(pRecordSettings.asOutParam());
+        ComPtr<IRecordingSettings> pRecordSettings;
+        HRESULT hrc = mMachine->COMGETTER(RecordingSettings)(pRecordSettings.asOutParam());
         ComAssertComRC(hrc);
         hrc = pRecordSettings->COMSETTER(Enabled)(false);
@@ -10146 +10146 @@
 
 #ifdef VBOX_WITH_RECORDING
-        ComPtr<IRecordSettings> RecordSettings;
-        rc = pConsole->mMachine->COMGETTER(RecordSettings)(RecordSettings.asOutParam());
+        ComPtr<IRecordingSettings> recordingSettings;
+        rc = pConsole->mMachine->COMGETTER(RecordingSettings)(recordingSettings.asOutParam());
         AssertComRCReturnVoid(rc);
 
-        BOOL fCaptureEnabled;
-        rc = RecordSettings->COMGETTER(Enabled)(&fCaptureEnabled);
+        BOOL fRecordingEnabled;
+        rc = recordingSettings->COMGETTER(Enabled)(&fRecordingEnabled);
         AssertComRCReturnVoid(rc);
 
-        if (fCaptureEnabled)
-        {
-            int vrc2 = pConsole->i_recordingEnable(fCaptureEnabled, &alock);
+        if (fRecordingEnabled)
+        {
+            int vrc2 = pConsole->i_recordingEnable(fRecordingEnabled, &alock);
             if (RT_SUCCESS(vrc2))
             {
-                fireRecordChangedEvent(pConsole->mEventSource);
+                fireRecordingChangedEvent(pConsole->mEventSource);
             }
             else

trunk/src/VBox/Main/src-client/DisplayImpl.cpp

@@ -3393 +3393 @@
     if (   pCtx
         && pCtx->IsStarted()
-        && pCtx->IsFeatureEnabled(RecordFeature_Video))
+        && pCtx->IsFeatureEnabled(RecordingFeature_Video))
     {
         do {
@@ -3859 +3859 @@
     if (   pCtx
         && pCtx->IsStarted()
-        && pCtx->IsFeatureEnabled(RecordFeature_Video))
+        && pCtx->IsFeatureEnabled(RecordingFeature_Video))
     {
         int rc2 = pCtx->SendVideoFrame(uScreen, x, y,

trunk/src/VBox/Main/src-client/DrvAudioRec.cpp

@@ -1088 +1088 @@
  * @param   Settings        Capturing configuration to apply.
  */
-int AudioVideoRec::applyConfiguration(const settings::RecordSettings &Settings)
+int AudioVideoRec::applyConfiguration(const settings::RecordingSettings &Settings)
 {
     /** @todo Do some validation here. */
@@ -1108 +1108 @@
     /** @todo For now we're using the configuration of the first screen here audio-wise. */
     Assert(mVideoRecCfg.mapScreens.size() >= 1);
-    const settings::RecordScreenSettings &Screen0Settings = mVideoRecCfg.mapScreens[0];
+    const settings::RecordingScreenSettings &Screen0Settings = mVideoRecCfg.mapScreens[0];
 
     rc = CFGMR3InsertInteger(pLunCfg, "ContainerType", (uint64_t)Screen0Settings.enmDest);
     AssertRCReturn(rc, rc);
-    if (Screen0Settings.enmDest == RecordDestination_File)
+    if (Screen0Settings.enmDest == RecordingDestination_File)
     {
         rc = CFGMR3InsertString(pLunCfg, "ContainerFileName", Utf8Str(Screen0Settings.File.strName).c_str());

trunk/src/VBox/Main/src-client/Recording.cpp

@@ -94 +94 @@
     , enmState(RECORDINGSTS_UNINITIALIZED) { }
 
-RecordingContext::RecordingContext(Console *a_pConsole, const settings::RecordSettings &a_Settings)
+RecordingContext::RecordingContext(Console *a_pConsole, const settings::RecordingSettings &a_Settings)
     : pConsole(a_pConsole)
     , enmState(RECORDINGSTS_UNINITIALIZED)
@@ -177 +177 @@
  * @param   a_Settings          Capture settings to use for context creation.
  */
-int RecordingContext::createInternal(const settings::RecordSettings &a_Settings)
+int RecordingContext::createInternal(const settings::RecordingSettings &a_Settings)
 {
     int rc = RTCritSectInit(&this->CritSect);
@@ -183 +183 @@
         return rc;
 
-    settings::RecordScreenMap::const_iterator itScreen = a_Settings.mapScreens.begin();
+    settings::RecordingScreenMap::const_iterator itScreen = a_Settings.mapScreens.begin();
     while (itScreen != a_Settings.mapScreens.end())
     {
@@ -318 +318 @@
 }
 
-const settings::RecordSettings &RecordingContext::GetConfig(void) const
+const settings::RecordingSettings &RecordingContext::GetConfig(void) const
 {
     return this->Settings;
@@ -355 +355 @@
 }
 
-int RecordingContext::Create(const settings::RecordSettings &a_Settings)
+int RecordingContext::Create(const settings::RecordingSettings &a_Settings)
 {
     return createInternal(a_Settings);
@@ -375 +375 @@
 }
 
-bool RecordingContext::IsFeatureEnabled(RecordFeature_T enmFeature) const
+bool RecordingContext::IsFeatureEnabled(RecordingFeature_T enmFeature) const
 {
     RecordingStreams::const_iterator itStream = this->vecStreams.begin();

trunk/src/VBox/Main/src-client/RecordingStream.cpp

@@ -51 +51 @@
 }
 
-RecordingStream::RecordingStream(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings)
+RecordingStream::RecordingStream(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
     : enmState(RECORDINGSTREAMSTATE_UNINITIALIZED)
     , tsStartMs(0)
@@ -74 +74 @@
  * @returns IPRT status code.
  */
-int RecordingStream::open(const settings::RecordScreenSettings &Settings)
+int RecordingStream::open(const settings::RecordingScreenSettings &Settings)
 {
     /* Sanity. */
-    Assert(Settings.enmDest != RecordDestination_None);
+    Assert(Settings.enmDest != RecordingDestination_None);
 
     int rc;
@@ -83 +83 @@
     switch (Settings.enmDest)
     {
-        case RecordDestination_File:
+        case RecordingDestination_File:
         {
             Assert(Settings.File.strName.isNotEmpty());
@@ -209 +209 @@
             if (value.compare("false", Utf8Str::CaseInsensitive) == 0)
             {
-                this->ScreenSettings.featureMap[RecordFeature_Video] = false;
+                this->ScreenSettings.featureMap[RecordingFeature_Video] = false;
 #ifdef VBOX_WITH_AUDIO_RECORDING
                 LogRel(("Recording: Only audio will be recorded\n"));
@@ -220 +220 @@
             if (value.compare("true", Utf8Str::CaseInsensitive) == 0)
             {
-                this->ScreenSettings.featureMap[RecordFeature_Audio] = true;
+                this->ScreenSettings.featureMap[RecordingFeature_Audio] = true;
             }
             else
@@ -255 +255 @@
 }
 
-const settings::RecordScreenSettings &RecordingStream::GetConfig(void) const
+const settings::RecordingScreenSettings &RecordingStream::GetConfig(void) const
 {
     return this->ScreenSettings;
@@ -277 +277 @@
     }
 
-    if (this->ScreenSettings.enmDest == RecordDestination_File)
+    if (this->ScreenSettings.enmDest == RecordingDestination_File)
     {
 
@@ -661 +661 @@
  * @param   Settings            Capturing configuration to use for initialization.
  */
-int RecordingStream::Init(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings)
+int RecordingStream::Init(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
 {
     return initInternal(a_pCtx, uScreen, Settings);
@@ -674 +674 @@
  * @param   Settings            Capturing configuration to use for initialization.
  */
-int RecordingStream::initInternal(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordScreenSettings &Settings)
+int RecordingStream::initInternal(RecordingContext *a_pCtx, uint32_t uScreen, const settings::RecordingScreenSettings &Settings)
 {
     int rc = parseOptionsString(Settings.strOptions);
@@ -688 +688 @@
         return rc;
 
-    const bool fVideoEnabled = Settings.isFeatureEnabled(RecordFeature_Video);
-    const bool fAudioEnabled = Settings.isFeatureEnabled(RecordFeature_Audio);
+    const bool fVideoEnabled = Settings.isFeatureEnabled(RecordingFeature_Video);
+    const bool fAudioEnabled = Settings.isFeatureEnabled(RecordingFeature_Audio);
 
     if (fVideoEnabled)
@@ -699 +699 @@
     switch (this->ScreenSettings.enmDest)
     {
-        case RecordDestination_File:
+        case RecordingDestination_File:
         {
             const char *pszFile = this->ScreenSettings.File.strName.c_str();
@@ -706 +706 @@
             rc = File.pWEBM->OpenEx(pszFile, &this->File.hFile,
 #ifdef VBOX_WITH_AUDIO_RECORDING
-                                      Settings.isFeatureEnabled(RecordFeature_Audio)
+                                      Settings.isFeatureEnabled(RecordingFeature_Audio)
                                     ? WebMWriter::AudioCodec_Opus : WebMWriter::AudioCodec_None,
 #else
                                       WebMWriter::AudioCodec_None,
 #endif
-                                      Settings.isFeatureEnabled(RecordFeature_Video)
+                                      Settings.isFeatureEnabled(RecordingFeature_Video)
                                     ? WebMWriter::VideoCodec_VP8 : WebMWriter::VideoCodec_None);
             if (RT_FAILURE(rc))
@@ -814 +814 @@
         switch (this->ScreenSettings.enmDest)
         {
-            case RecordDestination_File:
+            case RecordingDestination_File:
             {
                 if (this->File.pWEBM)
@@ -839 +839 @@
     switch (this->ScreenSettings.enmDest)
     {
-        case RecordDestination_File:
+        case RecordingDestination_File:
         {
             if (RTFileIsValid(this->File.hFile))
@@ -891 +891 @@
         return rc;
 
-    if (this->ScreenSettings.isFeatureEnabled(RecordFeature_Video))
+    if (this->ScreenSettings.isFeatureEnabled(RecordingFeature_Video))
     {
         int rc2 = unitVideo();
@@ -1025 +1025 @@
 {
 #ifdef VBOX_WITH_AUDIO_RECORDING
-    if (this->ScreenSettings.isFeatureEnabled(RecordFeature_Audio))
+    if (this->ScreenSettings.isFeatureEnabled(RecordingFeature_Audio))
     {
         /* Sanity. */

trunk/src/VBox/Main/src-client/SessionImpl.cpp

@@ -725 +725 @@
 }
 
-HRESULT Session::onRecordChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-#ifndef VBOX_COM_INPROC_API_CLIENT
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->i_onRecordChange();
+HRESULT Session::onRecordingChange()
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
+    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
+#ifndef VBOX_COM_INPROC_API_CLIENT
+    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
+
+    return mConsole->i_onRecordingChange();
 #else
     return S_OK;

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -359 +359 @@
 
         /* Apply record defaults. */
-        mRecordSettings->i_applyDefaults();
+        mRecordingSettings->i_applyDefaults();
 
         /* Apply network adapters defaults */
@@ -1940 +1940 @@
 }
 
-HRESULT Machine::getRecordSettings(ComPtr<IRecordSettings> &aRecordSettings)
-{
-    /* mRecordSettings is constant during life time, no need to lock */
-    aRecordSettings = mRecordSettings;
+HRESULT Machine::getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings)
+{
+    /* mRecordingSettings is constant during life time, no need to lock */
+    aRecordingSettings = mRecordingSettings;
 
     return S_OK;
@@ -8260 +8260 @@
 
     /* create associated record settings object */
-    unconst(mRecordSettings).createObject();
-    mRecordSettings->init(this);
+    unconst(mRecordingSettings).createObject();
+    mRecordingSettings->init(this);
 
     /* create an associated VRDE object (default is disabled) */
@@ -8378 +8378 @@
     }
 
-    if (mRecordSettings)
-    {
-        mRecordSettings->uninit();
-        unconst(mRecordSettings).setNull();
+    if (mRecordingSettings)
+    {
+        mRecordingSettings->uninit();
+        unconst(mRecordingSettings).setNull();
     }
 
@@ -8898 +8898 @@
         if (FAILED(rc)) return rc;
 
-        /* Record settings */
-        rc = mRecordSettings->i_loadSettings(data.recordSettings);
+        /* Recording settings */
+        rc = mRecordingSettings->i_loadSettings(data.recordingSettings);
         if (FAILED(rc)) return rc;
 
@@ -10217 +10217 @@
         if (FAILED(rc)) throw rc;
 
-        /* Record settings (required) */
-        rc = mRecordSettings->i_saveSettings(data.recordSettings);
+        /* Recording settings (required) */
+        rc = mRecordingSettings->i_saveSettings(data.recordingSettings);
         if (FAILED(rc)) throw rc;
 
@@ -11723 +11723 @@
         mBIOSSettings->i_rollback();
 
-    if (mRecordSettings && (mData->flModifications & IsModified_Record))
-        mRecordSettings->i_rollback();
+    if (mRecordingSettings && (mData->flModifications & IsModified_Record))
+        mRecordingSettings->i_rollback();
 
     if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
@@ -11836 +11836 @@
 
     mBIOSSettings->i_commit();
-    mRecordSettings->i_commit();
+    mRecordingSettings->i_commit();
     mVRDEServer->i_commit();
     mAudioAdapter->i_commit();
@@ -12089 +12089 @@
 
     mBIOSSettings->i_copyFrom(aThat->mBIOSSettings);
-    mRecordSettings->i_copyFrom(aThat->mRecordSettings);
+    mRecordingSettings->i_copyFrom(aThat->mRecordingSettings);
     mVRDEServer->i_copyFrom(aThat->mVRDEServer);
     mAudioAdapter->i_copyFrom(aThat->mAudioAdapter);
@@ -12463 +12463 @@
     unconst(mBIOSSettings).createObject();
     mBIOSSettings->init(this, aMachine->mBIOSSettings);
-    unconst(mRecordSettings).createObject();
-    mRecordSettings->init(this, aMachine->mRecordSettings);
+    unconst(mRecordingSettings).createObject();
+    mRecordingSettings->init(this, aMachine->mRecordingSettings);
     /* create another VRDEServer object that will be mutable */
     unconst(mVRDEServer).createObject();
@@ -14116 +14116 @@
         return S_OK;
 
-    return directControl->OnRecordChange();
+    return directControl->OnRecordingChange();
 }
 
@@ -15051 +15051 @@
 
     /* Initialize default record settings. */
-    mRecordSettings->i_applyDefaults();
+    mRecordingSettings->i_applyDefaults();
 
     /* Initialize default BIOS settings here */

trunk/src/VBox/Main/src-server/RecordingScreenSettingsImpl.cpp

@@ -2 +2 @@
 /** @file
  *
- * VirtualBox COM class implementation - Capture settings of one virtual screen.
+ * VirtualBox COM class implementation - Recording settings of one virtual screen.
  */
 
@@ -17 +17 @@
  */
 
-#define LOG_GROUP LOG_GROUP_MAIN_RECORDSCREENSETTINGS
+#define LOG_GROUP LOG_GROUP_MAIN_RECORDINGSCREENSETTINGS
 #include "LoggingNew.h"
 
-#include "RecordScreenSettingsImpl.h"
-#include "RecordSettingsImpl.h"
+#include "RecordingScreenSettingsImpl.h"
+#include "RecordingSettingsImpl.h"
 #include "MachineImpl.h"
 
@@ -38 +38 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-struct RecordScreenSettings::Data
+struct RecordingScreenSettings::Data
 {
     Data()
@@ -44 +44 @@
     { }
 
-    RecordSettings * const          pParent;
-    ComObjPtr<RecordScreenSettings> pPeer;
-    uint32_t                         uScreenId;
+    RecordingSettings * const          pParent;
+    ComObjPtr<RecordingScreenSettings> pPeer;
+    uint32_t                           uScreenId;
 
     // use the XML settings structure in the members for simplicity
-    Backupable<settings::RecordScreenSettings> bd;
+    Backupable<settings::RecordingScreenSettings> bd;
 };
 
@@ -55 +55 @@
 /////////////////////////////////////////////////////////////////////////////
 
-DEFINE_EMPTY_CTOR_DTOR(RecordScreenSettings)
-
-HRESULT RecordScreenSettings::FinalConstruct()
+DEFINE_EMPTY_CTOR_DTOR(RecordingScreenSettings)
+
+HRESULT RecordingScreenSettings::FinalConstruct()
 {
     return BaseFinalConstruct();
 }
 
-void RecordScreenSettings::FinalRelease()
+void RecordingScreenSettings::FinalRelease()
 {
     uninit();
@@ -76 +76 @@
  * @returns COM result indicator
  */
-HRESULT RecordScreenSettings::init(RecordSettings *aParent, uint32_t uScreenId, const settings::RecordScreenSettings& data)
+HRESULT RecordingScreenSettings::init(RecordingSettings *aParent, uint32_t uScreenId, const settings::RecordingScreenSettings& data)
 {
     LogFlowThisFuncEnter();
@@ -123 +123 @@
  *  it shares data with is destroyed.
  */
-HRESULT RecordScreenSettings::init(RecordSettings *aParent, RecordScreenSettings *that)
+HRESULT RecordingScreenSettings::init(RecordingSettings *aParent, RecordingScreenSettings *that)
 {
     LogFlowThisFuncEnter();
@@ -166 +166 @@
  *  of the original object passed as an argument.
  */
-HRESULT RecordScreenSettings::initCopy(RecordSettings *aParent, RecordScreenSettings *that)
+HRESULT RecordingScreenSettings::initCopy(RecordingSettings *aParent, RecordingScreenSettings *that)
 {
     LogFlowThisFuncEnter();
@@ -208 +208 @@
  *  Called either from FinalRelease() or by the parent when it gets destroyed.
  */
-void RecordScreenSettings::uninit()
+void RecordingScreenSettings::uninit()
 {
     LogFlowThisFuncEnter();
@@ -228 +228 @@
 }
 
-HRESULT RecordScreenSettings::isFeatureEnabled(RecordFeature_T aFeature, BOOL *aEnabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    settings::RecordFeatureMap::const_iterator itFeature = m->bd->featureMap.find(aFeature);
+HRESULT RecordingScreenSettings::isFeatureEnabled(RecordingFeature_T aFeature, BOOL *aEnabled)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    settings::RecordingFeatureMap::const_iterator itFeature = m->bd->featureMap.find(aFeature);
 
     *aEnabled = (   itFeature != m->bd->featureMap.end()
@@ -243 +243 @@
 }
 
-HRESULT RecordScreenSettings::getId(ULONG *id)
+HRESULT RecordingScreenSettings::getId(ULONG *id)
 {
     AutoCaller autoCaller(this);
@@ -255 +255 @@
 }
 
-HRESULT RecordScreenSettings::getEnabled(BOOL *enabled)
+HRESULT RecordingScreenSettings::getEnabled(BOOL *enabled)
 {
     AutoCaller autoCaller(this);
@@ -267 +267 @@
 }
 
-HRESULT RecordScreenSettings::setEnabled(BOOL enabled)
+HRESULT RecordingScreenSettings::setEnabled(BOOL enabled)
 {
     AutoCaller autoCaller(this);
@@ -275 +275 @@
 
     if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change enabled state of screen while capturing is enabled"));
+        return setError(E_INVALIDARG, tr("Cannot change enabled state of screen while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -292 +292 @@
 }
 
-HRESULT RecordScreenSettings::getFeatures(ULONG *aFeatures)
+HRESULT RecordingScreenSettings::getFeatures(ULONG *aFeatures)
 {
     AutoCaller autoCaller(this);
@@ -301 +301 @@
     *aFeatures = 0;
 
-    settings::RecordFeatureMap::const_iterator itFeature = m->bd->featureMap.begin();
+    settings::RecordingFeatureMap::const_iterator itFeature = m->bd->featureMap.begin();
     while (itFeature != m->bd->featureMap.end())
     {
@@ -313 +313 @@
 }
 
-HRESULT RecordScreenSettings::setFeatures(ULONG aFeatures)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change features while capturing is enabled"));
+HRESULT RecordingScreenSettings::setFeatures(ULONG aFeatures)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change features while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -326 +326 @@
     m->bd->featureMap.clear();
 
-    if (aFeatures & RecordFeature_Audio)
-        m->bd->featureMap[RecordFeature_Audio] = true;
-    if (aFeatures & RecordFeature_Video)
-        m->bd->featureMap[RecordFeature_Video] = true;
+    if (aFeatures & RecordingFeature_Audio)
+        m->bd->featureMap[RecordingFeature_Audio] = true;
+    if (aFeatures & RecordingFeature_Video)
+        m->bd->featureMap[RecordingFeature_Video] = true;
 
     alock.release();
@@ -336 +336 @@
 }
 
-HRESULT RecordScreenSettings::getDestination(RecordDestination_T *aDestination)
+HRESULT RecordingScreenSettings::getDestination(RecordingDestination_T *aDestination)
 {
     AutoCaller autoCaller(this);
@@ -348 +348 @@
 }
 
-HRESULT RecordScreenSettings::setDestination(RecordDestination_T aDestination)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change destination type while capturing is enabled"));
+HRESULT RecordingScreenSettings::setDestination(RecordingDestination_T aDestination)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change destination type while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -364 +364 @@
 }
 
-HRESULT RecordScreenSettings::getFileName(com::Utf8Str &aFileName)
+HRESULT RecordingScreenSettings::getFileName(com::Utf8Str &aFileName)
 {
     AutoCaller autoCaller(this);
@@ -376 +376 @@
 }
 
-HRESULT RecordScreenSettings::setFileName(const com::Utf8Str &aFileName)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change file name while capturing is enabled"));
+HRESULT RecordingScreenSettings::setFileName(const com::Utf8Str &aFileName)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change file name while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -397 +397 @@
 }
 
-HRESULT RecordScreenSettings::getMaxTime(ULONG *aMaxTimeS)
+HRESULT RecordingScreenSettings::getMaxTime(ULONG *aMaxTimeS)
 {
     AutoCaller autoCaller(this);
@@ -409 +409 @@
 }
 
-HRESULT RecordScreenSettings::setMaxTime(ULONG aMaxTimeS)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change maximum time while capturing is enabled"));
+HRESULT RecordingScreenSettings::setMaxTime(ULONG aMaxTimeS)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change maximum time while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -425 +425 @@
 }
 
-HRESULT RecordScreenSettings::getMaxFileSize(ULONG *aMaxFileSizeMB)
+HRESULT RecordingScreenSettings::getMaxFileSize(ULONG *aMaxFileSizeMB)
 {
     AutoCaller autoCaller(this);
@@ -437 +437 @@
 }
 
-HRESULT RecordScreenSettings::setMaxFileSize(ULONG aMaxFileSize)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change maximum file size while capturing is enabled"));
+HRESULT RecordingScreenSettings::setMaxFileSize(ULONG aMaxFileSize)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change maximum file size while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -453 +453 @@
 }
 
-HRESULT RecordScreenSettings::getOptions(com::Utf8Str &aOptions)
+HRESULT RecordingScreenSettings::getOptions(com::Utf8Str &aOptions)
 {
     AutoCaller autoCaller(this);
@@ -465 +465 @@
 }
 
-HRESULT RecordScreenSettings::setOptions(const com::Utf8Str &aOptions)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change options while capturing is enabled"));
+HRESULT RecordingScreenSettings::setOptions(const com::Utf8Str &aOptions)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change options while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -481 +481 @@
 }
 
-HRESULT RecordScreenSettings::getAudioCodec(RecordAudioCodec_T *aCodec)
+HRESULT RecordingScreenSettings::getAudioCodec(RecordingAudioCodec_T *aCodec)
 {
     AutoCaller autoCaller(this);
@@ -493 +493 @@
 }
 
-HRESULT RecordScreenSettings::setAudioCodec(RecordAudioCodec_T aCodec)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change audio codec while capturing is enabled"));
+HRESULT RecordingScreenSettings::setAudioCodec(RecordingAudioCodec_T aCodec)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change audio codec while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -509 +509 @@
 }
 
-HRESULT RecordScreenSettings::getAudioHz(ULONG *aHz)
+HRESULT RecordingScreenSettings::getAudioHz(ULONG *aHz)
 {
     AutoCaller autoCaller(this);
@@ -521 +521 @@
 }
 
-HRESULT RecordScreenSettings::setAudioHz(ULONG aHz)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change audio Hertz rate while capturing is enabled"));
+HRESULT RecordingScreenSettings::setAudioHz(ULONG aHz)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change audio Hertz rate while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -537 +537 @@
 }
 
-HRESULT RecordScreenSettings::getAudioBits(ULONG *aBits)
+HRESULT RecordingScreenSettings::getAudioBits(ULONG *aBits)
 {
     AutoCaller autoCaller(this);
@@ -549 +549 @@
 }
 
-HRESULT RecordScreenSettings::setAudioBits(ULONG aBits)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change audio bits while capturing is enabled"));
+HRESULT RecordingScreenSettings::setAudioBits(ULONG aBits)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change audio bits while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -565 +565 @@
 }
 
-HRESULT RecordScreenSettings::getAudioChannels(ULONG *aChannels)
+HRESULT RecordingScreenSettings::getAudioChannels(ULONG *aChannels)
 {
     AutoCaller autoCaller(this);
@@ -577 +577 @@
 }
 
-HRESULT RecordScreenSettings::setAudioChannels(ULONG aChannels)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change audio channels while capturing is enabled"));
+HRESULT RecordingScreenSettings::setAudioChannels(ULONG aChannels)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change audio channels while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -593 +593 @@
 }
 
-HRESULT RecordScreenSettings::getVideoCodec(RecordVideoCodec_T *aCodec)
+HRESULT RecordingScreenSettings::getVideoCodec(RecordingVideoCodec_T *aCodec)
 {
     AutoCaller autoCaller(this);
@@ -605 +605 @@
 }
 
-HRESULT RecordScreenSettings::setVideoCodec(RecordVideoCodec_T aCodec)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video codec while capturing is enabled"));
+HRESULT RecordingScreenSettings::setVideoCodec(RecordingVideoCodec_T aCodec)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video codec while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -621 +621 @@
 }
 
-HRESULT RecordScreenSettings::getVideoWidth(ULONG *aVideoWidth)
+HRESULT RecordingScreenSettings::getVideoWidth(ULONG *aVideoWidth)
 {
     AutoCaller autoCaller(this);
@@ -633 +633 @@
 }
 
-HRESULT RecordScreenSettings::setVideoWidth(ULONG aVideoWidth)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video width while capturing is enabled"));
+HRESULT RecordingScreenSettings::setVideoWidth(ULONG aVideoWidth)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video width while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -649 +649 @@
 }
 
-HRESULT RecordScreenSettings::getVideoHeight(ULONG *aVideoHeight)
+HRESULT RecordingScreenSettings::getVideoHeight(ULONG *aVideoHeight)
 {
     AutoCaller autoCaller(this);
@@ -661 +661 @@
 }
 
-HRESULT RecordScreenSettings::setVideoHeight(ULONG aVideoHeight)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video height while capturing is enabled"));
+HRESULT RecordingScreenSettings::setVideoHeight(ULONG aVideoHeight)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video height while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -677 +677 @@
 }
 
-HRESULT RecordScreenSettings::getVideoRate(ULONG *aVideoRate)
+HRESULT RecordingScreenSettings::getVideoRate(ULONG *aVideoRate)
 {
     AutoCaller autoCaller(this);
@@ -689 +689 @@
 }
 
-HRESULT RecordScreenSettings::setVideoRate(ULONG aVideoRate)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video rate while capturing is enabled"));
+HRESULT RecordingScreenSettings::setVideoRate(ULONG aVideoRate)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video rate while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -705 +705 @@
 }
 
-HRESULT RecordScreenSettings::getVideoRateControlMode(RecordVideoRateControlMode_T *aMode)
+HRESULT RecordingScreenSettings::getVideoRateControlMode(RecordVideoRateControlMode_T *aMode)
 {
     AutoCaller autoCaller(this);
@@ -717 +717 @@
 }
 
-HRESULT RecordScreenSettings::setVideoRateControlMode(RecordVideoRateControlMode_T aMode)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video rate control mode while capturing is enabled"));
+HRESULT RecordingScreenSettings::setVideoRateControlMode(RecordVideoRateControlMode_T aMode)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video rate control mode while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -733 +733 @@
 }
 
-HRESULT RecordScreenSettings::getVideoFPS(ULONG *aVideoFPS)
+HRESULT RecordingScreenSettings::getVideoFPS(ULONG *aVideoFPS)
 {
     AutoCaller autoCaller(this);
@@ -745 +745 @@
 }
 
-HRESULT RecordScreenSettings::setVideoFPS(ULONG aVideoFPS)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video FPS while capturing is enabled"));
+HRESULT RecordingScreenSettings::setVideoFPS(ULONG aVideoFPS)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video FPS while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -761 +761 @@
 }
 
-HRESULT RecordScreenSettings::getVideoScalingMethod(RecordVideoScalingMethod_T *aMode)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aMode = RecordVideoScalingMethod_None; /** @todo Implement this. */
-
-    return S_OK;
-}
-
-HRESULT RecordScreenSettings::setVideoScalingMethod(RecordVideoScalingMethod_T aMode)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    if (!m->pParent->i_canChangeSettings())
-        return setError(E_INVALIDARG, tr("Cannot change video rate scaling method while capturing is enabled"));
+HRESULT RecordingScreenSettings::getVideoScalingMethod(RecordingVideoScalingMethod_T *aMode)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    *aMode = RecordingVideoScalingMethod_None; /** @todo Implement this. */
+
+    return S_OK;
+}
+
+HRESULT RecordingScreenSettings::setVideoScalingMethod(RecordingVideoScalingMethod_T aMode)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    if (!m->pParent->i_canChangeSettings())
+        return setError(E_INVALIDARG, tr("Cannot change video rate scaling method while recording is enabled"));
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -794 +794 @@
  * @returns IPRT status code.
  */
-int RecordScreenSettings::i_initInternal(void)
+int RecordingScreenSettings::i_initInternal(void)
 {
     Assert(m);
@@ -802 +802 @@
     switch (m->bd->enmDest)
     {
-        case RecordDestination_File:
+        case RecordingDestination_File:
         {
             if (m->bd->File.strName.isEmpty())

trunk/src/VBox/Main/src-server/RecordingSettingsImpl.cpp

@@ -17 +17 @@
  */
 
-#define LOG_GROUP LOG_GROUP_MAIN_RECORDSETTINGS
+#define LOG_GROUP LOG_GROUP_MAIN_RECORDINGSETTINGS
 #include "LoggingNew.h"
 
-#include "RecordSettingsImpl.h"
-#include "RecordScreenSettingsImpl.h"
+#include "RecordingSettingsImpl.h"
+#include "RecordingScreenSettingsImpl.h"
 #include "MachineImpl.h"
 
@@ -37 +37 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-struct RecordSettings::Data
+struct RecordingSettings::Data
 {
     Data()
@@ -43 +43 @@
     { }
 
-    Machine * const           pMachine;
-    ComObjPtr<RecordSettings> pPeer;
-    RecordScreenSettingsMap   mapScreenObj;
-    bool                      fHasMachineLock;
+    Machine * const              pMachine;
+    ComObjPtr<RecordingSettings> pPeer;
+    RecordScreenSettingsMap      mapScreenObj;
+    bool                         fHasMachineLock;
 
     // use the XML settings structure in the members for simplicity
-    Backupable<settings::RecordSettings> bd;
+    Backupable<settings::RecordingSettings> bd;
 };
 
-DEFINE_EMPTY_CTOR_DTOR(RecordSettings)
-
-HRESULT RecordSettings::FinalConstruct()
+DEFINE_EMPTY_CTOR_DTOR(RecordingSettings)
+
+HRESULT RecordingSettings::FinalConstruct()
 {
     return BaseFinalConstruct();
 }
 
-void RecordSettings::FinalRelease()
+void RecordingSettings::FinalRelease()
 {
     uninit();
@@ -70 +70 @@
  * @returns COM result indicator
  */
-HRESULT RecordSettings::init(Machine *aParent)
+HRESULT RecordingSettings::init(Machine *aParent)
 {
     LogFlowThisFuncEnter();
@@ -103 +103 @@
  *  it shares data with is destroyed.
  */
-HRESULT RecordSettings::init(Machine *aParent, RecordSettings *that)
+HRESULT RecordingSettings::init(Machine *aParent, RecordingSettings *that)
 {
     LogFlowThisFuncEnter();
@@ -136 +136 @@
  *  of the original object passed as an argument.
  */
-HRESULT RecordSettings::initCopy(Machine *aParent, RecordSettings *that)
+HRESULT RecordingSettings::initCopy(Machine *aParent, RecordingSettings *that)
 {
     LogFlowThisFuncEnter();
@@ -168 +168 @@
  *  Called either from FinalRelease() or by the parent when it gets destroyed.
  */
-void RecordSettings::uninit()
+void RecordingSettings::uninit()
 {
     LogFlowThisFuncEnter();
@@ -194 +194 @@
 /////////////////////////////////////////////////////////////////////////////
 
-HRESULT RecordSettings::getEnabled(BOOL *enabled)
+HRESULT RecordingSettings::getEnabled(BOOL *enabled)
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -203 +203 @@
 }
 
-HRESULT RecordSettings::setEnabled(BOOL enable)
+HRESULT RecordingSettings::setEnabled(BOOL enable)
 {
     LogFlowThisFuncEnter();
@@ -251 +251 @@
 }
 
-HRESULT RecordSettings::getScreens(std::vector<ComPtr<IRecordScreenSettings> > &aRecordScreenSettings)
+HRESULT RecordingSettings::getScreens(std::vector<ComPtr<IRecordingScreenSettings> > &aRecordScreenSettings)
 {
     LogFlowThisFuncEnter();
@@ -277 +277 @@
 }
 
-HRESULT RecordSettings::getScreenSettings(ULONG uScreenId, ComPtr<IRecordScreenSettings> &aRecordScreenSettings)
+HRESULT RecordingSettings::getScreenSettings(ULONG uScreenId, ComPtr<IRecordingScreenSettings> &aRecordScreenSettings)
 {
     LogFlowThisFuncEnter();
@@ -312 +312 @@
  * @param   data                Recording screen settings to use for that screen.
  */
-int RecordSettings::i_createScreenObj(RecordScreenSettingsMap &screenSettingsMap,
-                                       uint32_t uScreenId, const settings::RecordScreenSettings &data)
+int RecordingSettings::i_createScreenObj(RecordScreenSettingsMap &screenSettingsMap,
+                                       uint32_t uScreenId, const settings::RecordingScreenSettings &data)
 {
     LogFlowThisFunc(("Screen %RU32\n", uScreenId));
@@ -325 +325 @@
     int vrc = VINF_SUCCESS;
 
-    ComObjPtr<RecordScreenSettings> RecordScreenSettings;
-    HRESULT rc = RecordScreenSettings.createObject();
+    ComObjPtr<RecordingScreenSettings> recordingScreenSettings;
+    HRESULT rc = recordingScreenSettings.createObject();
     if (SUCCEEDED(rc))
     {
-        rc = RecordScreenSettings->init(this, uScreenId, data);
+        rc = recordingScreenSettings->init(this, uScreenId, data);
         if (SUCCEEDED(rc))
         {
             try
             {
-                screenSettingsMap[uScreenId] = RecordScreenSettings;
+                screenSettingsMap[uScreenId] = recordingScreenSettings;
             }
             catch (std::bad_alloc &)
@@ -353 +353 @@
  * @param   uScreenId           ID of screen to remove.
  */
-int RecordSettings::i_destroyScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId)
+int RecordingSettings::i_destroyScreenObj(RecordScreenSettingsMap &screenSettingsMap, uint32_t uScreenId)
 {
     LogFlowThisFunc(("Screen %RU32\n", uScreenId));
@@ -368 +368 @@
     /* Make sure to consume the pointer before the one of the
      * iterator gets released. */
-    ComObjPtr<RecordScreenSettings> pScreenSettings = itScreen->second;
+    ComObjPtr<RecordingScreenSettings> pScreenSettings = itScreen->second;
 
     screenSettingsMap.erase(itScreen);
@@ -383 +383 @@
  * @param   screenSettingsMap   Map to destroy screen settings objects for.
  */
-int RecordSettings::i_destroyAllScreenObj(RecordScreenSettingsMap &screenSettingsMap)
+int RecordingSettings::i_destroyAllScreenObj(RecordScreenSettingsMap &screenSettingsMap)
 {
     LogFlowThisFuncEnter();
@@ -392 +392 @@
         /* Make sure to consume the pointer before the one of the
          * iterator gets released. */
-        ComObjPtr<RecordScreenSettings> pScreenSettings = itScreen->second;
+        ComObjPtr<RecordingScreenSettings> pScreenSettings = itScreen->second;
 
         screenSettingsMap.erase(itScreen);
@@ -412 +412 @@
  * @note Locks this object for writing.
  */
-HRESULT RecordSettings::i_loadSettings(const settings::RecordSettings &data)
+HRESULT RecordingSettings::i_loadSettings(const settings::RecordingSettings &data)
 {
     LogFlowThisFuncEnter();
@@ -427 +427 @@
     LogFlowThisFunc(("Data has %zu screens\n", data.mapScreens.size()));
 
-    settings::RecordScreenMap::const_iterator itScreen = data.mapScreens.begin();
+    settings::RecordingScreenMap::const_iterator itScreen = data.mapScreens.begin();
     while (itScreen != data.mapScreens.end())
     {
@@ -457 +457 @@
  * Resets the internal object state by destroying all screen settings objects.
  */
-void RecordSettings::i_reset(void)
+void RecordingSettings::i_reset(void)
 {
     LogFlowThisFuncEnter();
@@ -472 +472 @@
  * @note Locks this object for reading.
  */
-HRESULT RecordSettings::i_saveSettings(settings::RecordSettings &data)
+HRESULT RecordingSettings::i_saveSettings(settings::RecordingSettings &data)
 {
     LogFlowThisFuncEnter();
@@ -486 +486 @@
     data = *m->bd.data();
 
-    settings::RecordScreenMap::iterator itScreen = data.mapScreens.begin();
+    settings::RecordingScreenMap::iterator itScreen = data.mapScreens.begin();
     while (itScreen != data.mapScreens.end())
     {
@@ -499 +499 @@
 }
 
-void RecordSettings::i_rollback()
+void RecordingSettings::i_rollback()
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -505 +505 @@
 }
 
-void RecordSettings::i_commit()
+void RecordingSettings::i_commit()
 {
     /* sanity */
@@ -531 +531 @@
 }
 
-void RecordSettings::i_copyFrom(RecordSettings *aThat)
+void RecordingSettings::i_copyFrom(RecordingSettings *aThat)
 {
     AssertReturnVoid(aThat != NULL);
@@ -552 +552 @@
 }
 
-void RecordSettings::i_applyDefaults(void)
+void RecordingSettings::i_applyDefaults(void)
 {
     /* sanity */
@@ -566 +566 @@
  * Returns the full path to the default video capture file.
  */
-int RecordSettings::i_getDefaultFileName(Utf8Str &strFile)
+int RecordingSettings::i_getDefaultFileName(Utf8Str &strFile)
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -582 +582 @@
  * @returns \c true if the settings can be changed, \c false if not.
  */
-bool RecordSettings::i_canChangeSettings(void)
+bool RecordingSettings::i_canChangeSettings(void)
 {
     AutoAnyStateDependency adep(m->pMachine);
@@ -598 +598 @@
  * have been changed.
  */
-void RecordSettings::i_onSettingsChanged(void)
+void RecordingSettings::i_onSettingsChanged(void)
 {
     LogFlowThisFuncEnter();
@@ -613 +613 @@
  * to the number of the machine's configured displays.
  */
-int RecordSettings::i_syncToMachineDisplays(void)
+int RecordingSettings::i_syncToMachineDisplays(void)
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -632 +632 @@
         if (m->mapScreenObj.find(i) == m->mapScreenObj.end())
         {
-            settings::RecordScreenMap::const_iterator itScreen = m->bd->mapScreens.find(i);
+            settings::RecordingScreenMap::const_iterator itScreen = m->bd->mapScreens.find(i);
             if (itScreen == m->bd->mapScreens.end())
             {
-                settings::RecordScreenSettings defaultScreenSettings; /* Apply default settings. */
+                settings::RecordingScreenSettings defaultScreenSettings; /* Apply default settings. */
                 m->bd->mapScreens[i] = defaultScreenSettings;
             }

trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

@@ -1082 +1082 @@
     if (FAILED(rc)) return rc;
 
-    unconst(mRecordSettings).createObject();
-    rc = mRecordSettings->initCopy(this, pMachine->mRecordSettings);
+    unconst(mRecordingSettings).createObject();
+    rc = mRecordingSettings->initCopy(this, pMachine->mRecordingSettings);
     if (FAILED(rc)) return rc;
 
@@ -1208 +1208 @@
     mBIOSSettings->init(this);
 
-    unconst(mRecordSettings).createObject();
-    mRecordSettings->init(this);
+    unconst(mRecordingSettings).createObject();
+    mRecordingSettings->init(this);
 
     unconst(mVRDEServer).createObject();

trunk/src/VBox/Main/xml/Settings.cpp

@@ -2371 +2371 @@
 }
 
-RecordScreenSettings::RecordScreenSettings(void)
+RecordingScreenSettings::RecordingScreenSettings(void)
 {
     applyDefaults();
 }
 
-RecordScreenSettings::~RecordScreenSettings()
-{
-
-}
-
-void RecordScreenSettings::applyDefaults(void)
+RecordingScreenSettings::~RecordingScreenSettings()
+{
+
+}
+
+void RecordingScreenSettings::applyDefaults(void)
 {
     /*
@@ -2388 +2388 @@
 
     fEnabled            = false;
-    enmDest             = RecordDestination_File;
+    enmDest             = RecordingDestination_File;
     ulMaxTimeS          = 0;
     strOptions          = "";
     File.ulMaxSizeMB    = 0;
     File.strName        = "";
-    Video.enmCodec      = RecordVideoCodec_VP8;
+    Video.enmCodec      = RecordingVideoCodec_VP8;
     Video.ulWidth       = 1024;
     Video.ulHeight      = 768;
     Video.ulRate        = 512;
     Video.ulFPS         = 25;
-    Audio.enmAudioCodec = RecordAudioCodec_Opus;
+    Audio.enmAudioCodec = RecordingAudioCodec_Opus;
     Audio.cBits         = 16;
     Audio.cChannels     = 2;
     Audio.uHz           = 22050;
 
-    featureMap[RecordFeature_Video] = true;
-    featureMap[RecordFeature_Audio] = false;
+    featureMap[RecordingFeature_Video] = true;
+    featureMap[RecordingFeature_Audio] = false;
 }
 
@@ -2410 +2410 @@
  * Check if all settings have default values.
  */
-bool RecordScreenSettings::areDefaultSettings(void) const
+bool RecordingScreenSettings::areDefaultSettings(void) const
 {
     return    fEnabled            == false
-           && enmDest             == RecordDestination_File
+           && enmDest             == RecordingDestination_File
            && ulMaxTimeS          == 0
            && strOptions          == ""
            && File.ulMaxSizeMB    == 0
            && File.strName        == ""
-           && Video.enmCodec      == RecordVideoCodec_VP8
+           && Video.enmCodec      == RecordingVideoCodec_VP8
            && Video.ulWidth       == 1024
            && Video.ulHeight      == 768
            && Video.ulRate        == 512
            && Video.ulFPS         == 25
-           && Audio.enmAudioCodec == RecordAudioCodec_Opus
+           && Audio.enmAudioCodec == RecordingAudioCodec_Opus
            && Audio.cBits         == 16
            && Audio.cChannels     == 2
@@ -2429 +2429 @@
 }
 
-bool RecordScreenSettings::isFeatureEnabled(RecordFeature_T enmFeature) const
-{
-    RecordFeatureMap::const_iterator itFeature = featureMap.find(enmFeature);
+bool RecordingScreenSettings::isFeatureEnabled(RecordingFeature_T enmFeature) const
+{
+    RecordingFeatureMap::const_iterator itFeature = featureMap.find(enmFeature);
     if (itFeature != featureMap.end())
         return itFeature->second;
@@ -2443 +2443 @@
  * machine settings have really changed and thus need to be written out to disk.
  */
-bool RecordScreenSettings::operator==(const RecordScreenSettings &d) const
+bool RecordingScreenSettings::operator==(const RecordingScreenSettings &d) const
 {
     return    fEnabled            == d.fEnabled
@@ -2465 +2465 @@
  * Constructor. Needs to set sane defaults which stand the test of time.
  */
-RecordSettings::RecordSettings()
+RecordingSettings::RecordingSettings()
 {
     applyDefaults();
@@ -2473 +2473 @@
  * Applies the default settings.
  */
-void RecordSettings::applyDefaults(void)
+void RecordingSettings::applyDefaults(void)
 {
     fEnabled = false;
@@ -2482 +2482 @@
     {
         /* Always add screen 0 to the default configuration. */
-        RecordScreenSettings screenSettings; /* Apply default settings for screen 0. */
+        RecordingScreenSettings screenSettings; /* Apply default settings for screen 0. */
         screenSettings.fEnabled = true;       /* Enabled by default. */
         mapScreens[0] = screenSettings;
@@ -2495 +2495 @@
  * Check if all settings have default values.
  */
-bool RecordSettings::areDefaultSettings() const
+bool RecordingSettings::areDefaultSettings() const
 {
     const bool fDefault =    fEnabled          == false
@@ -2502 +2502 @@
         return false;
 
-    RecordScreenMap::const_iterator itScreen = mapScreens.begin();
+    RecordingScreenMap::const_iterator itScreen = mapScreens.begin();
     return    itScreen->first == 0
            && itScreen->second.areDefaultSettings();
@@ -2512 +2512 @@
  * machine settings have really changed and thus need to be written out to disk.
  */
-bool RecordSettings::operator==(const RecordSettings &d) const
+bool RecordingSettings::operator==(const RecordingSettings &d) const
 {
     if (this == &d)
@@ -2521 +2521 @@
         return false;
 
-    RecordScreenMap::const_iterator itScreen = mapScreens.begin();
+    RecordingScreenMap::const_iterator itScreen = mapScreens.begin();
     uint32_t i = 0;
     while (itScreen != mapScreens.end())
     {
-        RecordScreenMap::const_iterator itScreenThat = d.mapScreens.find(i);
+        RecordingScreenMap::const_iterator itScreenThat = d.mapScreens.find(i);
         if (itScreen->second == itScreenThat->second)
         {
@@ -4409 +4409 @@
         else if (pelmHwChild->nameEquals("VideoCapture"))
         {
-            pelmHwChild->getAttributeValue("enabled",   hw.recordSettings.fEnabled);
+            pelmHwChild->getAttributeValue("enabled",   hw.recordingSettings.fEnabled);
 
             /* Right now I don't want to bump the settings version, so just convert the enabled
@@ -4418 +4418 @@
             /* At the moment we only support one capturing configuration, that is, all screens
              * have the same configuration. So load/save to/from screen 0. */
-            Assert(hw.recordSettings.mapScreens.size()); /* At least screen must be present. */
-            RecordScreenSettings &screen0Settings = hw.recordSettings.mapScreens[0];
+            Assert(hw.recordingSettings.mapScreens.size()); /* At least screen must be present. */
+            RecordingScreenSettings &screen0Settings = hw.recordingSettings.mapScreens[0];
 
             pelmHwChild->getAttributeValue("maxTime",   screen0Settings.ulMaxTimeS);
@@ -4433 +4433 @@
             {
                 /* Add screen i to config in any case. */
-                hw.recordSettings.mapScreens[i] = screen0Settings;
+                hw.recordingSettings.mapScreens[i] = screen0Settings;
 
                 if (u64VideoCaptureScreens & RT_BIT_64(i)) /* Screen i enabled? */
-                    hw.recordSettings.mapScreens[i].fEnabled = true;
+                    hw.recordingSettings.mapScreens[i].fEnabled = true;
             }
         }
@@ -5820 +5820 @@
     }
 
-    if (m->sv >= SettingsVersion_v1_14 && !hw.recordSettings.areDefaultSettings())
+    if (m->sv >= SettingsVersion_v1_14 && !hw.recordingSettings.areDefaultSettings())
     {
         xml::ElementNode *pelmVideoCapture = pelmHardware->createChild("VideoCapture");
 
-        if (hw.recordSettings.fEnabled)
-            pelmVideoCapture->setAttribute("enabled", hw.recordSettings.fEnabled);
+        if (hw.recordingSettings.fEnabled)
+            pelmVideoCapture->setAttribute("enabled", hw.recordingSettings.fEnabled);
 
         /* Right now I don't want to bump the settings version, so just convert the enabled
          * screens to the former uint64t_t bit array and vice versa. */
         uint64_t u64VideoCaptureScreens = 0;
-        RecordScreenMap::const_iterator itScreen = hw.recordSettings.mapScreens.begin();
-        while (itScreen != hw.recordSettings.mapScreens.end())
+        RecordingScreenMap::const_iterator itScreen = hw.recordingSettings.mapScreens.begin();
+        while (itScreen != hw.recordingSettings.mapScreens.end())
         {
             if (itScreen->second.fEnabled)
@@ -5843 +5843 @@
         /* At the moment we only support one capturing configuration, that is, all screens
          * have the same configuration. So load/save to/from screen 0. */
-        Assert(hw.recordSettings.mapScreens.size());
-        const RecordScreenMap::const_iterator itScreen0Settings = hw.recordSettings.mapScreens.find(0);
-        Assert(itScreen0Settings != hw.recordSettings.mapScreens.end());
+        Assert(hw.recordingSettings.mapScreens.size());
+        const RecordingScreenMap::const_iterator itScreen0Settings = hw.recordingSettings.mapScreens.find(0);
+        Assert(itScreen0Settings != hw.recordingSettings.mapScreens.end());
 
         if (itScreen0Settings->second.ulMaxTimeS)
@@ -7442 +7442 @@
             || hardwareMachine.enmLongMode != Hardware::LongMode_Legacy
             || machineUserData.ovIcon.size() > 0
-            || hardwareMachine.recordSettings.fEnabled)
+            || hardwareMachine.recordingSettings.fEnabled)
         {
             m->sv = SettingsVersion_v1_14;