private static void EnsureNoIdColumnIncludedWhenCreatingAutoIncrementEntites(RecordMode recordMode,
bool isAutoIncrementingId, bool isImportingEntityId)
{
if (isAutoIncrementingId && isImportingEntityId && recordMode == RecordMode.CreateOnly)
{
throw new Exception("Id is created in the database. You cannot import an ID column when creating.");
}
}
public virtual void NextCode()
{
DataBinder.Clear(this.Controls);
binder.NextCode(this.NextCodeControl, "");
this.Controls[NextCodeControl].Focus();
this.recordMode = RecordMode.None;
updateButtonsStatus();
}
public virtual void NextCode()
{
DataBinder.Clear(this.Controls);
binder.NextCode(this.NextCodeControl, "");
this.Controls[NextCodeControl].Focus();
this.recordMode = RecordMode.None;
updateButtonsStatus();
}
/// <summary>
/// 发送回调
/// </summary>
protected void SendCallFunc(RecordMode mode, Record <T> record, T item, int row)
{
if (m_callbacks != null)
{
for (int i = 0; i < m_callbacks.Count; i++)
{
if (m_callbacks[i] != null)
{
m_callbacks[i](mode, record, item, row);
}
}
}
}
private static void ValidateDbResult <TEntity>(TEntity matchedDbObject, RecordMode recordMode, string xlsxIdColName, string idValue) where TEntity : class
{
if (matchedDbObject == null && recordMode == RecordMode.UpdateOnly)
{
throw new RowParseException(xlsxIdColName + " value " + idValue +
" cannot be updated - not found in database");
}
if (matchedDbObject != null && recordMode == RecordMode.CreateOnly)
{
throw new RowParseException(xlsxIdColName + " value " + idValue + " cannot be added - already in database");
}
}
void Update()
{
if (disableUIWhenNoPlayerVehicle && activePlayerCanvas)
{
CheckCanvas();
}
if (Input.GetKeyDown(RCC_Settings.Instance.recordKB))
{
recorder.Record();
}
if (Input.GetKeyDown(RCC_Settings.Instance.playbackKB))
{
recorder.Play();
}
if (Input.GetKey(RCC_Settings.Instance.slowMotionKB))
{
Time.timeScale = .2f;
}
if (Input.GetKeyUp(RCC_Settings.Instance.slowMotionKB))
{
Time.timeScale = orgTimeScale;
}
activeMainCamera = Camera.current;
switch (recorder.mode)
{
case RCC_Recorder.Mode.Neutral:
recordMode = RecordMode.Neutral;
break;
case RCC_Recorder.Mode.Play:
recordMode = RecordMode.Play;
break;
case RCC_Recorder.Mode.Record:
recordMode = RecordMode.Record;
break;
}
}
private string CreateFFmpegArgs(RecordMode mode, Rectangle recordRegion, string output)
{
var rec = recordRegion;
int width = (rec.Width % 2 == 0) ? rec.Width : rec.Width - 1;
int height = (rec.Height % 2 == 0) ? rec.Height : rec.Height - 1;
int fps = 0;
string audio = "";
string option = "";
if (mode == RecordMode.Gif)
{
fps = CaptureSetting.GifFPS;
option = " -qp 0";
}
else if (mode == RecordMode.Mp4)
{
fps = CaptureSetting.VideoFPS;
option = " -crf 28 -pix_fmt yuv420p -movflags +faststart";
// AudioSource
if (!string.IsNullOrWhiteSpace(CaptureSetting.AudioSource) && CaptureSetting.AudioSource != DefaultAudioSource)
{
var deviceNames = GetDeviceNames()["Audio"];
var audioSource = deviceNames.FirstOrDefault(o => o == CaptureSetting.AudioSource);
if (!string.IsNullOrWhiteSpace(audioSource))
{
audio = " -f dshow -i audio=\"" + audioSource + "\"";
option += " -c:a aac -ac 2 -b:a 128k";
}
}
}
var sb = new StringBuilder();
sb.Append("-rtbufsize 150M -f gdigrab -framerate " + fps);
sb.Append(string.Format(" -offset_x {0} -offset_y {1} -video_size {2}x{3}", rec.X, rec.Y, width, height));
sb.Append(" -draw_mouse 1 -i desktop");
sb.Append(audio);
sb.Append(" -c:v libx264 -r " + fps);
sb.Append(" -preset ultrafast -tune zerolatency");
sb.Append(option);
sb.Append(" -y \"" + output + "\"");
return(sb.ToString());
}
internal Cassette(ICasseteStorage storage, string name, RecordMode recordMode, IRequestMatcher requestMatcher)
{
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
_name = name ?? throw new ArgumentNullException(nameof(name));
_requestMatcher = requestMatcher ?? throw new ArgumentNullException(nameof(requestMatcher));
_recordMode = recordMode;
var httpInteractions = storage.Load(name);
if (httpInteractions == null)
{
_isNew = true;
_httpInteractions = new List <HttpInteraction>();
}
else
{
_isNew = false;
_httpInteractions = httpInteractions;
}
}
void FixedUpdate()
{
if (mode == RecordMode.play)
{
if (place >= records.Length)
{
mode = RecordMode.none;
return;
}
while ((Time.time - startTime) > records[place].time)
{
ProcessRecord(records[place]);
place++;
if (place >= records.Length)
{
mode = RecordMode.none;
return;
}
}
}
}
void OnGUI()
{
string jsonText;
if (GUI.Button(new Rect(100, 10, 100, 30), "Record"))
{
records = new Record[] {};
mode = RecordMode.record;
startTime = Time.time;
}
if (GUI.Button(new Rect(210, 10, 100, 30), "RecordPlay"))
{
mode = RecordMode.play;
place = 0;
startTime = Time.time;
allObject = new Dictionary <string, GameObject>();
}
if (GUI.Button(new Rect(310, 10, 100, 30), "Save"))
{
new StoreRecords(records).Save("_record.json");
mode = RecordMode.none;
place = 0;
startTime = 0;
}
if (GUI.Button(new Rect(410, 10, 100, 30), "Load"))
{
StoreRecords sr = new StoreRecords("_record.json");
records = sr.records;
mode = RecordMode.play;
place = 0;
startTime = Time.time;
allObject = new Dictionary <string, GameObject>();
}
if (GUI.Button(new Rect(510, 10, 100, 30), "RenameScene"))
{
Scene src = SceneManager.GetSceneByName("TowerAtack");
Scene dst = SceneManager.CreateScene("NewTestScene");
SceneManager.MergeScenes(src, dst);
}
}
public void RecordActor(Actor actor, RecordMode mode)
{
string recordActor = mode == RecordMode.Adding ?
"INSERT INTO actors(photo, name, surname, patronymic, country, birth_date) VALUES(@photo, @name, @surname, @patronymic, @country, @birth_date)" :
"UPDATE Actors SET photo = @photo, name = @name, surname = @surname, patronymic = @patronymic, country = @country, birth_date = @birth_date WHERE id = @id";
using (SqlConnection connection = new SqlConnection(connectionString))
{
//try
//{
SqlCommand command = new SqlCommand(recordActor, connection);
//if (actor.Photo != null) command.Parameters.AddWithValue("@photo", BitmapToByte(actor.Photo));
//else
//command.Parameters.AddWithValue("@photo", DBNull.Value);
//command.Parameters.AddWithValue("@name", actor.Name);
//command.Parameters.AddWithValue("@surname", actor.Surname);
//object buffPatr = actor.Patronymic;
//if (actor.Patronymic == null) buffPatr = DBNull.Value;
//command.Parameters.AddWithValue("@patronymic", buffPatr);
//command.Parameters.AddWithValue("@country", actor.Country);
//command.Parameters.AddWithValue("@birth_date", actor.BirthDate);
//command.Parameters.AddWithValue("@id", actor.Id);
command.Parameters.AddWithValue("@photo", DBNull.Value);
command.Parameters.AddWithValue("@name", DBNull.Value);
command.Parameters.AddWithValue("@surname", DBNull.Value);
command.Parameters.AddWithValue("@patronymic", DBNull.Value);
command.Parameters.AddWithValue("@country", DBNull.Value);
command.Parameters.AddWithValue("@birth_date", DBNull.Value);
command.Parameters.AddWithValue("@id", actor.Id);
connection.Open();
command.ExecuteNonQuery();
//}
//catch (SqlException ex)
//{
// MessageBox.Show(ex.Message);
//}
}
}
private void btnDelete_Click(object sender, EventArgs e)
{
if (BeforeDelete())
{
this.recordMode = RecordMode.Delete;
DialogResult dr = MessageBox.Show("هل أنت متأكد من الحذف ؟",
"تأكيد الحذف", MessageBoxButtons.YesNo);
if (dr == System.Windows.Forms.DialogResult.Yes)
{
binder.Delete(this);
this.recordMode = RecordMode.None;
updateButtonsStatus();
fillList();
//hemaily 5aug
RecordsNo.Text = binder.Get_Records_num(this.TableName).ToString();
}
else
{
return;
}
}
}
public bool StartRecord(RecordMode mode, Rectangle recordRegion, string outputFilePath)
{
if (_proc != null)
{
return(false);
}
try
{
_recordThread = new BackgroundWorker();
_recordThread.DoWork += delegate(object sender, DoWorkEventArgs e)
{
string args = CreateFFmpegArgs(mode, recordRegion, outputFilePath);
Excute(args);
};
_recordThread.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs e)
{
_recordThread = null;
// Gif 모드일 경우 컨버팅(mp4 -> gif) 작업 추가
if (mode == RecordMode.Gif)
{
ConvertMp4ToGif(outputFilePath);
}
OnCompletedRecord?.Invoke(this, EventArgs.Empty);
};
_recordThread.RunWorkerAsync();
return(true);
}
catch (Exception e)
{
Logger.Error(e);
return(false);
}
}
void Update()
{
if (activePlayerVehicle)
{
if (activePlayerVehicle != lastActivePlayerVehicle)
{
if (OnVehicleChanged != null)
{
OnVehicleChanged();
}
}
lastActivePlayerVehicle = activePlayerVehicle;
}
if (disableUIWhenNoPlayerVehicle && activePlayerCanvas)
{
CheckCanvas();
}
if (Input.GetKeyDown(RCC_Settings.Instance.recordKB))
{
RCC.StartStopRecord();
}
if (Input.GetKeyDown(RCC_Settings.Instance.playbackKB))
{
RCC.StartStopReplay();
}
if (Input.GetKey(RCC_Settings.Instance.slowMotionKB))
{
Time.timeScale = .2f;
}
if (Input.GetKeyUp(RCC_Settings.Instance.slowMotionKB))
{
Time.timeScale = orgTimeScale;
}
if (Input.GetButtonDown("Cancel"))
{
Cursor.lockState = CursorLockMode.None;
}
activeMainCamera = Camera.main;
switch (recorder.mode)
{
case RCC_Recorder.Mode.Neutral:
recordMode = RecordMode.Neutral;
break;
case RCC_Recorder.Mode.Play:
recordMode = RecordMode.Play;
break;
case RCC_Recorder.Mode.Record:
recordMode = RecordMode.Record;
break;
}
}
/// <summary>
/// Creates or uses cassette with given name to record HTTP interactions.
/// </summary>
/// <param name="name">Cassette name</param>
/// <param name="recordMode">Rercording mode</param>
/// <param name="requestMatcher">Request matcher to use with this cassette</param>
/// <returns></returns>
public Cassette UseCassette(string name, RecordMode recordMode = RecordMode.Once, IRequestMatcher requestMatcher = null)
{
Cassette = new Cassette(Storage, name, recordMode, requestMatcher ?? DefaultMatcher);
return(Cassette);
}
public void SetRecordModeToFrameInterval(int startFrame, int endFrame)
{
m_RecordMode = RecordMode.FrameInterval;
m_StartFrame = startFrame;
m_EndFrame = endFrame;
}
public void SetRecordModeToManual()
{
m_RecordMode = RecordMode.Manual;
}
void start_recording()
{
Debug.Assert (record_mode == RecordMode.Stopped, "must be stopped");
if (runner != null) {
runner.Resume ();
record_mode = RecordMode.Recording;
} else {
if (full_log == null)
full_log = new Log ();
set_waiting_for_systemtap_to_start (true);
runner = new SystemtapRunner (full_log);
runner.StderrDataAvailable += runner_stderr_data_available_cb;
runner.ChildExited += runner_child_exited_cb;
ensure_error_window ();
error_buffer.Clear ();
runner.Run (); /* FIXME: catch exceptions? */
set_derived_model ();
update_timeout_id = GLib.Timeout.Add (1000, update_timeout_cb);
record_mode = RecordMode.Recording;
}
}
public override async Task UpdateProperties(T destination1, Dictionary <string, string> matches, Dictionary <string, string> excelRow, RecordMode recordMode)
{
{
var product = new Product();
var productCategoryPropertyName = "ProductCategoryCode";
var productPropertyName = PropertyNameHelper.GetPropertyName(() => product.ProductName);
foreach (var destinationProperty in matches.Keys)
{
var xlsxColumnName = matches[destinationProperty];
var value = excelRow[xlsxColumnName];
if (destinationProperty == productCategoryPropertyName)
{
var newCategory =
await _context.Set <ProductCategory>().Where(x => x.CategoryCode == value).FirstOrDefaultAsync();
if (newCategory == null)
{
throw new RowParseException("Category Code does not match a category");
}
destination1.ProductCategory = newCategory;
}
else if (destinationProperty == productPropertyName)
{
destination1.ProductName = value;
}
}
}
}
#pragma warning restore DF0000 // Marks undisposed anonymous objects from object creations.
#pragma warning restore DF0001 // Marks undisposed anonymous objects from method invocations.
// ReSharper restore ExplicitCallerInfoArgument
/// <summary>
/// Records/playbacks the <see cref="HttpResponseMessage" /> to specified <see cref="HttpRequestMessage" />.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="getResponseAsync">The function to call if a recording is needed.</param>
/// <param name="options">The options.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="callerFilePath">The caller file path; set automatically.</param>
/// <param name="callerMemberName">Name of the caller member; set automatically.</param>
/// <param name="callerLineNumber">The caller line number; set automatically.</param>
/// <returns>
/// The <see cref="HttpResponseMessage" />.
/// </returns>
/// <exception cref="ArgumentNullException">request
/// or
/// request</exception>
/// <exception cref="ArgumentOutOfRangeException">mode - null</exception>
public async Task <HttpResponseMessage> RecordAsync(
HttpRequestMessage request,
GetResponseAsync getResponseAsync,
CassetteOptions options = null,
CancellationToken cancellationToken = default(CancellationToken),
[CallerFilePath] string callerFilePath = "",
[CallerMemberName] string callerMemberName = "",
[CallerLineNumber] int callerLineNumber = 0)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
if (getResponseAsync is null)
{
throw new ArgumentNullException(nameof(request));
}
// Overwrite defaults with options
options = DefaultOptions & options;
// ReSharper disable once PossibleInvalidOperationException
RecordMode mode = options.Mode.Value;
// If we're in 'none' mode skip recording.
if (mode == RecordMode.None)
{
return(await getResponseAsync(request, cancellationToken).ConfigureAwait(false));
}
// Ensure request has been completed before serialization attempts
if (!(request.Content is null))
{
await request.Content.LoadIntoBufferAsync().ConfigureAwait(false);
}
// Get key data.
byte[] key = await KeyGenerator.Generate(request, cancellationToken);
// Get key data hash.
string hash = key.GetKeyHash();
/*
* Lock based on hash - so only one operation is allowed for the same hash at the same time.
*/
IDisposable @lock = await _keyedSemaphoreSlim.WaitAsync(hash, cancellationToken);
try
{
// Try to get recording from the store.
Recording recording;
bool found = false;
HttpResponseMessage response = null;
byte[] recordingData = null;
/*
* Unless we're in overwrite mode, try to get a response from the store.
*/
if (mode != RecordMode.Overwrite)
{
// Logs an error
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
void Error(string message, Exception exception = null, bool @throw = false)
{
CassetteException cassetteException = new CassetteException(
message,
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
exception);
if (@throw)
{
Logger.LogCritical(cassetteException);
throw cassetteException;
}
Logger.LogError(cassetteException);
recording = null;
found = false;
}
try
{
recordingData = await Store.GetAsync(hash, cancellationToken);
}
catch (Exception e)
{
Error("The underlying store threw an exception when attempting to retrieve a recording.", e);
}
// If we got a response and it has more than 0 bytes consider it fond!
if (!(recordingData is null) && recordingData.Length > 0)
{
found = true;
// If we're in recording mode don't bother to deserialize it as we're not going to use it
if (mode != RecordMode.Record)
{
// Deserialize recording
try
{
recording = MessagePackSerializer.Deserialize <Recording>(recordingData,
RecorderResolver.Instance);
}
catch (Exception e)
{
Error("The recording could not be deserialized.", e);
}
// Validate key
if (found && !string.Equals(hash, recording.Hash))
{
Error("The recording's hash did not match, ignoring.");
}
if (found && !string.Equals(KeyGenerator.Name, recording.KeyGeneratorName))
{
Error("The recording's key generator name did not match, ignoring.");
}
/*
* If we're in playback or auto mode we need to replay response
*/
if (found && (mode == RecordMode.Playback || mode == RecordMode.Auto))
{
if (recording.ResponseData is null)
{
Error("No response data found in recording, ignoring.");
}
// Deserialize response
if (found)
{
try
{
response = MessagePackSerializer.Deserialize <HttpResponseMessage>(
recording.ResponseData, RecorderResolver.Instance);
}
catch (Exception e)
{
Error("Failed to deserialize the response from the store, ignoring.", e);
}
}
// ReSharper disable once PossibleInvalidOperationException
RequestPlaybackMode requestPlaybackMode = options.RequestPlaybackMode.Value;
if (found)
{
if (recording.RequestData is null ||
requestPlaybackMode == RequestPlaybackMode.IgnoreRecorded)
{
if (requestPlaybackMode == RequestPlaybackMode.UseRecorded)
{
Error(
"No request found in the recording, and in RequestPlaybackMode UseRecorded.",
null,
true);
}
// ReSharper disable once PossibleNullReferenceException
response.RequestMessage = request;
}
else
{
// Deserialize request
try
{
#pragma warning disable DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation.
// ReSharper disable once PossibleNullReferenceException
response.RequestMessage =
MessagePackSerializer.Deserialize <HttpRequestMessage>(
recording.RequestData, RecorderResolver.Instance);
#pragma warning restore DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation.
}
catch (Exception e)
{
if (requestPlaybackMode == RequestPlaybackMode.UseRecorded)
{
Error(
"Failed to deserialize the request from the store, and in RequestPlaybackMode UseRecorded.",
e,
true);
}
else
{
Error("Failed to deserialize the request from the store, ignoring.", e);
}
}
}
}
// ReSharper disable once PossibleInvalidOperationException
if (found)
{
TimeSpan simulateDelay = options.SimulateDelay.Value;
if (simulateDelay != default(TimeSpan))
{
int delay = simulateDelay < TimeSpan.Zero
? recording.DurationMs
: (int)simulateDelay.TotalMilliseconds;
Logger.LogInformation(
$"Responding with matching recording from '{recording.RecordedUtc.ToLocalTime()}' after {delay}ms simulated delay.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber);
await Task.Delay(delay, cancellationToken);
}
else
{
Logger.LogInformation(
$"Responding with matching recording from '{recording.RecordedUtc.ToLocalTime()}'.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber);
}
return(response);
}
}
}
}
}
// If we're in playback mode we've failed to get a recording so error
if (mode == RecordMode.Playback)
{
// Recording not found so error in playback mode.
CassetteNotFoundException exception = new CassetteNotFoundException(
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber);
Logger.LogError(exception);
throw exception;
}
/*
* Record original request to detect changes if options set to RequestRecordMode.RecordIfChanged
*/
byte[] requestData;
// ReSharper disable once PossibleInvalidOperationException
RequestRecordMode requestRecordMode = options.RequestRecordMode.Value;
if (!found && requestRecordMode == RequestRecordMode.RecordIfChanged)
{
// If the key was generated with the FullRequestKeyGenerator.Instance then the request is already serialized.
if (ReferenceEquals(KeyGenerator, FullRequestKeyGenerator.Instance))
{
requestData = key;
}
else
{
try
{
requestData = MessagePackSerializer.Serialize(request, RecorderResolver.Instance);
}
catch (Exception e)
{
CassetteException ce = new CassetteException(
"Failed to serialize the request.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
e);
Logger.LogCritical(ce);
throw ce;
}
}
}
else
{
requestData = null;
}
/*
* Retrieve response from endpoint.
*/
int durationMs;
DateTime recordedUtc;
try
{
// Use stopwatch to record how long it takes to get a response.
Stopwatch stopwatch = Stopwatch.StartNew();
#pragma warning disable DF0010 // Marks undisposed local variables.
response = await getResponseAsync(request, cancellationToken).ConfigureAwait(false);
#pragma warning restore DF0010 // Marks undisposed local variables.
durationMs = (int)stopwatch.ElapsedMilliseconds;
recordedUtc = DateTime.UtcNow;
}
catch (Exception e)
{
// TODO We could save the exception an repeat on playback, useful for testing handlers
// Unfortunately MessagePack-CSharp doesn't support exception serialization normally so would need to be
// handled in a custom way.
CassetteException re = new CassetteException("Fatal error occured retrieving the response.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
e);
Logger.LogError(re);
throw re;
}
// If we have a recording, don't overwrite just return the new response here.
if (found)
{
Logger.LogInformation(
"Existing recording found so not overwriting it.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber);
return(response);
}
// Serialize response
byte[] responseData;
try
{
responseData = MessagePackSerializer.Serialize(response, RecorderResolver.Instance);
}
catch (Exception e)
{
CassetteException re = new CassetteException(
"Failed to serialize response, not storing.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
e);
Logger.LogError(re);
return(response);
}
if (requestRecordMode != RequestRecordMode.Ignore)
{
byte[] oldRequestData = requestData;
// Serialize the request
try
{
requestData =
MessagePackSerializer.Serialize(response.RequestMessage, RecorderResolver.Instance);
// If we're only recording requests on change, check for changes
if (requestRecordMode == RequestRecordMode.RecordIfChanged &&
// ReSharper disable once AssignNullToNotNullAttribute
requestData.SequenceEqual(oldRequestData))
{
requestData = null;
}
}
catch (Exception e)
{
CassetteException re = new CassetteException(
"Failed to serialize response's request message, so ignoring check.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
e);
Logger.LogError(re);
requestData = null;
}
}
// Create new recording
recording = new Recording(
hash,
KeyGenerator.Name,
recordedUtc,
durationMs,
responseData,
requestData);
// Finally serialize the recording
try
{
recordingData = MessagePackSerializer.Serialize(recording, RecorderResolver.Instance);
}
catch (Exception e)
{
CassetteException re = new CassetteException(
"Failed to serialize recording, not storing.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
e);
Logger.LogError(re);
return(response);
}
// Set the response
Logger.LogInformation(
$"Recording response at '{recordedUtc.ToLocalTime()}' (took {durationMs} ms).",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber);
if (options.WaitForSave == true)
{
try
{
await Store.StoreAsync(hash, recordingData);
}
catch (Exception e)
{
// Just log the error.
CassetteException re = new CassetteException(
"Failed to store recording.",
Store.Name,
callerFilePath,
callerMemberName,
callerLineNumber,
e);
Logger.LogError(re);
}
// We can now dispose the lock safely.
@lock.Dispose();
}
else
{
// Store the recording asynchronously, and don't wait the result (errors will be logged and suppressed).
StoreAsync(hash, recordingData, @lock, callerFilePath, callerMemberName, callerLineNumber);
}
// Return the response.
return(response);
}
public virtual void StopRecording()
{
_recordMode = RecordMode.Live;
}
public virtual void StartRecording()
{
_recordMode = RecordMode.Record;
}
void set_record_mode(RecordMode mode)
{
Gtk.Action action;
if (mode == record_mode)
return;
switch (mode) {
case RecordMode.Stopped:
suspend_recording ();
action = action_group.GetAction ("record-stop");
break;
case RecordMode.Recording:
start_recording ();
action = action_group.GetAction ("record-record");
break;
default:
Debug.Assert (false, "not reached");
action = null;
break;
}
setting_record_mode = true;
action.Activate ();
setting_record_mode = false;
}
public virtual void StartRecording()
{
_recordMode = RecordMode.Record;
}
public virtual void StopRecording()
{
_recordMode = RecordMode.Live;
}
/// <summary>
/// Handles UI sync for pre load of data grids.
/// </summary>
/// <param name="mode">The grid we are loading.</param>
private void preLoad(RecordMode mode)
{
var action = string.Empty;
if (mode == RecordMode.Matching)
action = "Searching";
else
{
if (dataGridViewMatch.Columns["Print"] != null)
dataGridViewMatch.Columns.Remove("Print");
dataGridViewMatch.DataSource = null;
action = "Loading";
}
lblStatus.Text = string.Format("{0} {1} records...please wait.", action, mode);
groupBoxDetail.Enabled = false;
groupBoxMatch.Enabled = false;
groupBoxSearch.Enabled = false;
}
private void handleRecordButtonOn()
{
recordButton.ImageIndex = 1;
recordMode = RecordMode.Recording;
optionsTable.Enabled = false;
int eventToTrack = 1;
if (recordRig)
{
eventToTrack++;
}
if (recordDepth)
{
eventToTrack++;
}
finishRecording = new CountdownEvent(eventToTrack);
// Disable changing to options table
string timeStr = (DateTime.Now.ToShortDateString() + "_" + DateTime.Now.ToLongTimeString()).Replace("/", "_").Replace(":", "_").Replace(" ", "");
mapFileName[tempRgbFileName] = ((string)optionsTable.Rows[4].Cells[1].Value).Replace("[DateTime]", timeStr) + "." + ((string)optionsTable.Rows[1].Cells[1].Value);
mapFileName[tempDepthFileName] = ((string)optionsTable.Rows[6].Cells[1].Value).Replace("[DateTime]", timeStr) + "." + ((string)optionsTable.Rows[5].Cells[1].Value);
mapFileName[tempRigFileName] = ((string)optionsTable.Rows[9].Cells[1].Value).Replace("[DateTime]", timeStr) + ".xml" ;
startRecordRgb();
startRecordDepth();
if (recordRig)
{
startRecordRig();
}
}
void suspend_recording()
{
Debug.Assert (record_mode == RecordMode.Recording, "must be recording");
runner.Suspend ();
record_mode = RecordMode.Stopped;
}
private StringBuilder makeLogData(RecordMode mode)
{
StringBuilder text = new StringBuilder();
if (RcvLogData == null)
{
return text;
}
string note = "Start Logging time: " + LogStartTime.ToString();
text.AppendLine(note);
string delimiter;
if (mode == RecordMode.ClipBoard)
{
delimiter = "\t";
}
else
{
delimiter = ",";
}
if (CheckedCellData != null)
{
string header = "Rcv Status" + delimiter + "OS Timer" + delimiter + "Count";
foreach (var name in CheckedCellData)
{
header = header + delimiter + name.Cells[(int)DgvRowName.Name].Value;
}
text.AppendLine(header);
}
if (RcvLogData.Count != 0)
{
foreach (var list in RcvLogData)
{
string line = "";
foreach (var data in list)
{
if (line == "")
{
line = data;
}
else
{
line = line + delimiter + data;
}
}
text.AppendLine(line);
}
}
return text;
}
private static async Task MapIntoEntity <TEntity>(Dictionary <string, string> matchingData, string idPropertyName,
UpdatePropertyOverrider <TEntity> overridingMapper, TEntity entityToUpdate, Dictionary <string, string> excelRow, bool isAutoIncrementingId, RecordMode recordMode)
{
if (overridingMapper != null)
{
await overridingMapper.UpdateProperties(entityToUpdate, matchingData, excelRow, recordMode);
}
else
{
UpdateProperties(entityToUpdate, matchingData, excelRow, idPropertyName, isAutoIncrementingId);
}
}
public void StopRecording()
{
recordMode = RecordMode.Live;
}
public abstract Task UpdateProperties(TSelector destination, Dictionary <string, string> destinationProperty, Dictionary <string, string> value, RecordMode recordMode);
public void StartRecording()
{
recordMode = RecordMode.Record;
}
public void SetRecordModeToSingleFrame(int frameNumber)
{
m_RecordMode = RecordMode.SingleFrame;
m_StartFrame = m_EndFrame = frameNumber;
}
private void btnDelete_Click(object sender, EventArgs e)
{
if (BeforeDelete())
{
this.recordMode = RecordMode.Delete;
DialogResult dr = MessageBox.Show("هل أنت متأكد من الحذف ؟",
"تأكيد الحذف", MessageBoxButtons.YesNo);
if (dr == System.Windows.Forms.DialogResult.Yes)
{
binder.Delete(this);
this.recordMode = RecordMode.None;
updateButtonsStatus();
fillList();
//hemaily 5aug
RecordsNo.Text = binder.Get_Records_num(this.TableName).ToString();
}
else
return;
}
}
public void SetRecordModeToTimeInterval(float startTime, float endTime)
{
m_RecordMode = RecordMode.TimeInterval;
m_StartTime = startTime;
m_EndTime = endTime;
}
void ensure_recording_stopped()
{
if (update_timeout_id != 0) {
GLib.Source.Remove (update_timeout_id);
update_timeout_id = 0;
}
set_waiting_for_systemtap_to_start (false);
record_mode = RecordMode.Stopped;
}
public static bool RecordInput(string filename, RecordMode mode)
{
return((Result)NativeIUP.IupRecordInput(filename, (int)mode) == Result.NoError);
}
/// <summary>
/// Handles UI sync for post load of data grids.
/// </summary>
/// <param name="mode">The grid we are loading.</param>
private void postLoad(RecordMode mode, string elapsed)
{
var count = 0;
if (mode == RecordMode.Detail)
{
var startRecord = _pagingIndex * _pagingSize +1;
var endRecord = startRecord -1 + _pagingSize;
if (_pagingIndex == _pagesTotal)
endRecord = _recordTotal;
btnPrintPreview.Enabled = false;
btnPrint.Enabled = false;
selectAllToolStripMenuItem.Enabled = false;
selectAllToolStripMenuItem.Text = "Select All Records";
lblPaging.Text = string.Format("Showing records {0} - {1} of {2}",startRecord, endRecord, _recordTotal);
lblStatus.Text = string.Empty;
}
else
{
count = dataGridViewMatch.Rows.Count;
btnPrintPreview.Enabled = (count > 0);
btnPrint.Enabled = (count > 0);
selectAllToolStripMenuItem.Enabled = (count > 0);
selectAllToolStripMenuItem.Text = "Select All Records";
lblStatus.Text = string.Format("{0} record(s) loaded in {1} sec.", count,elapsed);
}
groupBoxDetail.Enabled = true;
groupBoxMatch.Enabled = true;
groupBoxSearch.Enabled = true;
}
