public static void Log(string logMessage, Action<string> echo = null, IMyProgrammableBlock me = null, string label = null, IMyTextPanel mirrorLcd = null, bool truncateForLcd = true) { String output = ""; if(echo == null) { output = "\n"; output += logMessage; throw new Exception(output); } if(LogBuffer == null) { LogBuffer = new StringBuilder(); } if(label != null) { logMessage = label+": "+logMessage; } if(mirrorLcd != null) { string currentlyMirrored = mirrorLcd.GetPublicText(); if(truncateForLcd && LogBuffer.Length + logMessage.Length > LOG_MAX_LCD_LENGTH_CHARS) { StringBuilder lcdBuffer = new StringBuilder(LogBuffer.ToString()); int charAmountToOffset = fullLineCharsExceeding(lcdBuffer, logMessage.Length, LogBuffer.Length - (LOG_MAX_LCD_LENGTH_CHARS - logMessage.Length)); lcdBuffer.Remove(0, LogBuffer.Length - LOG_MAX_LCD_LENGTH_CHARS + charAmountToOffset - 2); lcdBuffer.AppendLine(); lcdBuffer.Append(logMessage); mirrorLcd.WritePublicText(lcdBuffer.ToString(), false); } else { string potentialNewLine = (currentlyMirrored.Length > 0)? "\n" : ""; mirrorLcd.WritePublicText(potentialNewLine+logMessage, true); } } if(LogBuffer.Length + logMessage.Length * 2 > LOG_MAX_ECHO_LENGTH_CHARS) { int charAmountToRemove = fullLineCharsExceeding(LogBuffer, logMessage.Length); LogBuffer.Remove(0, charAmountToRemove); LogBuffer.Append(output); } if(LogBuffer.Length > 0) { LogBuffer.AppendLine(); } LogBuffer.Append(logMessage); echo(LogBuffer.ToString()); }
public void Main(string containerName) { IMyCargoContainer cargo = FindBlock <IMyCargoContainer>(containerName); IMyTextPanel debug = FindBlock <IMyTextPanel>("debug"); if (cargo == null || debug == null) { debug.WritePublicText("Cargo or debug not found!", false); return; } IMyInventory cargoInventory = cargo.GetInventory(0); var assemblers = new List <IMyTerminalBlock>(); GridTerminalSystem.GetBlocksOfType <IMyAssembler>(assemblers); for (int i = 0; i < assemblers.Count; i++) { if (!assemblers[i].HasInventory) { continue; } IMyInventory inventory = assemblers[i].GetInventory(1); List <IMyInventoryItem> items = inventory.GetItems(); debug.WritePublicText("Items Moved:" + items.Count + "\n", true); // Move items to cargo for (int j = 0; j < items.Count; j++) { inventory.TransferItemTo(cargoInventory, 0, null, stackIfPossible: true); } } }
private void AddEntriesToPanel(IMyTextPanel Panel) { if (Autoscroll) { List <string> buffer = new List <string>(Panel.GetPublicText().Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)); buffer.AddRange(Queue); int maxLines = Math.Min(getMaxLinesFromPanel(Panel), buffer.Count); if (Prepend) { buffer.Reverse(); } Panel.WritePublicText(string.Join("\n", buffer.GetRange(buffer.Count - maxLines, maxLines).ToArray()), false); } else { if (Prepend) { var buffer = new List <string>(Panel.GetPublicText().Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)); buffer.AddRange(Queue); buffer.Reverse(); Panel.WritePublicText(string.Join("\n", buffer.ToArray()), false); } else { Panel.WritePublicText(string.Join("\n", Queue.ToArray()), true); } } }
/// <summary> /// Using single LCD mode /// </summary> private void Single_Docking() { if (G_LCD != null) { G_LCD.WritePublicText($"<---Ship Status--->\nLocked: {Get_Amount_Connected ()}/{connectors.Count}\n", true); } }
} // программ public void Main(string argument) { if (argument == "stop") { return; } else { Runtime.UpdateFrequency = UpdateFrequency.Update100; } // разпознавание присутствия хозяина в кокпите if (memcocpit != cocpit.IsUnderControl) { memcocpit = cocpit.IsUnderControl; if (memcocpit) { DBG.WritePublicText("Вошол\n", true); } else { DBG.WritePublicText("Вышел\n", true); } } }
private void printDetectedObjects() { var det = new List <MyDetectedEntityInfo>(); foreach (IMySensorBlock sensor in sensors) { det.Clear(); sensor.DetectedEntities(det); if (lcd != null) { lcd.WritePublicText("Detected " + det.Count + " entities.\n", false); } foreach (var d in det) { if (lcd != null) { lcd.WritePublicText("ID: " + d.EntityId + "\n", true); lcd.WritePublicText("Name: " + d.Name + "\n", true); lcd.WritePublicText("Type: " + d.Type + "\n", true); lcd.WritePublicText("Time(ms): " + d.TimeStamp + "\n", true); lcd.WritePublicText("Orientation: " + d.Orientation + "\n", true); lcd.WritePublicText("BB: " + d.BoundingBox + "\n", true); lcd.WritePublicText("Vel: " + d.Velocity + "\n", true); lcd.WritePublicText("Pos: " + convertToGPS("Player", d.Position) + "\n", true); lcd.WritePublicText("Relation: " + d.Relationship + "\n", true); } } } }
// ***MARKER: State Machine Program // NOTE: If you don't need a precreated, reusable state machine, // replace the declaration with the following: // public IEnumerator<bool> RunStuffOverTime() { public IEnumerable <bool> RunStuffOverTime() { // For the very first instruction set, we will just switch on the light. _panelLight.RequestEnable(true); // Then we will tell the script to stop execution here and let the game do it's // thing. The time until the code continues on the next line after this yield return // depends on your State Machine Execution and the timer setup. // I have chosen the simplest form of state machine here. A return value of // true will tell the script to execute the next step the next time the timer is // invoked. A return value of false will tell the script to halt execution and not // continue. This is actually not really necessary, you could have used the // statement // yield break; // to do the same. However I wanted to demonstrate how you can use the return // value of the enumerable to control execution. yield return(true); int i = 0; // The following would seemingly be an illegal operation, because the script would // keep running until the instruction count overflows. However, using yield return, // you can get around this limitation. while (true) { _textPanel.WritePublicText(i.ToString()); i++; // Like before, when this statement is executed, control is returned to the game. // This way you can have a continuously polling script with complete state // management, with very little effort. yield return(true); } }
public Program() { DBG = GridTerminalSystem.GetBlockWithName("DBG") as IMyTextPanel; DBG.ShowPublicTextOnScreen(); DBG.WritePublicText("Отладочная консоль\n", false); List <IMyTerminalBlock> blocks = new List <IMyTerminalBlock>(); GridTerminalSystem.GetBlocksOfType <IMyLightingBlock>(blocks); initLight(blocks); // настройка всех ламп и прожекторов // создать группу //IMyBlockGroup group = GridTerminalSystem.GetBlockGroupWithName( "Группа"); // печать имён всех групп корабля List <IMyBlockGroup> groups = new List <IMyBlockGroup>(); GridTerminalSystem.GetBlockGroups(groups); foreach (IMyBlockGroup tut in groups) { DBG.WritePublicText(tut.Name.ToString() + "\n", true); } Echo("Вывод в терминал программного блока"); // разпознавание присутствия хозяина в кокпите cocpit = GridTerminalSystem.GetBlockWithName("Кабина") as IMyCockpit; } // программ
void StatusLog(string text, IMyTextPanel block, bool bReverse = false) { if (block == null) { return; } if (text.Equals("clear")) { block.WritePublicText(""); } else { if (bReverse) { string oldtext = block.GetPublicText(); block.WritePublicText(text + "\n" + oldtext); } else { block.WritePublicText(text + "\n", true); } // block.WritePublicTitle(DateTime.Now.ToString()); } block.ShowTextureOnScreen(); block.ShowPublicTextOnScreen(); }
private void Log(string text) { return; string line = text; //Logger.Log(text); MyAPIGateway.Utilities.ShowMessage("TR-Log", line); if (LcdPanel == null) { return; } List <string> output = new List <string>(); output.AddArray(LcdPanel.GetPublicText().Split('\n')); if (output.Count > 17) { while (output.Count > 16) { output.RemoveAt(0); } LcdPanel.WritePublicText(string.Join("\n", output.ToArray())); } LcdPanel.WritePublicText(line + "\n", true); }
void Main(string argument) { if (s == null) s = GridTerminalSystem.GetBlockWithName("Data - Power") as IMyTextPanel; if (solars.Count == 0) GridTerminalSystem.GetBlocksOfType<IMySolarPanel>(solars); Echo("Checking Grids"); Echo("Found " + solars.Count + " pannels attached"); /*solars = solars.FindAll(delegate (IMySolarPanel c) { if(c.CubeGrid.ToString() == s.CubeGrid.ToString()) return true; return false; });*/ int count = solars.Count; Echo("Filtered to " + count + " panels"); if (argument == "reset" || count != lastCount) { peakPower = 0; totalPower = 0; minPower = -1; cycles = 0; } lastCount = count; float total = 0; cycles++; Echo("Cycle #" + cycles + " Started"); int panel_count = 0; Echo("Going to check " + count + " panels"); for (int i = 0; i < count; i++) { total += solars[i].MaxOutput; panel_count++; } if (peakPower < total) peakPower = total; if (minPower == -1 || minPower > total) minPower = total; totalPower += total; string f_peakPower = "None"; if (peakPower > 0) f_peakPower = FormatNumber(peakPower * Math.Pow(1000, 2)) + "W"; string f_minPower = "None"; if (minPower > 0) f_minPower = FormatNumber(minPower * Math.Pow(1000, 2)) + "W"; string f_averagePower = "None"; if (totalPower > 0) f_averagePower = FormatNumber(totalPower / cycles * Math.Pow(1000, 2)) + "W"; s.WritePublicText("Peak Power:\n" + f_peakPower + "\n"); s.WritePublicText("Min Power:\n" + f_minPower + "\n", true); s.WritePublicText("Average Power:\n" + f_averagePower + "\n", true); s.WritePublicText("For " + panel_count + " Panels" + "\n", true); Echo("Peak Power: " + f_peakPower); Echo("Min Power: " + f_minPower); Echo("Average Power: " + f_averagePower); Echo("For " + panel_count + " Panels"); Echo("Cycle #" + cycles + " Completed"); }
public void BindLCD(IMyTextPanel txtpnl) { if (Panel != null) { Panel.WritePublicText("MENU UNBOUND"); } Panel = txtpnl; UpdateLCD(); }
public void WriteDebug(string message, params object[] args) { if (debugScreen == null) { return; } debugScreen.WritePublicText(String.Format(message, args), true); debugScreen.WritePublicText("\n", true); }
//------------------------------------------------------------------------ public void Main(string argument, UpdateType updateSource) { if (GetShipSystems()) { //------------------------------------------------------------------ // Environment //------------------------------------------------------------------ m_textPanel.WritePublicText(""); m_listError.Clear(); m_argument = argument; m_updateSource = updateSource; m_dateTimeNow = DateTime.Now; m_currentPosition = Me.CubeGrid.GridIntegerToWorld(Me.Position); //------------------------------------------------------------------ DrawText("//--------------------------------------------"); DrawText("// ASSEMBLER2000 BY VX TEK AUTOMATING SYSTEMS "); DrawText("//--------------------------------------------"); DrawText(""); DrawText("Date " + m_dateTimeNow.ToShortDateString() + " " + m_dateTimeNow.ToLongTimeString()); DrawText("Current position : " + m_currentPosition.X + ":" + m_currentPosition.Y + ":" + m_currentPosition.Z); DrawText("Last position : " + m_lastPosition.X + ":" + m_lastPosition.Y + ":" + m_lastPosition.Z); DrawText("Current ship speed: " + Vector3D.Distance(m_lastPosition, m_currentPosition)); //------------------------------------------------------------------ // State machine //------------------------------------------------------------------ switch (m_internalState) { case EInternalState.Idle: { StateIdle(); } break; case EInternalState.Assembling: { StateAssembling(); } break; case EInternalState.Error: { StateAssembling(); } break; } } else { m_internalState = EInternalState.Error; } }
public static void Log(string logMessage, Action <string> echo = null, IMyProgrammableBlock me = null, string label = null, IMyTextPanel mirrorLcd = null, bool truncateForLcd = true) { String output = ""; if (echo == null) { output = "\n"; output += logMessage; throw new Exception(output); } if (LogBuffer == null) { LogBuffer = new StringBuilder(); } if (label != null) { logMessage = label + ": " + logMessage; } if (mirrorLcd != null) { string currentlyMirrored = mirrorLcd.GetPublicText(); if (truncateForLcd && LogBuffer.Length + logMessage.Length > LOG_MAX_LCD_LENGTH_CHARS) { StringBuilder lcdBuffer = new StringBuilder(LogBuffer.ToString()); int charAmountToOffset = fullLineCharsExceeding(lcdBuffer, logMessage.Length, LogBuffer.Length - (LOG_MAX_LCD_LENGTH_CHARS - logMessage.Length)); lcdBuffer.Remove(0, LogBuffer.Length - LOG_MAX_LCD_LENGTH_CHARS + charAmountToOffset - 2); lcdBuffer.AppendLine(); lcdBuffer.Append(logMessage); mirrorLcd.WritePublicText(lcdBuffer.ToString(), false); } else { string potentialNewLine = (currentlyMirrored.Length > 0)? "\n" : ""; mirrorLcd.WritePublicText(potentialNewLine + logMessage, true); } } if (LogBuffer.Length + logMessage.Length * 2 > LOG_MAX_ECHO_LENGTH_CHARS) { int charAmountToRemove = fullLineCharsExceeding(LogBuffer, logMessage.Length); LogBuffer.Remove(0, charAmountToRemove); LogBuffer.Append(output); } if (LogBuffer.Length > 0) { LogBuffer.AppendLine(); } LogBuffer.Append(logMessage); echo(LogBuffer.ToString()); }
public void c_log(string message) { if (logPanel == null) { return; } if (message == null) { logPanel.WritePublicText(""); } else { logPanel.WritePublicText(message + "\n", true); } logPanel.ShowPublicTextOnScreen(); }
// TODO: display n to m lines. public void UpdatePublic(bool show = true) { try { if (FontSize != _panel.GetValueFloat("FontSize")) { _panel.SetValueFloat("FontSize", FontSize); } } catch (Exception ex) { // The game may generate an exception from the GetValueFloat(GetValue) call. // We can safely ignore this if it doesn't work, but it may indicate a game issue. EconomyScript.Instance.ServerLogger.WriteException(ex, UpdateCrashMessage); EconomyScript.Instance.ClientLogger.WriteException(ex, UpdateCrashMessage); } LastUpdate = DateTime.Now; // no need to update if the text has not changed. if (_panel.GetPublicText() != _publicString.ToString()) { _panel.WritePublicText(_publicString.ToString()); if (show) { if (ForceRedraw) { _panel.ShowTextureOnScreen(); } _panel.ShowPublicTextOnScreen(); } } }
public void Main(string argument) { // The main entry point of the script, invoked every time // one of the programmable block's Run actions are invoked. // // The method itself is required, but the argument above // can be removed if not needed. BMyLog4PB Log = new BMyLog4PB(this, BMyLog4PB.E_ALL, new BMyLog4PB.BMyTextPanelAppender("DrawLog", this)); Log.AutoFlush = true; IMyTextPanel panel = GridTerminalSystem.GetBlockWithName("DrawPanel") as IMyTextPanel; if (panel == null) { throw new Exception("Panel \"DrawPanel\" not found"); } string[] code = panel?.CustomData.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries); Log?.PushStack("BaconDraw"); string image = (new BaconDraw()).run(code, Log).ToString(); Log.PopStack(); panel?.WritePublicText(image); panel?.ShowPublicTextOnScreen(); }
private void debug(string line, int logLevel = LOG_LVL_DEBUG) { if (usedLogLevel != LOG_LVL_SILENT) { if (usedLogLevel >= logLevel) { string prefix = ""; if (usedLogLevel >= LOG_LVL_DEBUG) { prefix = "[Tick#" + this.ElapsedTime.Ticks.ToString() + "]"; } line = prefix + line; Echo(line.Trim()); List <IMyTerminalBlock> LCDs = new List <IMyTerminalBlock>(); GridTerminalSystem.GetBlocksOfType <IMyTextPanel>(LCDs, (x => x.CustomName.Contains(TAG_LOG_DEBUG_LCD) && x.CubeGrid.Equals(Me.CubeGrid))); for (int i = 0; i < LCDs.Count; i++) { IMyTextPanel LCD = LCDs[i] as IMyTextPanel; StringBuilder sb = new StringBuilder(); sb.AppendLine(line); sb.Append(LCD.GetPublicText()); LCD.WritePublicText(sb.ToString()); } } } }
public void Main(string argument, UpdateType updateSource) { str = ""; if (Me.CustomData == "0") { foreach (var th in thrusters) { IMyThrust thr = th as IMyThrust; th.ApplyAction("OnOff_On"); thr.ThrustOverridePercentage = 0; } foreach (var item in Gyros) { item.GyroOverride = false; } } else { foreach (var th in thrusters) { IMyThrust thr = th as IMyThrust; thrusterControllr(thr); } gyroControll(); } text.WritePublicText(str); Echo(Me.CustomData); }
// ***MARKER: Coroutine Example // The return value (bool in this case) is not important for this example. It is not // actually in use. public IEnumerator <bool> RunStuffOverTime() { // For the very first instruction set, we will just switch on the light. _panelLight.Enabled = true; // Then we will tell the script to stop execution here and let the game do it's // thing. The time until the code continues on the next line after this yield return // depends on your State Machine Execution and the timer setup. // The `true` portion is there simply because an enumerator needs to return a value // per item, in our case the value simply has no meaning at all. You _could_ utilize // it for a more advanced scheduler if you want, but that is beyond the scope of this // tutorial. yield return(true); int i = 0; // The following would seemingly be an illegal operation, because the script would // keep running until the instruction count overflows. However, using yield return, // you can get around this limitation - without breaking the rules and while remaining // performance friendly. while (i < 100) { i++; _textPanel.WritePublicText(argument + " " + i.ToString()); // Like before, when this statement is executed, control is returned to the game. // This way you can have a continuously polling script with complete state // management, with very little effort. yield return(true); } }
public void update() { if (ready) { screen.WritePublicText(new String(data), false); } }
public void Main(string argument) { List <IMyTextPanel> TTYs = new List <IMyTextPanel>(); GridTerminalSystem.GetBlocksOfType <IMyTextPanel>(TTYs, (IMyTextPanel x) => x.CustomName.Contains("TTY") && x.CubeGrid.Equals(Me.CubeGrid)); BaconShell.Environment env = new BaconShell.Environment(this, GridTerminalSystem, new BaconDebug("debug", GridTerminalSystem, this, 99)); BaconShell bs = new BaconShell(env); for (int i_TTY = 0; i_TTY < TTYs.Count; i_TTY++) { IMyTextPanel TTY = TTYs[i_TTY]; string stdin = TTY.GetPrivateText(); if (!stdin.Equals("")) { StringBuilder stdout = new StringBuilder(); string[] command = stdin.Split(new Char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < command.Length; i++) { BaconArgs Args = BaconArgs.parse(command[i]); stdout.Append(bs.runCommand(Args, env).ToString()); } TTY.WritePrivateText(""); TTY.WritePublicText(stdout.ToString()); } } }
} // AddLog method public void Update() { const string title = "Log File\n"; // Screen Title int i = 0; // loop counter string temp = ""; // temp string if (log == "") { return; // nothing to do } lcd = LCDList[0] as IMyTextPanel; // grab the first lcd temp = lcd.GetPublicText(); // grab the text if (temp.Contains(title)) { temp.Remove(temp.IndexOf(title, 0), title.Length); // remove the title } // if title temp = title + log + temp; // update the log string lcd.WritePublicText(temp); // write to first panel for (i = 1; i < LCDList.Count; i++) { lcd = LCDList[i] as IMyTextPanel; // grab the panel lcd.WritePublicText(temp); // write subsequent panel(s) } // lcd for log = ""; // reset log buffer } // Update method
void Main(string args) { Echo("Hellow World"); IMyTextPanel LCD = GridTerminalSystem.GetBlockWithName("LCDW") as IMyTextPanel; if (IfFirstRun) { LCDTotalString = LCD.GetPublicText(); LCDGIFStringArray = LCDTotalString.Split('*'); IndexMax = LCDGIFStringArray.Length; IfFirstRun = false; } LCD.WritePublicText(LCDGIFStringArray[Index]); Index++; if (Index >= IndexMax) { Index = 0; } Echo(Index.ToString()); Echo(IfFirstRun.ToString()); return; }
public void displayText() { IMyTextPanel block = (IMyTextPanel)this.myProgram.GridTerminalSystem.GetBlockWithName("LCD - Hangar 1 - Outer Airlock"); if (block == null) { throw new Exception("Can not find LCD block"); } this.screen = new List <string>(block.CustomData.Split('\n')); this.writeSquare(this.hangarAirlockIconGreen, 10, 100); this.writeSquare(this.hangarIconRed, 20, 40); this.writeSquare(this.hangarIconWhite, 50, 40); this.writeSquare(this.hangarIconGreen, 80, 40); this.writeSquare(this.hangarIconGreen, 110, 40); string str = ""; foreach (var txt in this.screen) { str += txt + "\n"; } block.WritePublicText(str); block.ShowPublicTextOnScreen(); }
public void LcdPrint(string msg, string lcdName = "VarPanel") { IMyTextPanel lcd = GridTerminalSystem.GetBlockWithName(lcdName) as IMyTextPanel; lcd.WritePublicText(lcd.GetPublicText() + msg); }
// // http://steamcommunity.com/sharedfiles/filedetails/?id=360966557 // https://forum.keenswh.com/threads/pb-scripting-guide-how-to-use-self-updating.7398267/ // //---------------------------------------------------------------------------------------------------------------------- // Kopioitava koodi //---------------------------------------------------------------------------------------------------------------------- void Main() { // ------------ Auto update --------------- Runtime.UpdateFrequency = UpdateFrequency.Update10; // ------------ Definitions --------------- IMyTextPanel naytto1 = GridTerminalSystem.GetBlockWithName("Infoscreen") as IMyTextPanel; IMyCargoContainer cargo1 = GridTerminalSystem.GetBlockWithName("Hitsi cargo 1") as IMyCargoContainer; // ------------ Logic --------------- // --- Cargo 1 usage --- float usedVolume1 = 0.0f; float maxVolume1 = 0.0f; usedVolume1 = (float)cargo1.GetInventory(0).CurrentVolume; maxVolume1 += (float)cargo1.GetInventory(0).MaxVolume; float pctUsed1 = 100.0f * usedVolume1 / maxVolume1; // ------------ Screen writing --------------- naytto1.WritePublicText("\n\n\n\n Cargo-1 käytössä: " + (int)pctUsed1 + "%", false); naytto1.ShowPublicTextOnScreen(); }
/// <summary> /// Builds detectedGrids from a text panel. /// </summary> /// <param name="textPanelName">text panel name to lookup</param> void createListDetected(string textPanelName) { // get panel IMyTextPanel panel = null; List <IMyTerminalBlock> textPanels = new List <IMyTerminalBlock>(); GridTerminalSystem.GetBlocksOfType <IMyTextPanel>(textPanels); for (int index = 0; index < textPanels.Count; index++) { if (textPanels[index].DisplayNameText == textPanelName) { panel = textPanels[index] as IMyTextPanel; break; } } // assume panel has been filled, otherwise something went horribly wrong // get data string[] splitByLine = panel.GetPublicText().Split(newLine, StringSplitOptions.RemoveEmptyEntries); // erase panel panel.WritePublicText(""); // build from data and invoke handler for (int lineIndex = 0; lineIndex < splitByLine.Length; lineIndex++) { if (!string.IsNullOrWhiteSpace(splitByLine[lineIndex])) { //string distanceString = splitByLine[lineIndex].Split(separator)[4]; //debug("distance = "+distanceString+" => "+); handle_detectedGrid(new Detected(splitByLine[lineIndex])); } } }
//------------------------------------------------------------------------ // DrawText //------------------------------------------------------------------------ private void DrawText(IMyTextPanel textPanel, String text, bool bNewLine = true) { Echo(text); if (textPanel != null) { if (bNewLine) { textPanel.WritePublicText(text + Environment.NewLine, true); } else { textPanel.WritePublicText(text, true); } } }
public static void Terminate() { // Generate title line String title_line, hb; if (heartbeat) { heartbeat = false; hb = "\\"; } else { heartbeat = true; hb = "/"; } if (is_sec_run) { title_line = String.Format("{0} #\n\n", term_title); } else { title_line = String.Format("{0} {1}\n\n", term_title, hb); } _term.WritePublicText(title_line + _stdout); _stdout = null; // Docking changes this object, so unset it to help garbage collection GridTerminalSystem = null; }