private void RecordingGroup()
    {
        RecorderBase recorder = target as RecorderBase;

        RecordingBase recordingRef = recordingProp.objectReferenceValue as RecordingBase;

        string type        = "-";
        string duration    = "-";
        string recordCount = "0";

        if (recordingRef)
        {
            type        = recordingRef.GetType().Name;
            duration    = String.Format("{0:N2}", recordingRef.duration);
            recordCount = recordingRef.Count().ToString();
        }

        EditorGUILayout.BeginVertical(EditorStyles.helpBox);
        EditorGUILayout.PropertyField(recordingNameProp);

        EditorGUILayout.LabelField("Type", type);
        EditorGUILayout.LabelField("Duration", duration);
        EditorGUILayout.LabelField("Count", recordCount);

        EditorGUILayout.LabelField("Destination Folder", recorder.DestinationFolder);

        EditorGUILayout.EndVertical();
    }
 public LinuxGeneralPurposeRecorderContext(RecorderBase recorder, Regex regSplitForValue, Dictionary<string, int> fieldOrder, string dateFormat)
     : base(recorder)
 {
     DescriptionBuffer = new StringBuilder();
     RegSplitForValue = regSplitForValue;
     FieldOrder = fieldOrder;
     DateFormat = dateFormat;
     FieldValueBuffer = new Dictionary<string, string>();
 }
        public LinuxGeneralPurposeUnifiedRecorderContext(RecorderBase recorder, Regex regSplitForValue, string dateFormat)
            : base(recorder)
        {
            contextKeys = new Dictionary<DataMappingInfo, string>();
            contextVariables = new Dictionary<DataMappingInfo, string>();

            RegSplitForValue = regSplitForValue;
            DateFormat = dateFormat;
        }
    void OnEnable()
    {
        RecorderBase recorder = target as RecorderBase;

        recorder.InitRecording();

        // Setup the SerializedProperties.
        recordProp        = serializedObject.FindProperty("doRecord");
        saveProp          = serializedObject.FindProperty("doSave");
        cancelProp        = serializedObject.FindProperty("doCancel");
        recordingProp     = serializedObject.FindProperty("recording");
        responseProp      = serializedObject.FindProperty("responseText");
        recordingNameProp = serializedObject.FindProperty("recordingName");
    }
示例#5
0
 public static void fillRecordBySeconds(RecorderBase recorder, DateTime beginTime, int start, int end)
 {
     recordAddSeconds(recorder, beginTime, start, DataType.StreamDataKey);
     for (int i = start + 1; i < end; i++)
     {
         if (i % 5 == 0)
         {
             recordAddSeconds(recorder, beginTime, i, DataType.StreamDataKey);
         }
         else
         {
             recordAddSeconds(recorder, beginTime, i, DataType.StreamData);
         }
     }
     recordAddSeconds(recorder, beginTime, end, DataType.StopSign);
 }
示例#6
0
 private static void recordAddTimeLarge(RecorderBase recorder, DateTime time, DataType type)
 {
     if (type == DataType.StreamData)
     {
         recorder.Set(time, DataType.StreamData, new byte[100000]);
     }
     else if (type == DataType.StreamDataKey)
     {
         recorder.Set(time, DataType.StreamDataKey, new byte[1920 * 1080 * 3]);
     }
     else if (type == DataType.SysHead)
     {
         recorder.Set(time, DataType.SysHead, new byte[50]);
     }
     else
     {
         recorder.Set(time, type, new byte[0]);
     }
 }
