public void AddMarker(bool editText = false, int?frame = null)
{
// feos: we specify the selected frame if we call this from TasView, otherwise marker should be added to the emulated frame
var markerFrame = frame ?? Global.Emulator.Frame;
if (editText)
{
InputPrompt i = new InputPrompt
{
Text = "Marker for frame " + markerFrame,
TextInputType = InputPrompt.InputType.Text,
Message = "Enter a message",
InitialValue =
Markers.IsMarker(markerFrame) ?
Markers.PreviousOrCurrent(markerFrame).Message :
""
};
var result = i.ShowHawkDialog();
if (result == DialogResult.OK)
{
Markers.Add(new TasMovieMarker(markerFrame, i.PromptText));
UpdateValues();
}
}
else
{
Markers.Add(new TasMovieMarker(markerFrame, ""));
UpdateValues();
}
Tastudio.RefreshDialog();
}
internal void MoveMarker(int?index, double latitude, double longitude, double?altitude)
{
if (!IsEditable)
{
return;
}
Log.Debug($"MoveMarker: {index?.ToString() ?? "<null>"}, {latitude}, {longitude}, {altitude}");
MapMarkerModel marker;
if (index == null)
{
Markers.Add(marker = new MapMarkerModel()
{
IsEditable = true
});
}
else
{
marker = Markers[index.Value];
}
if (marker.IsEditable)
{
marker.Latitude = latitude;
marker.Longitude = longitude;
marker.Altitude = altitude;
MarkersChanged?.Invoke();
}
}
/// <inheritdoc/>
public void Draw(TextView textView, DrawingContext drawingContext)
{
Debug.Assert(_textView == textView, "The MarkerRenderer belongs to a different TextEditor.");
if (!IsEnabled || Markers == null || Markers.Count == 0)
{
return;
}
// Draw only the relevant part.
if (textView.VisualLines.Count == 0)
{
return;
}
// Offsets of the first and last visual text.
int visualStart = textView.VisualLines[0].FirstDocumentLine.Offset;
int visualEnd = textView.VisualLines.Last().LastDocumentLine.Offset
+ textView.VisualLines.Last().LastDocumentLine.Length;
foreach (var marker in Markers.FindOverlappingSegments(visualStart, visualEnd))
{
marker.Draw(textView, drawingContext);
}
}
public static void Options()
{
// Cria o arquivo se ele não existir
if (!Directories.Options.Exists)
{
Clean.Options();
}
else
{
// Create a Timer file
BinaryReader Arquivo = new BinaryReader(File.OpenRead(Directories.Options.FullName));
// Load the Data
Lists.Options.Jogo_Name = Arquivo.ReadString();
Lists.Options.SalvarUsuário = Arquivo.ReadBoolean();
Lists.Options.Sons = Arquivo.ReadBoolean();
Lists.Options.Músicas = Arquivo.ReadBoolean();
Lists.Options.User = Arquivo.ReadString();
// Download the file
Arquivo.Dispose();
}
// Adds the Data to the cache
Markers.Locate("Sons").State = Lists.Options.Sons;
Markers.Locate("Músicas").State = Lists.Options.Músicas;
Markers.Locate("SalvarUsuário").State = Lists.Options.SalvarUsuário;
if (Lists.Options.SalvarUsuário)
{
Scanners.Locate("Conectar_Usuário").Text = Lists.Options.User;
}
}
public void AddBigIllustration(int key, int illustNum, Vector2 markerPosition)
{
//markerPositionList.Add(new Vector3(markerPosition.x, markerPosition.y));
bigIllustrations[key] = illustNum;
GameObject clone = Instantiate(effectObjectOrigin);
clone.transform.SetParent(effectListContent.transform);
clone.GetComponent <RectTransform>().localScale = Vector3.one;
Markers clonem = clone.GetComponent <Markers>();
clonem.type = "BigIllustration";
clonem.key = key;
clonem.valueIndex = 0;
clonem.position = markerPosition;
markersList.Add(clonem);
clonem.SetDialog(this);
clone.GetComponentInChildren <Text>().text = key.ToString() + " : " + " BigIllustrationPopUp - " + illustNum;
GameObject smallMarker = Instantiate(smallMarkerOrigin);
smallMarker.transform.SetParent(de.editorsTextInputField.transform);
smallMarker.GetComponent <RectTransform>().anchoredPosition = new Vector3(markerPosition.x, markerPosition.y - 20);
smallMarker.GetComponent <RectTransform>().localScale = Vector3.one;
clonem.SetSmallMarker(smallMarker);
smallMarker.GetComponent <Image>().color = new Color(1.0f, 1.0f, 1.0f, 0.5f); //bg => white
}
public void Clear()
{
MathItems.Clear();
Cursors.Clear();
Markers.Clear();
Traces.Clear();
}
private void ClearTasprojExtras()
{
ClearLagLog();
_stateManager.ClearStateHistory();
Markers.Clear();
ChangeLog.ClearLog();
}
/// <summary>
/// Constructor for generating new JPEG2000 Codestream, without an
/// backing IO. Codestream is created with a collection of functional
/// and informative markers that supply basic information about the
/// image and coding parameters.
///
/// To fill this image with data you should create new tile parts with
/// the parent CodestreamNode set to this instance.
///
/// There are 3 mandatory marker segments that must be provided: SIZ,
/// COD and QCD.
/// </summary>
/// <param name="markers"></param>
/// <param name="expectedTileParts"></param>
public JP2Codestream(IEnumerable <MarkerSegment> markers,
int expectedTileParts)
: base(null)
{
if (markers == null)
{
throw new ArgumentNullException("markers");
}
Markers = markers.ToDictionary(marker => marker.Type);
var missing = MandatoryMarkers.Where(
mandatory => !Markers.ContainsKey(mandatory));
if (missing.Any())
{
throw new ArgumentException(
"Mandatory marker is missing: " + missing.First());
}
_expectedTileParts = expectedTileParts;
ConstructCommon();
Tiles = ConstructTiles();
_tlmMarkers = new List <TlmMarker>()
{
new TlmMarker(0)
};
UpdateSotOffset(markers, expectedTileParts);
}
protected override void draw_gui()
{
LockControls();
WindowPos =
GUILayout.Window(GetInstanceID(),
WindowPos,
DrawMainWindow,
Title,
GUILayout.Width(width),
GUILayout.Height(height)).clampToScreen();
if (warning.doShow)
{
var facility = EditorLogic.fetch.ship.shipFacility;
warning.Draw("Are you sure you want to save current ship configuration as default for " + facility + "?");
if (warning.Result == SimpleDialog.Answer.Yes)
{
TCAScenario.UpdateDefaultConfig(facility, CFG);
}
}
PartsEditor.Draw();
if (show_imbalance && ActiveEngines.Count > 0)
{
Markers.DrawWorldMarker(WetCoM, Color.yellow, "Center of Mass", CoM_Icon);
Markers.DrawWorldMarker(DryCoM, Color.red, "Center of Dry Mass", CoM_Icon);
}
}
public void BuildAutomaticPoints()
{
ClearAll();
if (!IntervalSettings.isAuto)
{
Markers.Add(((IntervalSettings.PointsQuantity - 1) / 2) + 1);
CenterFrequencys.Add(IntervalSettings.HandCenterFrequency);
}
else
{
if (IntervalSettings.FrequencyInnerStep <= 0)
{
MessageBox.Show("ШАГ СКАНИРОВАНИЯ ДОЛЖЕН БЫТЬ БОЛЬШЕ 0");
return;
}
if (IntervalSettings.FrequencyStart > IntervalSettings.FrequencyStop)
{
MessageBox.Show("КОНЕЦ ДИАПАЗОНА ДОЛЖЕН БЫТЬ БОЛЬШЕ НАЧАЛА ДИАПАЗОНА");
return;
}
long CurrentCenterFrequency;
long innerStepQuantity = (IntervalSettings.FrequencyStop - IntervalSettings.FrequencyStart) / IntervalSettings.FrequencyInnerStep;
if (innerStepQuantity <= IntervalSettings.PointsQuantity - 1)
{
IntervalSettings.Span = IntervalSettings.FrequencyStop - IntervalSettings.FrequencyStart;
CurrentCenterFrequency = IntervalSettings.FrequencyStart + IntervalSettings.Span / 2;
CenterFrequencys.Add(CurrentCenterFrequency);
for (int counter = 0; counter <= innerStepQuantity; counter++)
{
Markers.Add(counter * ((IntervalSettings.PointsQuantity - 1) / (int)innerStepQuantity));
}
}
else
{
IntervalSettings.Span = (IntervalSettings.PointsQuantity - 1) * IntervalSettings.FrequencyInnerStep;
CurrentCenterFrequency = IntervalSettings.FrequencyStart + IntervalSettings.Span / 2;
CenterFrequencys.Add(CurrentCenterFrequency);
while ((CurrentCenterFrequency + IntervalSettings.Span / 2) < IntervalSettings.FrequencyStop)
{
CurrentCenterFrequency += IntervalSettings.Span;
CenterFrequencys.Add(CurrentCenterFrequency);
}
for (int counter = 0; counter <= innerStepQuantity; counter++)
{
Markers.Add(counter);
}
}
}
}
private void MarkerView_QueryItemBkColor(int index, InputRoll.RollColumn column, ref Color color)
{
var prev = Markers.PreviousOrCurrent(Global.Emulator.Frame); //Temp fix
if (prev != null && index == Markers.IndexOf(prev))
{
color = TAStudio.Marker_FrameCol;
}
else if (index < Markers.Count)
{
var marker = Markers[index];
var record = Tastudio.CurrentTasMovie[marker.Frame];
if (record.Lagged.HasValue)
{
if (record.Lagged.Value)
{
color = column.Name == "FrameColumn" ? TAStudio.LagZone_FrameCol : TAStudio.LagZone_InputLog;
}
else
{
color = column.Name == "LabelColumn" ? TAStudio.GreenZone_FrameCol : TAStudio.GreenZone_InputLog;
}
}
else
{
color = Color.White;
}
}
else
{
color = Color.White;
}
}
public void InsertInput(int frame, IEnumerable <string> inputLog)
{
bool endBatch = ChangeLog.BeginNewBatch("Insert Frame: " + frame, true);
ChangeLog.AddGeneralUndo(frame, InputLogLength + inputLog.Count() - 1);
_log.InsertRange(frame, inputLog);
Changes = true;
InvalidateAfter(frame);
if (BindMarkersToInput)
{
bool wasRecording = ChangeLog.IsRecording;
ChangeLog.IsRecording = false;
int firstIndex = Markers.FindIndex(m => m.Frame >= frame);
if (firstIndex != -1)
{
for (int i = firstIndex; i < Markers.Count; i++)
{
TasMovieMarker m = Markers.ElementAt(i);
Markers.Move(m.Frame, m.Frame + inputLog.Count());
}
}
ChangeLog.IsRecording = wasRecording;
}
ChangeLog.SetGeneralRedo();
if (endBatch)
{
ChangeLog.EndBatch();
}
}
private void _LayerCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
ObservableCollection <LayerClass> layers = (ObservableCollection <LayerClass>)sender;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
_InsertMarkers(layers, e.NewItems.Cast <LayerClass>(), e.NewStartingIndex);
break;
case NotifyCollectionChangedAction.Move:
case NotifyCollectionChangedAction.Replace:
_RemoveMarkers(layers, e.OldItems.Count, e.OldStartingIndex);
_InsertMarkers(layers, e.NewItems.Cast <LayerClass>(), e.NewStartingIndex);
break;
case NotifyCollectionChangedAction.Remove:
_RemoveMarkers(layers, e.OldItems.Count, e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Reset:
Markers.Clear();
break;
}
}
private void ClearTasprojExtras()
{
LagLog.Clear();
TasStateManager?.Clear();
Markers.Clear();
ChangeLog.Clear();
}
public void Replace(Signature sig, Marker data)
{
bool added = false;
for (int i = 1; i < Markers.Count; i++)
{
Marker m = (Marker)Markers [i];
if (m.Matches(sig))
{
if (!added)
{
Markers [i] = data;
added = true;
}
else
{
Markers.RemoveAt(i--);
}
}
else if (!m.IsApp || m.Type > sig.Id)
{
if (!added)
{
Markers.Insert(i, data);
added = true;
}
}
}
if (!added)
{
throw new System.Exception(String.Format("unable to replace {0} marker", sig.Name));
}
}
public static void DrawPath(CelestialBody body, WayPoint wp0, WayPoint wp1, Color c, float alpha = -1)
{
if (alpha >= 0)
{
c.a = alpha;
}
if (c.a.Equals(0))
{
return;
}
var D = wp1.AngleTo(wp0);
var N = (int)Mathf.Clamp((float)D * Mathf.Rad2Deg, 1, 5);
var dD = D / N;
var last_point = wp0.WorldPos(body);
Vector3d point;
Color line_color = c;
line_color.a /= 2;
for (int i = 1; i < N; i++)
{
var p = wp0.PointBetween(wp1, dD * i);
p.SetAlt2Surface(body);
Markers.DrawCBMarker(body, p, c, out point, PathNodeMarker, path_point_size);
Utils.GLLine(last_point, point, line_color);
last_point = point;
}
Utils.GLLine(last_point, wp1.WorldPos(body), line_color);
}
private void AddTasProjLumps(ZipStateSaver bs, bool isBackup = false)
{
var settings = JsonConvert.SerializeObject(TasStateManager.Settings);
bs.PutLump(BinaryStateLump.StateHistorySettings, tw => tw.WriteLine(settings));
bs.PutLump(BinaryStateLump.LagLog, tw => LagLog.Save(tw));
bs.PutLump(BinaryStateLump.Markers, tw => tw.WriteLine(Markers.ToString()));
if (ClientSettingsForSave != null)
{
var clientSettingsJson = ClientSettingsForSave();
bs.PutLump(BinaryStateLump.ClientSettings, (TextWriter tw) => tw.Write(clientSettingsJson));
}
if (VerificationLog.Any())
{
bs.PutLump(BinaryStateLump.VerificationLog, tw => tw.WriteLine(VerificationLog.ToInputLog()));
}
if (Branches.Any())
{
Branches.Save(bs);
}
bs.PutLump(BinaryStateLump.Session, tw => tw.WriteLine(JsonConvert.SerializeObject(TasSession)));
if (!isBackup)
{
bs.PutLump(BinaryStateLump.StateHistory, bw => TasStateManager.SaveStateHistory(bw));
}
}
public void addMarker(Markers marker)
{
if (!markers.Contains(marker))
{
markers.Add(marker);
}
}
public void DuplicatePlot(ShipTrackGmapPlotViewModel vm)
{
foreach (var marker in vm.Markers)
{
Markers.Add(marker);
}
}
public void InsertInput(int frame, string inputState)
{
bool endBatch = ChangeLog.BeginNewBatch($"Insert Frame: {frame}", true);
ChangeLog.AddGeneralUndo(frame, InputLogLength);
Log.Insert(frame, inputState);
Changes = true;
InvalidateAfter(frame);
if (BindMarkersToInput)
{
bool wasRecording = ChangeLog.IsRecording;
ChangeLog.IsRecording = false;
int firstIndex = Markers.FindIndex(m => m.Frame >= frame);
if (firstIndex != -1)
{
for (int i = firstIndex; i < Markers.Count; i++)
{
TasMovieMarker m = Markers[i];
Markers.Move(m.Frame, m.Frame + 1);
}
}
ChangeLog.IsRecording = wasRecording;
}
ChangeLog.SetGeneralRedo();
if (endBatch)
{
ChangeLog.EndBatch();
}
}
public void removeMarker(Markers marker)
{
if (markers.Contains(marker))
{
markers.Remove(marker);
}
}
private void ShiftBindedMarkers(int frame, int offset)
{
if (BindMarkersToInput)
{
Markers.ShiftAt(frame, offset);
}
}
private async Task LoadImagesAsync()
{
int imagesCount = 0;
if (Images != null)
{
imagesCount = Images.Count;
}
Images = await Api.GetImagesAsync(EntryId);
if (Log.IsDebugEnabled())
{
Log.Debug($"LoadImages, previous images: {imagesCount}, markers: {Markers.Count}, entry locations: {Model.Locations.Count}.");
Log.Debug(Json.Serialize(Markers));
}
if (imagesCount > 0)
{
Markers.RemoveRange(0, imagesCount);
}
if (Log.IsDebugEnabled())
{
Log.Debug($"LoadImages.Cleared, markers: {Markers.Count}.");
Log.Debug(Json.Serialize(Markers));
}
for (int i = 0; i < Images.Count; i++)
{
var image = Images[i];
Markers.Insert(i, new MapMarkerModel
{
Latitude = image.Location.Latitude,
Longitude = image.Location.Longitude,
Altitude = image.Location.Altitude,
DropColor = "blue",
Title = image.Name
});
}
if (Log.IsDebugEnabled())
{
Log.Debug($"LoadImages.Final, markers: {Markers.Count}.");
Log.Debug(Json.Serialize(Markers));
}
GalleryItems.Clear();
foreach (var image in Images)
{
GalleryItems.Add(new GalleryModel()
{
Title = image.Name,
Width = image.Preview.Width,
Height = image.Preview.Height
});
}
}
void AddSummonAreaEffect(vec2 pos, vec2 area)
{
vec2 cell_size = 2 * (1 / DataGroup.GridSize);
vec2 size = vec(1.266f, 1.35f) * area * cell_size;
Markers.Add(new Marker(this, pos, size, Assets.MagicTexture, alpha_fade: -1.5f, frames: 4, frame_length: .1375f, DrawOrder: DrawOrder.AfterTiles, dsize_dt: .65f * size));
Markers.Add(new Marker(this, pos, size, Assets.MagicTexture, alpha_fade: -1.5f, frames: 4, frame_length: .1375f, DrawOrder: DrawOrder.AfterUnits, dsize_dt: .65f * size, alpha: 1));
}
public override void StartNewRecording()
{
ClearTasprojExtras();
Markers.Add(0, StartsFromSavestate ? "Savestate" : "Power on");
ChangeLog = new TasMovieChangeLog(this);
base.StartNewRecording();
}
void AddSummonUnitEffect(vec2 GridCoord)
{
vec2 size = vec(1.266f, 1.35f) * 2 * CellWorldSize;
vec2 pos = GridToWorldCood(floor(GridCoord)) + new vec2(CellWorldSize.x, -CellWorldSize.y) / 2;
Markers.Add(new Marker(this, pos, size, Assets.MagicTexture, -1f, frames: 4, DrawOrder: DrawOrder.AfterTiles, dsize_dt: vec(.002f, .002f)));
Markers.Add(new Marker(this, pos, size, Assets.MagicTexture, -1f, frames: 4, DrawOrder: DrawOrder.AfterUnits, dsize_dt: vec(.002f, .002f), alpha: 1));
}
public ActionResult DeleteConfirmed(int id)
{
Markers markers = db.Markers.Find(id);
db.Markers.Remove(markers);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ClearAll()
{
SignalClear();
NoiseClear();
Frequencys.Clear();
CenterFrequencys.Clear();
Markers.Clear();
}
public void UpdateFileAndMarkerLookUp()
{
if (Markers != null)
{
FileLookUp = FileUtil.GetFileLookUp(new HashSet <string>(Markers.Select(m => m.FilePath)));
MarkerLookUp = CreateMarkerLookUp();
}
}
Func <IDictionary, string, object> GetEvaluator(string marker)
{
if (Markers == null || !Markers.ContainsKey(marker))
{
return(null);
}
return(Markers[marker]);
}
private void PrintBoard(Markers[] board)
{
string space = " | ";
ui.PrintToUser(board[0].ToString() + space + board[1].ToString() + space + board[2]);
ui.PrintToUser("----------");
ui.PrintToUser(board[3].ToString() + space + board[4].ToString() + space + board[5]);
ui.PrintToUser("----------");
ui.PrintToUser(board[6].ToString() + space + board[7].ToString() + space + board[8]);
}
/// <summary>
/// Read a Markers from stream, compare it to the desired Marker.
/// </summary>
/// <param name="desiredMarker">The desired Markers.</param>
/// <returns>Whether read Markers equals the desired Markers.</returns>
public bool ReadMarker(Markers desiredMarker)
{
byte[] buffer = new byte[PidLength];
int len = this.Read(buffer, 0, PidLength);
if (len == PidLength)
{
uint marker = BitConverter.ToUInt32(buffer, 0);
return (Markers)marker == desiredMarker;
}
return false;
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.StartRecip)
{
this.StartMarker = Markers.StartRecip;
this.PropList = new PropList(stream);
if (stream.ReadMarker() == Markers.EndToRecip)
{
this.EndMarker = Markers.EndToRecip;
}
else
{
throw new Exception("The Recipient cannot be parsed successfully. The EndToRecip Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.IncrSyncProgressMode)
{
this.StartMarker = Markers.IncrSyncProgressMode;
this.propertiesTag = stream.ReadUInt32();
this.propertiesLength = stream.ReadUInt32();
ProgressInformation tmpProgressInfo = new ProgressInformation();
tmpProgressInfo.Parse(stream);
this.PropList = tmpProgressInfo;
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.NewAttach)
{
this.StartMarker = Markers.NewAttach;
this.PidTagAttachNumber = new FixedPropTypePropValue(stream);
this.AttachmentContent = new AttachmentContent(stream);
if (stream.ReadMarker() == Markers.EndAttach)
{
this.EndMarker = Markers.EndAttach;
}
else
{
throw new Exception("The Attachment cannot be parsed successfully. The EndAttach Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.StartTopFld)
{
this.StartMarker = Markers.StartTopFld;
this.FolderContentNoDelProps = new FolderContentNoDelProps(stream);
if (stream.ReadMarker() == Markers.EndFolder)
{
this.EndMarker = Markers.EndFolder;
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.IncrSyncStateBegin)
{
this.StartMarker = Markers.IncrSyncStateBegin;
this.PropList = new PropList(stream);
if (stream.ReadMarker() == Markers.IncrSyncStateEnd)
{
this.EndMarker = Markers.IncrSyncStateEnd;
}
else
{
throw new Exception("The State cannot be parsed successfully. The IncrSyncStateEnd Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.IncrSyncGroupInfo)
{
this.StartMarker = Markers.IncrSyncGroupInfo;
this.propertiesTag = stream.ReadUInt32();
this.propertiesLength = stream.ReadUInt32();
PropertyGroupInfo tmpGroupInfo = new PropertyGroupInfo();
tmpGroupInfo.Parse(stream);
this.PropList = tmpGroupInfo;
}
}
public static bool LMap2ResX(Markers markers, processStringsEvent onProcessString) {
string txt = null; Dictionary<string, object> props = new Dictionary<string, object>();
List<string> keys = new List<string>();
List<string> values = new List<string>();
for (int i = 0; i < markers.Count; i++) {
Marker mark = markers[i];
props.Clear();
Marker.decodeText(mark.RawTitle, ref txt, ref props);
if (props.Count == 0) continue;
foreach (KeyValuePair<string, object> kv in props) {
if (kv.Key[0] != 't') continue;
keys.Add(string.Format("{0}_{1}", kv.Key, i));
values.Add((string)kv.Value);
}
}
return onProcessString(keys, values);
//return createResx(fileName, keys, values);
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
List<ProgressPerMessageChange> InterProgressPerMessageChanges = new List<ProgressPerMessageChange>();
if (ProgressTotal.Verify(stream))
{
this.ProgressTotal = new ProgressTotal(stream);
}
while (ProgressPerMessageChange.Verify(stream))
{
InterProgressPerMessageChanges.Add(new ProgressPerMessageChange(stream));
}
this.ProgressPerMessageChanges = InterProgressPerMessageChanges.ToArray();
if (Deletions.Verify(stream))
{
this.Deletions = new Deletions(stream);
}
if (ReadStateChanges.Verify(stream))
{
this.ReadStateChanges = new ReadStateChanges(stream);
}
this.State = new State(stream);
if (stream.ReadMarker() == Markers.IncrSyncEnd)
{
this.EndMarker = Markers.IncrSyncEnd;
}
else
{
throw new Exception("The ContentsSync cannot be parsed successfully. The IncrSyncEnd Marker is missed.");
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
List<FolderChange> InterFolderChanges = new List<FolderChange>();
while (FolderChange.Verify(stream))
{
InterFolderChanges.Add(new FolderChange(stream));
}
this.FolderChanges = InterFolderChanges.ToArray();
if (Deletions.Verify(stream))
{
this.Deletions = new Deletions(stream);
}
this.State = new State(stream);
if (stream.ReadMarker() == Markers.IncrSyncEnd)
{
this.EndMarker = Markers.IncrSyncEnd;
}
else
{
throw new Exception("The HierarchySync cannot be parsed successfully. The IncrSyncEnd Marker is missed.");
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.IncrSyncDel)
{
this.StartMarker = Markers.IncrSyncDel;
this.PropList = new PropList(stream);
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
Markers marker = stream.ReadMarker();
if (marker == Markers.StartMessage || marker == Markers.StartFAIMsg)
{
if (marker == Markers.StartMessage)
{ this.StartMarker1 = Markers.StartMessage; }
else
{ this.StartMarker2 = Markers.StartFAIMsg; }
this.Content = new MessageContent(stream);
if (stream.ReadMarker() == Markers.EndMessage)
{
this.EndMarker = Markers.EndMessage;
}
else
{
throw new Exception("The Message cannot be parsed successfully. The EndMessage Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.StartSubFld)
{
this.StartMarker = Markers.StartSubFld;
this.folderContentNoDelProps = new FolderContentNoDelProps(stream);
if (stream.ReadMarker() == Markers.EndFolder)
{
this.EndMarker = Markers.EndFolder;
}
else
{
throw new Exception("The SubFolderNoDelProps cannot be parsed successfully. The EndFolder Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.IncrSyncChg)
{
this.StartMarker = Markers.IncrSyncChg;
this.messageChangeHeader = new PropList(stream);
if (stream.ReadMarker() == Markers.IncrSyncMessage)
{
this.SecondMarker = Markers.IncrSyncMessage;
this.propList = new PropList(stream);
this.messageChildren = new MessageChildren(stream);
}
else
{
throw new Exception("The MessageChangeFull cannot be parsed successfully. The IncrSyncMessage Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
if (stream.ReadMarker() == Markers.StartEmbed)
{
this.StartMarker = Markers.NewAttach;
this.MessageContent = new MessageContent(stream);
if (stream.ReadMarker() == Markers.EndEmbed)
{
this.EndMarker = Markers.EndEmbed;
}
else
{
throw new Exception("The EmbeddedMessage cannot be parsed successfully. The EndEmbed Marker is missed.");
}
}
}
/// <summary>
/// Parse fields from a FastTransferStream.
/// </summary>
/// <param name="stream">A FastTransferStream.</param>
public override void Parse(FastTransferStream stream)
{
List<SyncMessagePartialPropList> InterMessagePartialList = new List<SyncMessagePartialPropList>();
this.groupInfo = new GroupInfo(stream);
if (stream.VerifyMetaProperty(MetaProperties.MetaTagIncrSyncGroupId))
{
this.MetaTagIncrSyncGroupId = new MetaPropValue(stream);
}
if (stream.ReadMarker() == Markers.IncrSyncChgPartial)
{
this.Marker = Markers.IncrSyncChgPartial;
this.messageChangeHeader = new PropList(stream);
while (stream.VerifyMetaProperty(MetaProperties.MetaTagIncrementalSyncMessagePartial))
{
InterMessagePartialList.Add(new SyncMessagePartialPropList(stream));
}
this.SyncMessagePartialPropList = InterMessagePartialList.ToArray();
this.MessageChildren = new MessageChildren(stream);
}
else
{
throw new Exception("The MessageChangePartial cannot be parsed successfully. The IncrSyncChgPartial Marker is missed.");
}
}
/// <summary>
/// Indicate the Markers at the position equals a specified Markers.
/// </summary>
/// <param name="marker">A Markers value</param>
/// <returns>True if the Markers at the position equals to the specified Markers, else false.</returns>
public bool VerifyMarker(Markers marker)
{
return this.Verify((uint)marker);
}
/// <summary>
/// Indicate whether a Markers is an end marker.
/// </summary>
/// <param name="marker">The Markers.</param>
/// <returns>If a Markers is an end marker, return true, else false.</returns>
public static bool IsEndMarker(Markers marker)
{
List<Markers> markers = GetEnumValues<Markers>();
return markers.Contains(marker);
}
/// <summary>
/// Indicate the Markers at the current position plus an offsetequals a specified Markers
/// </summary>
/// <param name="marker">A Markers to be verified</param>
/// <param name="offset">An int value</param>
/// <returns>True if the Markers at the current position plus an offset equals a specified Markers, else false.</returns>
public bool VerifyMarker(Markers marker, int offset)
{
return this.Verify((uint)marker, offset);
}
public void TestPlayerOnePlaysTopRightCorner()
{
game.Play(0);
Markers[] expected = new Markers[9] { Markers.X, Markers._, Markers._, Markers._, Markers._, Markers._, Markers._, Markers._, Markers._ };
Markers[] actual = game.Board;
CollectionAssert.AreEqual(expected, actual);
}
