// Remove empty runs adjacent to non-empty text ones. private void RemoveUnwantedRuns(List <MapRun> runs) { for (int irun = 0; irun < runs.Count;) { MapRun run = runs[irun]; if (run.LogLength > 0 || run.RenderLength > 0) { irun++; continue; // target run is not empty (or displaying a substitute), don't consider removing it. } if (irun + 1 < runs.Count) { MapRun runNext = runs[irun + 1]; if (runNext.ClientRun is TextClientRun && runNext.LogLength > 0) { // following text run is non-empty, remove this empty run. runs.RemoveAt(irun); continue; } } if (irun > 0 && runs[irun - 1].ClientRun is TextClientRun) { // there is a preceding text run, remove this run, even if preceding one is empty; don't want two adjacent empties. runs.RemoveAt(irun); continue; } irun++; } }
internal FwUnderlineType GetUnderlineInfo(int ich, out int underColor, out int ichLim) { int runIndex = RunContaining(ich); MapRun run = Runs[runIndex]; ichLim = run.RenderStart + run.RenderLength; underColor = (int)run.Chrp.clrUnder; return((FwUnderlineType)run.Chrp.unt); }
public void GetCharProps(int ich, out LgCharRenderProps chrp, out int ichMin, out int ichLim) { int runIndex = RunContaining(ich); MapRun run = Runs[runIndex]; ichMin = run.RenderStart; ichLim = ichMin + run.RenderLength; chrp = run.Chrp; }
// Determine the run of the character with the specified render index. internal int RunContaining(int ichRen) { Debug.Assert(ichRen >= 0); MapRun key = new MapRun(0, null, ichRen, 0, 0); int index = Array.BinarySearch(Runs, key, RenderStartComparer); if (index < 0) // exact match { index = ~index; // now the index of the first run with RenderStart > ichRen index--; // so this one contains the character } return(index); }
public int LogToRen(int ichLog) { Debug.Assert(ichLog >= 0); MapRun key = new MapRun(ichLog, null, 0, 0, 0); int index = Array.BinarySearch(Runs, key, LogStartComparer); if (index < 0) { index = ~index; // index is now the index of the first element with LogStart > ichLog (or Runs.Length, if it is greater than any LogStart in the array). index--; // if it doesn't match exactly we want the previous run (which contains this index) } MapRun run = Runs[index]; return(run.RenderStart + (ichLog - run.LogStart)); }
static void BeginMap(MapRun mapRun) { Console.Clear(); GetMapInfo(); Console.Write("\nClick on a specific button: "); var keyMap = Console.ReadKey(); Console.WriteLine(); switch (keyMap.Key) { case ConsoleKey.B: { Console.Clear(); mapRun.BasicDictionary(); PressAnyKey(); } break; case ConsoleKey.E: { Console.Clear(); mapRun.EasyMap(); PressAnyKey(); } break; case ConsoleKey.D: { Console.Clear(); mapRun.ImplementedDictionary(); PressAnyKey(); } break; case ConsoleKey.X: { } break; } }
public string GetRenderText(int ichMin, int length) { if (Runs.Length == 0) { if (ichMin != 0) { throw new ArgumentException("ichMin is beyond the length of the (empty) paragraph."); } if (length != 0) { throw new ArgumentException("asked for characters from an empty paragraph"); } return(""); } int ichLim = ichMin + length; int firstRunIndex = RunContaining(ichMin); int lastRunIndex = RunContaining(ichLim); MapRun firstRun = Runs[firstRunIndex]; MapRun lastRun = Runs[lastRunIndex]; int ichMinRun = ichMin - firstRun.RenderStart; int ichLimRun = ichLim - lastRun.RenderStart; string text; if (firstRunIndex == lastRunIndex) { text = GetRunText(firstRun, ichMinRun, ichLimRun); } else { StringBuilder builder = new StringBuilder(GetRunText(firstRun, ichMinRun, firstRun.RenderLength)); for (int i = firstRunIndex + 1; i < lastRunIndex; i++) { MapRun run = Runs[i]; builder.Append(run.RenderText); } builder.Append(GetRunText(lastRun, 0, ichLimRun)); text = builder.ToString(); } return(text); }
public int RenToLog(int ichRen) { Debug.Assert(ichRen >= 0); MapRun key = new MapRun(0, null, ichRen, 0, 0); int index = Array.BinarySearch(Runs, key, RenderStartComparer); if (index >= 0) // exact match { return(Runs[index].LogStart); } index = ~index; // index is now the index of the first element with RenderStart > ichRen (or Runs.Length, if it is greater than any RenderStart in the array). MapRun run = Runs[index - 1]; // run containing the indicated position. // If this is an ORC run, we want its start index (all the render characters for the run correspond to that one ORC) if (run is OrcMapRun) { return(run.LogStart); } // In ordinary runs, the logical and rendered characters correspond one for one. return(run.LogStart + (ichRen - run.RenderStart)); }
/// <summary> /// Get the text from the specified run. indexes are offsets into the run, in render characters. /// </summary> /// <param name="run"></param> /// <param name="ichMin"></param> /// <param name="ichLim"></param> /// <returns></returns> string GetRunText(MapRun run, int ichMin, int ichLim) { return(run.RenderText.Substring(ichMin, ichLim - ichMin)); }
static void Main(string[] args) { Console.Title = "Guids and implementation examples for most popular types of Data Structures v1.0"; var stackRun = new StackRun(); var queueRun = new QueueRun(); var setRun = new SetRun(); var hashTableRun = new HashTableRun(); var mapRun = new MapRun(); var listRun = new ListRun(); var treeRun = new TreeRun(); var heapRun = new HeapRun(); var binarySearchTreeRun = new BinarySearchTreeRun(); var graphRun = new GraphRun(); while (true) { Console.Clear(); GetBasicInfo(); Console.Write("\nClick on a specific button: "); var key = Console.ReadKey(); Console.WriteLine(); switch (key.Key) { case ConsoleKey.S: { BeginStack(stackRun); } break; case ConsoleKey.Q: { BeginQueue(queueRun); } break; case ConsoleKey.E: { BeginSet(setRun); } break; case ConsoleKey.B: { BeginHashTable(hashTableRun); } break; case ConsoleKey.M: { BeginMap(mapRun); } break; case ConsoleKey.L: { BeginList(listRun); } break; case ConsoleKey.T: { BeginTree(treeRun); } break; case ConsoleKey.H: { BeginHeap(heapRun); } break; case ConsoleKey.N: { BeginBinarySearchTree(binarySearchTreeRun); } break; case ConsoleKey.G: { BeginGraph(graphRun); } break; case ConsoleKey.X: { Environment.Exit(0); } break; } } }
void VerifyRun(int logical, IClientRun clientRun, int render, int offset, int irun, string runText, MapRun run, string label) { Assert.AreEqual(logical, run.LogStart, label + " - logical"); Assert.AreEqual(clientRun, run.ClientRun, label + " - cllient run"); Assert.AreEqual(render, run.RenderStart, label + " - render"); Assert.AreEqual(offset, run.Offset, label + " - offset"); Assert.AreEqual(irun, run.ClientUniformRunIndex, label + "- ClientUniformRunIndex"); Assert.AreEqual(runText, run.RenderText, label + " - RenderText"); }
void VerifyRun(int logical, IClientRun clientRun, int render, int offset, string runText, MapRun run, string label) { VerifyRun(logical, clientRun, render, offset, 0, runText, run, label); }