示例#7
0
 private static void recordAddTime(RecorderBase recorder, DateTime time, DataType type)
 {
     if (type == DataType.StreamData)
     {
         recorder.Set(time, DataType.StreamData, new byte[3]);
     }
     else if (type == DataType.StreamDataKey)
     {
         recorder.Set(time, DataType.StreamDataKey, new byte[6]);
     }
     else if (type == DataType.SysHead)
     {
         recorder.Set(time, DataType.SysHead, new byte[2]);
     }
     else
     {
         recorder.Set(time, type, new byte[0]);
     }
 }
    private void RecordToggle()
    {
        RecorderBase recorder = target as RecorderBase;

        Color  defaultColor = GUI.backgroundColor;
        string toggleLabel;

        if (recordProp.boolValue)
        {
            GUI.backgroundColor = Color.red;
            toggleLabel         = "Recording";
        }
        else
        {
            toggleLabel = recorder.IsPaused ? "Continue Recording" : "Start Recording";
        }

        recordProp.boolValue = GUILayout.Toggle(recordProp.boolValue, toggleLabel, buttonStyle, height);

        //reset background color
        GUI.backgroundColor = defaultColor;
    }
示例#9
0
        ///----------------------------------------------------------------------------------------------
        void Begin()
        {
            if (isRendering)
            {
                return;
            }

            isRendering = true;
            cutscene.Rewind();
            EditorApplication.ExecuteMenuItem("Window/Game");
            cutscene.currentTime = cutscene.cameraTrack.startTime;
            cutscene.Sample();

            CutsceneEditor.OnStopInEditor += Done;

            if (settings.renderPasses)
            {
                recorder = DirectorCamera.renderCamera.GetAddComponent <GBufferRecorder>();
            }
            else
            {
                recorder = DirectorCamera.renderCamera.GetAddComponent <MovieRecorder>();
            }

            var config = new MovieEncoderConfigs(settings.renderFormat);

            recorder.encoderConfigs  = config;
            recorder.captureControl  = RecorderBase.CaptureControl.Manual;
            recorder.targetFramerate = settings.framerate;
            recorder.captureAudio    = settings.captureAudio;
            recorder.fixDeltaTime    = Application.isPlaying;
            recorder.waitDeltaTime   = Application.isPlaying;

            recorder.outputDir = new DataPath(DataPath.Root.Current, GetFolderName(), GetFileName());
            recorder.BeginRecording();
        }
 public void TestFixtureTearDown()
 {
     _mcafeeıps.Clear();
     _mcafeeıps = null;
 }
    public override void OnInspectorGUI()
    {
        RecorderBase recorder = target as RecorderBase;

        serializedObject.Update();

        buttonStyle = EditorStyles.miniButtonMid;
        height      = GUILayout.Height(20);

        DrawDefaultInspector();
        EditorGUILayout.Space();

        // disable gui outside play mode
        if (recorder.disableIfNotPlaying && !Application.isPlaying)
        {
            EditorGUILayout.HelpBox("For this Recorder recording is disabled while Application is not playing.", MessageType.Info);
            GUI.enabled = false;
        }

        // record toggle
        RecordToggle();

        // recording group
        RecordingGroup();

        if (recorder.IsRecording)
        {
            showFeedback = false;

            Repaint(); // drawn 10 times per second
        }

        //only enable save/cancel if recording has been started
        GUI.enabled = GUI.enabled && recorder.IsRecordingStarted;

        // save button
        if (GUILayout.Button("Save Recording", buttonStyle, height))
        {
            saveProp.boolValue = true;
            showFeedback       = true;
        }

        // cancel button
        if (GUILayout.Button("Cancel Recording", buttonStyle, height))
        {
            cancelProp.boolValue = true;
            showFeedback         = true;
        }

        GUI.enabled = true;

        // feedback helpbox
        if (showFeedback)
        {
            EditorGUILayout.HelpBox(responseProp.stringValue, MessageType.Info);
        }

        EditorGUILayout.Space();

        serializedObject.ApplyModifiedPropertiesWithoutUndo();
    }
 public void TestFixtureSetup()
 {
     _symantecBrigtmail = new SymantecBrightmailUnifiedRecorder();
 }
 public TrendMicroUnifiedRecorderContext(RecorderBase recorder)
     : base(recorder)
 {
     Buffer = new Dictionary<string, string>();
 }
 public void TestFixtureTearDown()
 {
     _zimbra.Clear();
     _zimbra = null;
 }
 public void TestFixtureSetup()
 {
     _squidsys = new SquidSyslogUnifiedRecorder();
 }
