How to create a minimal console in a Swift app (UILabel, UITextView, scrolling, truncating head?) - swift

Question

I want to create a console in my App in order to display activities or information on the screen. It will begin with a simple string, "Awaiting new messages..." and when different things happen, new messages will be added to that string. When the console fills up, the field will scroll with each addition so that the user is always seeing the most recent message at the bottom of the console, and old messages disappear off the view at the top.
Is there a way with "Truncate Head" and a multi-line UILabel? I attempted to do this with UILabel first, but I could find no way to always be viewing the END of the string. Truncate head actually works line-by-line, so it would show me the first five lines of the string and then the tail of the last visible line. I tried various alignment and wrapping settings but nothing worked... am I missing something? Is there a way to have a UILabel always display the end of a string and let the contents just disappear off the top?
Cut the string to fit each time? Maybe I could just cut the string to the last thousand characters or similar? But I don't know how big the UILabel will be (on different screens)... and even if I did, with fonts being what they are, I doubt I could know exactly the number of characters I should trim the string to. I can't trim it to a given amount of SPACE and get the amount of space in my UILabel, can I?
OR, I could use a UITextView and Scroll Maybe this is what I have to do. I can grab the entire value of the my text view's text and add the new string to it and put it back into the UITextView, and then scroll to the bottom using NSMakeRange and .scrollRangeToBottom.
func updateConsole(switchType: String) {
//unwind the console's text
if let tempString = consoleZe.text {
currentText = tempString
}
consoleZe.text = currentText + "A new message here! Something clever taken from \(switchType).\n"
//Scroll to the bottom
let bottom = NSMakeRange(consoleZe.text.characters.count - 1, 1)
consoleZe.scrollRangeToVisible(bottom)
}
That seems like a lot of work for my little update console. I don't care about scrolling to see past values. I'd even prefer the console didn't scroll... So grabbing, adding, pasting, getting the bottom and then scrolling seems like a lot of extra, unwanted baggage.
All thoughts on implementing a minimal console, using UILabel or UITextView or any other way are welcome, thank you!

Answer 1

I have implemented a “Console View Controller” using a tableview and a “ConsoleBuffer” class as the datasource. A tableview corresponds well to the line-by-line oriented nature of a message-logging console—and makes auto-scrolling easy.
The ConsoleBuffer is a singleton class which holds the console messages in a simple array of strings and some helper functions attached. Please see below the complete ConsoleBufferimplementation:
class ConsoleBuffer {
struct Prefs {
static let defaultLines = 100
static let maxLines = 1000
}
static let shared = ConsoleBuffer()
private var buffer = [String]() {
didSet {
if buffer.count > lines {
buffer.removeFirst(buffer.count - lines)
}
tableView?.reloadData()
NSAnimationContext.runAnimationGroup({ (context) in
if let tableView = self.tableView {
if let scrollView = tableView.enclosingScrollView {
let range = tableView.rows(in: scrollView.contentView.visibleRect)
let lastRow = range.location + range.length
if lastRow == oldValue.count - 1 {
context.allowsImplicitAnimation = true
tableView.scrollRowToVisible(buffer.count - 1)
}
}
}
}, completionHandler: nil)
}
}
var lines = ConsoleBuffer.Prefs.defaultLines {
didSet {
if lines > ConsoleBuffer.Prefs.maxLines {
lines = ConsoleBuffer.Prefs.maxLines
}
}
}
var count: Int {
get {
return buffer.count
}
}
var tableView: NSTableView?
private init() { }
func line(_ n: Int) -> String {
if n >= 0 && n < buffer.count {
return buffer[n]
} else {
return ""
}
}
func add(_ line: String) {
let dateStampedLine = "\(Date()) \(line)"
buffer.append(dateStampedLine)
}
func clear() {
buffer.removeAll()
}
}
These two statements make ConsoleBuffer a singleton:
static let shared = ConsoleBuffer()
private init() { }
Having a singleton makes it easy adding new console lines anywhere in your project without the need of having a reference to an instance of the class. Making init private prevents anyone from calling ConsoleBuffer()—rather you are forced to use its singleton instance: ConsoleBuffer.shared.
The console line strings are held in the buffer array which is private to keep its implementation hidden. When adding new lines to this array, the tableview smoothly scrolls to the last line added but only if previously the last line was displayed. Otherwise the scrolling position remains unchanged.
The datasource is now easy to implement:
func numberOfRows(in tableView: NSTableView) -> Int {
return ConsoleBuffer.shared.count
}
func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
let cell = tableView.make(withIdentifier: "ConsoleCell", owner: self) as? NSTableCellView
cell?.textField?.stringValue = ConsoleBuffer.shared.line(row)
return cell
}
In the tableview controller’s viewDidLoad function you need to set the tableView property of ConsoleBuffer to the tableview used. Also, this is the place to set the desired maximum number of lines to store in the buffer array:
ConsoleBuffer.shared.tableView = tableView
ConsoleBuffer.shared.lines = 500
Now you can add new lines to the console like this:
ConsoleBuffer.shared.add("console message")
Hope this gets you going into the right direction.