示例#16
0
 public static void recordAddSeconds(RecorderBase recorder, DateTime beginTime, int timeoutSeconds, DataType type)
 {
     recordAddTime(recorder, beginTime.AddSeconds(timeoutSeconds), type);
 }
 public VeriBranchUnifiedRecorderContext(RecorderBase recorder)
     : base(recorder)
 {
 }
 public void TestFixtureSetup()
 {
     _ubuntuAuthUnifiedRecorder = new UbuntuAuthUnifiedRecorder();
 }
 public void TestFixtureTearDown()
 {
     _cryptTechUnifiedRecorder.Clear();
     _cryptTechUnifiedRecorder = null;
 }
 public void TestFixtureSetup()
 {
     _cryptTechUnifiedRecorder = new CryptTechUnifiedRecorder();
 }
 public HadoopUnifiedContext(RecorderBase recorder)
     : base(recorder)
 {
 }
 public void TestFixtureTearDown()
 {
     _squidsys.Clear();
     _squidsys = null;
 }
示例#23
0
 private static void recordAddMinutes(RecorderBase recorder, DateTime beginTime, int timeoutMinutes, DataType type)
 {
     recordAddTime(recorder, beginTime.AddMinutes(timeoutMinutes), type);
 }
 public LinuxDnsRecorderContext(RecorderBase recorder)
     : base(recorder)
 {
 }
 public void TestFixtureSetup()
 {
     _emcStorageRepUnifiedRecorder = new EmcStorageRepUnifiedRecorder();
 }
 public void TestFixtureTearDown()
 {
     _coslatUrlUnifiedRecorder.Clear();
     _coslatUrlUnifiedRecorder = null;
 }
 public void TestFixtureTearDown()
 {
     _ubuntuAuthUnifiedRecorder.Clear();
     _ubuntuAuthUnifiedRecorder = null;
 }
 public void TestFixtureTearDown()
 {
     _emcStorageRepUnifiedRecorder.Clear();
     _emcStorageRepUnifiedRecorder = null;
 }
 public VeriBranchUnifiedRecorderContext(RecorderBase recorder, Regex regSplitForValue, string dateFormat)
     : base(recorder)
 {
     RegSplitForValue = regSplitForValue;
     DateFormat = dateFormat;
 }
 public void TestFixtureSetup()
 {
     _mssqlErrorUnifiedRecorder = new MssqlErrorUnifiedRecorder();
 }
 public void TestFixtureSetup()
 {
     _coslatUrlUnifiedRecorder = new CoslatUrlUnifiedRecorder();
 }
 public void TestFixtureTearDown()
 {
     _mssqlErrorUnifiedRecorder.Clear();
     _mssqlErrorUnifiedRecorder = null;
 }
 public void TestFixtureSetup()
 {
     _zimbra = new ZimbraUnifiedRecorder();
 }
 public void TestFixtureSetup()
 {
     _netscalerUnifiedRecorder = new NetscalerUnifiedRecorder();
 }
 public MerakMailVersion2UnifiedRecorderContext(RecorderBase recorder)
     : base(recorder)
 {
 }
 public void TestFixtureTearDown()
 {
     _netscalerUnifiedRecorder.Clear();
     _netscalerUnifiedRecorder = null;
 }
 public LinuxJobsUnifiedRecorderContext(RecorderBase recorder)
     : base(recorder)
 {
 }
 public LabrisAdministrativeUnifiedRecorderContext(RecorderBase recorder)
     : base(recorder)
 {
 }
 public void TestFixtureTearDown()
 {
     _symantecBrigtmail.Clear();
     _symantecBrigtmail = null;
 }
 public void TestFixtureSetup()
 {
     _mcafeeıps = new McAfeeIpsUnifiedRecorder();
 }