Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "h", "*", "hawkularSink", ")", "checkCache", "(", "key", "string", ",", "hash", "uint64", ")", "bool", "{", "h", ".", "regLock", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "regLock", ".", "Unlock", "(", ")", "\n", "_", ",", "found", ":=", "h", ".", "expReg", "[", "key", "]", "\n", "if", "!", "found", "||", "h", ".", "expReg", "[", "key", "]", ".", "hash", "!=", "hash", "{", "return", "false", "\n", "}", "\n", "// Update the TTL", "h", ".", "expReg", "[", "key", "]", ".", "ttl", "=", "h", ".", "runId", "\n", "return", "true", "\n", "}" ]

[ "checkCache", "returns", "false", "if", "the", "cached", "instance", "is", "not", "current", ".", "Updates", "the", "TTL", "in", "the", "cache" ]

[ "func", "(", "h", "*", "hawkularSink", ")", "expireCache", "(", "runId", "uint64", ")", "{", "h", ".", "regLock", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "regLock", ".", "Unlock", "(", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "h", ".", "expReg", "{", "if", "(", "v", ".", "ttl", "+", "h", ".", "cacheAge", ")", "<=", "runId", "{", "delete", "(", "h", ".", "expReg", ",", "k", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "expireCache", "will", "process", "the", "map", "and", "check", "for", "any", "item", "that", "has", "been", "expired", "and", "release", "it" ]

[ "func", "(", "h", "*", "hawkularSink", ")", "updateDefinitions", "(", "mds", "[", "]", "*", "metrics", ".", "MetricDefinition", ")", "error", "{", "for", "_", ",", "p", ":=", "range", "mds", "{", "if", "model", ",", "f", ":=", "h", ".", "models", "[", "p", ".", "Tags", "[", "descriptorTag", "]", "]", ";", "f", "&&", "!", "h", ".", "recent", "(", "p", ",", "model", ")", "{", "if", "err", ":=", "h", ".", "client", ".", "UpdateTags", "(", "p", ".", "Type", ",", "p", ".", "ID", ",", "p", ".", "Tags", ",", "h", ".", "modifiers", "...", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "h", ".", "cache", "(", "p", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Fetches", "definitions", "from", "the", "server", "and", "checks", "that", "they", "re", "matching", "the", "descriptors" ]

[ "func", "(", "h", "*", "hawkularSink", ")", "recent", "(", "live", "*", "metrics", ".", "MetricDefinition", ",", "model", "*", "metrics", ".", "MetricDefinition", ")", "bool", "{", "recent", ":=", "true", "\n", "for", "k", ":=", "range", "model", ".", "Tags", "{", "if", "v", ",", "found", ":=", "live", ".", "Tags", "[", "k", "]", ";", "!", "found", "{", "// There's a label that wasn't in our stored definition", "live", ".", "Tags", "[", "k", "]", "=", "v", "\n", "recent", "=", "false", "\n", "}", "\n", "}", "\n\n", "return", "recent", "\n", "}" ]

[ "Checks", "that", "stored", "definition", "is", "up", "to", "date", "with", "the", "model" ]

[ "func", "(", "h", "*", "hawkularSink", ")", "descriptorToDefinition", "(", "md", "*", "core", ".", "MetricDescriptor", ")", "metrics", ".", "MetricDefinition", "{", "tags", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "// Postfix description tags with _description", "for", "_", ",", "l", ":=", "range", "md", ".", "Labels", "{", "if", "len", "(", "l", ".", "Description", ")", ">", "0", "{", "tags", "[", "l", ".", "Key", "+", "descriptionTag", "]", "=", "l", ".", "Description", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "md", ".", "Units", ".", "String", "(", ")", ")", ">", "0", "{", "tags", "[", "unitsTag", "]", "=", "md", ".", "Units", ".", "String", "(", ")", "\n", "}", "\n\n", "tags", "[", "descriptorTag", "]", "=", "md", ".", "Name", "\n\n", "hmd", ":=", "metrics", ".", "MetricDefinition", "{", "ID", ":", "md", ".", "Name", ",", "Tags", ":", "tags", ",", "Type", ":", "heapsterTypeToHawkularType", "(", "md", ".", "Type", ")", ",", "}", "\n\n", "return", "hmd", "\n", "}" ]

[ "Transform", "the", "MetricDescriptor", "to", "a", "format", "used", "by", "Hawkular", "-", "Metrics" ]

[ "func", "(", "h", "*", "hawkularSink", ")", "pointToLabeledMetricHeader", "(", "ms", "*", "core", ".", "MetricSet", ",", "metric", "core", ".", "LabeledMetric", ",", "timestamp", "time", ".", "Time", ")", "(", "*", "metrics", ".", "MetricHeader", ",", "error", ")", "{", "name", ":=", "h", ".", "idName", "(", "ms", ",", "metric", ".", "Name", ")", "\n", "if", "resourceID", ",", "found", ":=", "metric", ".", "Labels", "[", "core", ".", "LabelResourceID", ".", "Key", "]", ";", "found", "{", "name", "=", "h", ".", "idName", "(", "ms", ",", "metric", ".", "Name", "+", "separator", "+", "resourceID", ")", "\n", "}", "\n\n", "var", "value", "float64", "\n", "if", "metric", ".", "ValueType", "==", "core", ".", "ValueInt64", "{", "value", "=", "float64", "(", "metric", ".", "IntValue", ")", "\n", "}", "else", "{", "value", "=", "float64", "(", "metric", ".", "FloatValue", ")", "\n", "}", "\n\n", "m", ":=", "metrics", ".", "Datapoint", "{", "Value", ":", "value", ",", "Timestamp", ":", "timestamp", ",", "}", "\n\n", "mh", ":=", "&", "metrics", ".", "MetricHeader", "{", "ID", ":", "name", ",", "Data", ":", "[", "]", "metrics", ".", "Datapoint", "{", "m", "}", ",", "Type", ":", "heapsterTypeToHawkularType", "(", "metric", ".", "MetricType", ")", ",", "}", "\n\n", "return", "mh", ",", "nil", "\n", "}" ]

[ "Converts", "Timeseries", "to", "metric", "structure", "used", "by", "the", "Hawkular" ]

[ "func", "parseFilters", "(", "v", "[", "]", "string", ")", "(", "[", "]", "Filter", ",", "error", ")", "{", "fs", ":=", "make", "(", "[", "]", "Filter", ",", "0", ",", "len", "(", "v", ")", ")", "\n", "for", "_", ",", "s", ":=", "range", "v", "{", "p", ":=", "strings", ".", "Index", "(", "s", ",", "\"", "\"", ")", "\n", "if", "p", "<", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "strings", ".", "Index", "(", "s", ",", "\"", "\"", ")", "!=", "len", "(", "s", ")", "-", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "t", ":=", "Unknown", ".", "From", "(", "s", "[", ":", "p", "]", ")", "\n", "if", "t", "==", "Unknown", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "command", ":=", "s", "[", "p", "+", "1", ":", "len", "(", "s", ")", "-", "1", "]", "\n\n", "switch", "t", "{", "case", "Label", ":", "proto", ":=", "strings", ".", "SplitN", "(", "command", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "proto", ")", "<", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "r", ",", "err", ":=", "regexp", ".", "Compile", "(", "proto", "[", "1", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "fs", "=", "append", "(", "fs", ",", "labelFilter", "(", "proto", "[", "0", "]", ",", "r", ")", ")", "\n", "break", "\n", "case", "Name", ":", "r", ",", "err", ":=", "regexp", ".", "Compile", "(", "command", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "fs", "=", "append", "(", "fs", ",", "nameFilter", "(", "r", ")", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "fs", ",", "nil", "\n", "}" ]

[ "If", "Heapster", "gets", "filters", "remove", "these", ".." ]

[ "func", "main", "(", ")", "{", "encoding", ".", "Register", "(", ")", "\n\n", "s", ",", "e", ":=", "tcell", ".", "NewScreen", "(", ")", "\n", "if", "e", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "e", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "if", "e", ":=", "s", ".", "Init", "(", ")", ";", "e", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "e", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n", "defStyle", "=", "tcell", ".", "StyleDefault", ".", "Background", "(", "tcell", ".", "ColorBlack", ")", ".", "Foreground", "(", "tcell", ".", "ColorWhite", ")", "\n", "s", ".", "SetStyle", "(", "defStyle", ")", "\n", "s", ".", "EnableMouse", "(", ")", "\n", "s", ".", "Clear", "(", ")", "\n\n", "posfmt", ":=", "\"", "\"", "\n", "btnfmt", ":=", "\"", "\"", "\n", "keyfmt", ":=", "\"", "\"", "\n", "white", ":=", "tcell", ".", "StyleDefault", ".", "Foreground", "(", "tcell", ".", "ColorWhite", ")", ".", "Background", "(", "tcell", ".", "ColorRed", ")", "\n\n", "mx", ",", "my", ":=", "-", "1", ",", "-", "1", "\n", "ox", ",", "oy", ":=", "-", "1", ",", "-", "1", "\n", "bx", ",", "by", ":=", "-", "1", ",", "-", "1", "\n", "w", ",", "h", ":=", "s", ".", "Size", "(", ")", "\n", "lchar", ":=", "'*'", "\n", "bstr", ":=", "\"", "\"", "\n", "lks", ":=", "\"", "\"", "\n", "ecnt", ":=", "0", "\n\n", "for", "{", "drawBox", "(", "s", ",", "1", ",", "1", ",", "42", ",", "6", ",", "white", ",", "' '", ")", "\n", "emitStr", "(", "s", ",", "2", ",", "2", ",", "white", ",", "\"", "\"", ")", "\n", "emitStr", "(", "s", ",", "2", ",", "3", ",", "white", ",", "fmt", ".", "Sprintf", "(", "posfmt", ",", "mx", ",", "my", ")", ")", "\n", "emitStr", "(", "s", ",", "2", ",", "4", ",", "white", ",", "fmt", ".", "Sprintf", "(", "btnfmt", ",", "bstr", ")", ")", "\n", "emitStr", "(", "s", ",", "2", ",", "5", ",", "white", ",", "fmt", ".", "Sprintf", "(", "keyfmt", ",", "lks", ")", ")", "\n\n", "s", ".", "Show", "(", ")", "\n", "bstr", "=", "\"", "\"", "\n", "ev", ":=", "s", ".", "PollEvent", "(", ")", "\n", "st", ":=", "tcell", ".", "StyleDefault", ".", "Background", "(", "tcell", ".", "ColorRed", ")", "\n", "up", ":=", "tcell", ".", "StyleDefault", ".", "Background", "(", "tcell", ".", "ColorBlue", ")", ".", "Foreground", "(", "tcell", ".", "ColorBlack", ")", "\n", "w", ",", "h", "=", "s", ".", "Size", "(", ")", "\n\n", "// always clear any old selection box", "if", "ox", ">=", "0", "&&", "oy", ">=", "0", "&&", "bx", ">=", "0", "{", "drawSelect", "(", "s", ",", "ox", ",", "oy", ",", "bx", ",", "by", ",", "false", ")", "\n", "}", "\n\n", "switch", "ev", ":=", "ev", ".", "(", "type", ")", "{", "case", "*", "tcell", ".", "EventResize", ":", "s", ".", "Sync", "(", ")", "\n", "s", ".", "SetContent", "(", "w", "-", "1", ",", "h", "-", "1", ",", "'R'", ",", "nil", ",", "st", ")", "\n", "case", "*", "tcell", ".", "EventKey", ":", "s", ".", "SetContent", "(", "w", "-", "2", ",", "h", "-", "2", ",", "ev", ".", "Rune", "(", ")", ",", "nil", ",", "st", ")", "\n", "s", ".", "SetContent", "(", "w", "-", "1", ",", "h", "-", "1", ",", "'K'", ",", "nil", ",", "st", ")", "\n", "if", "ev", ".", "Key", "(", ")", "==", "tcell", ".", "KeyEscape", "{", "ecnt", "++", "\n", "if", "ecnt", ">", "1", "{", "s", ".", "Fini", "(", ")", "\n", "os", ".", "Exit", "(", "0", ")", "\n", "}", "\n", "}", "else", "if", "ev", ".", "Key", "(", ")", "==", "tcell", ".", "KeyCtrlL", "{", "s", ".", "Sync", "(", ")", "\n", "}", "else", "{", "ecnt", "=", "0", "\n", "if", "ev", ".", "Rune", "(", ")", "==", "'C'", "||", "ev", ".", "Rune", "(", ")", "==", "'c'", "{", "s", ".", "Clear", "(", ")", "\n", "}", "\n", "}", "\n", "lks", "=", "ev", ".", "Name", "(", ")", "\n", "case", "*", "tcell", ".", "EventMouse", ":", "x", ",", "y", ":=", "ev", ".", "Position", "(", ")", "\n", "button", ":=", "ev", ".", "Buttons", "(", ")", "\n", "for", "i", ":=", "uint", "(", "0", ")", ";", "i", "<", "8", ";", "i", "++", "{", "if", "int", "(", "button", ")", "&", "(", "1", "<<", "i", ")", "!=", "0", "{", "bstr", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", "+", "1", ")", "\n", "}", "\n", "}", "\n", "if", "button", "&", "tcell", ".", "WheelUp", "!=", "0", "{", "bstr", "+=", "\"", "\"", "\n", "}", "\n", "if", "button", "&", "tcell", ".", "WheelDown", "!=", "0", "{", "bstr", "+=", "\"", "\"", "\n", "}", "\n", "if", "button", "&", "tcell", ".", "WheelLeft", "!=", "0", "{", "bstr", "+=", "\"", "\"", "\n", "}", "\n", "if", "button", "&", "tcell", ".", "WheelRight", "!=", "0", "{", "bstr", "+=", "\"", "\"", "\n", "}", "\n", "// Only buttons, not wheel events", "button", "&=", "tcell", ".", "ButtonMask", "(", "0xff", ")", "\n", "ch", ":=", "'*'", "\n\n", "if", "button", "!=", "tcell", ".", "ButtonNone", "&&", "ox", "<", "0", "{", "ox", ",", "oy", "=", "x", ",", "y", "\n", "}", "\n", "switch", "ev", ".", "Buttons", "(", ")", "{", "case", "tcell", ".", "ButtonNone", ":", "if", "ox", ">=", "0", "{", "bg", ":=", "tcell", ".", "Color", "(", "(", "lchar", "-", "'0'", ")", "*", "2", ")", "\n", "drawBox", "(", "s", ",", "ox", ",", "oy", ",", "x", ",", "y", ",", "up", ".", "Background", "(", "bg", ")", ",", "lchar", ")", "\n", "ox", ",", "oy", "=", "-", "1", ",", "-", "1", "\n", "bx", ",", "by", "=", "-", "1", ",", "-", "1", "\n", "}", "\n", "case", "tcell", ".", "Button1", ":", "ch", "=", "'1'", "\n", "case", "tcell", ".", "Button2", ":", "ch", "=", "'2'", "\n", "case", "tcell", ".", "Button3", ":", "ch", "=", "'3'", "\n", "case", "tcell", ".", "Button4", ":", "ch", "=", "'4'", "\n", "case", "tcell", ".", "Button5", ":", "ch", "=", "'5'", "\n", "case", "tcell", ".", "Button6", ":", "ch", "=", "'6'", "\n", "case", "tcell", ".", "Button7", ":", "ch", "=", "'7'", "\n", "case", "tcell", ".", "Button8", ":", "ch", "=", "'8'", "\n", "default", ":", "ch", "=", "'*'", "\n\n", "}", "\n", "if", "button", "!=", "tcell", ".", "ButtonNone", "{", "bx", ",", "by", "=", "x", ",", "y", "\n", "}", "\n", "lchar", "=", "ch", "\n", "s", ".", "SetContent", "(", "w", "-", "1", ",", "h", "-", "1", ",", "'M'", ",", "nil", ",", "st", ")", "\n", "mx", ",", "my", "=", "x", ",", "y", "\n", "default", ":", "s", ".", "SetContent", "(", "w", "-", "1", ",", "h", "-", "1", ",", "'X'", ",", "nil", ",", "st", ")", "\n", "}", "\n\n", "if", "ox", ">=", "0", "&&", "bx", ">=", "0", "{", "drawSelect", "(", "s", ",", "ox", ",", "oy", ",", "bx", ",", "by", ",", "true", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "This", "program", "just", "shows", "simple", "mouse", "and", "keyboard", "events", ".", "Press", "ESC", "twice", "to", "exit", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "Fill", "(", "ch", "rune", ",", "style", "tcell", ".", "Style", ")", "{", "if", "v", ".", "v", "!=", "nil", "{", "for", "y", ":=", "0", ";", "y", "<", "v", ".", "height", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "v", ".", "width", ";", "x", "++", "{", "v", ".", "v", ".", "SetContent", "(", "x", "+", "v", ".", "physx", ",", "y", "+", "v", ".", "physy", ",", "ch", ",", "nil", ",", "style", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "Fill", "fills", "the", "displayed", "view", "port", "with", "the", "given", "character", "and", "style", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "Reset", "(", ")", "{", "v", ".", "limx", "=", "0", "\n", "v", ".", "limy", "=", "0", "\n", "v", ".", "viewx", "=", "0", "\n", "v", ".", "viewy", "=", "0", "\n", "}" ]

[ "Reset", "resets", "the", "record", "of", "content", "and", "also", "resets", "the", "offset", "back", "to", "the", "origin", ".", "It", "doesn", "t", "alter", "the", "dimensions", "of", "the", "view", "port", "nor", "the", "physical", "location", "relative", "to", "its", "parent", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "MakeVisible", "(", "x", ",", "y", "int", ")", "{", "if", "x", "<", "v", ".", "limx", "&&", "x", ">=", "v", ".", "viewx", "+", "v", ".", "width", "{", "v", ".", "viewx", "=", "x", "-", "(", "v", ".", "width", "-", "1", ")", "\n", "}", "\n", "if", "x", ">=", "0", "&&", "x", "<", "v", ".", "viewx", "{", "v", ".", "viewx", "=", "x", "\n", "}", "\n", "if", "y", "<", "v", ".", "limy", "&&", "y", ">=", "v", ".", "viewy", "+", "v", ".", "height", "{", "v", ".", "viewy", "=", "y", "-", "(", "v", ".", "height", "-", "1", ")", "\n", "}", "\n", "if", "y", ">=", "0", "&&", "y", "<", "v", ".", "viewy", "{", "v", ".", "viewy", "=", "y", "\n", "}", "\n", "v", ".", "ValidateView", "(", ")", "\n", "}" ]

[ "MakeVisible", "moves", "the", "ViewPort", "the", "minimum", "necessary", "to", "make", "the", "given", "point", "visible", ".", "This", "should", "be", "called", "before", "any", "content", "is", "changed", "with", "SetContent", "since", "otherwise", "it", "may", "be", "possible", "to", "move", "the", "location", "onto", "a", "region", "whose", "contents", "have", "been", "discarded", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "ValidateViewY", "(", ")", "{", "if", "v", ".", "viewy", ">=", "v", ".", "limy", "-", "v", ".", "height", "{", "v", ".", "viewy", "=", "(", "v", ".", "limy", "-", "v", ".", "height", ")", "\n", "}", "\n", "if", "v", ".", "viewy", "<", "0", "{", "v", ".", "viewy", "=", "0", "\n", "}", "\n", "}" ]

[ "ValidateViewY", "ensures", "that", "the", "Y", "offset", "of", "the", "view", "port", "is", "limited", "so", "that", "it", "cannot", "scroll", "away", "from", "the", "content", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "ValidateViewX", "(", ")", "{", "if", "v", ".", "viewx", ">=", "v", ".", "limx", "-", "v", ".", "width", "{", "v", ".", "viewx", "=", "(", "v", ".", "limx", "-", "v", ".", "width", ")", "\n", "}", "\n", "if", "v", ".", "viewx", "<", "0", "{", "v", ".", "viewx", "=", "0", "\n", "}", "\n", "}" ]

[ "ValidateViewX", "ensures", "that", "the", "X", "offset", "of", "the", "view", "port", "is", "limited", "so", "that", "it", "cannot", "scroll", "away", "from", "the", "content", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "Center", "(", "x", ",", "y", "int", ")", "{", "if", "x", "<", "0", "||", "y", "<", "0", "||", "x", ">=", "v", ".", "limx", "||", "y", ">=", "v", ".", "limy", "||", "v", ".", "v", "==", "nil", "{", "return", "\n", "}", "\n", "v", ".", "viewx", "=", "x", "-", "(", "v", ".", "width", "/", "2", ")", "\n", "v", ".", "viewy", "=", "y", "-", "(", "v", ".", "height", "/", "2", ")", "\n", "v", ".", "ValidateView", "(", ")", "\n", "}" ]

[ "Center", "centers", "the", "point", "if", "possible", "in", "the", "View", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "ScrollUp", "(", "rows", "int", ")", "{", "v", ".", "viewy", "-=", "rows", "\n", "v", ".", "ValidateViewY", "(", ")", "\n", "}" ]

[ "ScrollUp", "moves", "the", "view", "up", "showing", "lower", "numbered", "rows", "of", "content", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "ScrollDown", "(", "rows", "int", ")", "{", "v", ".", "viewy", "+=", "rows", "\n", "v", ".", "ValidateViewY", "(", ")", "\n", "}" ]

[ "ScrollDown", "moves", "the", "view", "down", "showingh", "higher", "numbered", "rows", "of", "content", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "ScrollLeft", "(", "cols", "int", ")", "{", "v", ".", "viewx", "-=", "cols", "\n", "v", ".", "ValidateViewX", "(", ")", "\n", "}" ]

[ "ScrollLeft", "moves", "the", "view", "to", "the", "left", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "ScrollRight", "(", "cols", "int", ")", "{", "v", ".", "viewx", "+=", "cols", "\n", "v", ".", "ValidateViewX", "(", ")", "\n", "}" ]

[ "ScrollRight", "moves", "the", "view", "to", "the", "left", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "SetSize", "(", "width", ",", "height", "int", ")", "{", "v", ".", "height", "=", "height", "\n", "v", ".", "width", "=", "width", "\n", "v", ".", "ValidateView", "(", ")", "\n", "}" ]

[ "SetSize", "is", "used", "to", "set", "the", "visible", "size", "of", "the", "view", ".", "Enclosing", "views", "or", "layout", "managers", "can", "use", "this", "to", "inform", "the", "View", "of", "its", "correct", "visible", "size", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "GetVisible", "(", ")", "(", "int", ",", "int", ",", "int", ",", "int", ")", "{", "return", "v", ".", "viewx", ",", "v", ".", "viewy", ",", "v", ".", "viewx", "+", "v", ".", "width", "-", "1", ",", "v", ".", "viewy", "+", "v", ".", "height", "-", "1", "\n", "}" ]

[ "GetVisible", "returns", "the", "upper", "left", "and", "lower", "right", "coordinates", "of", "the", "visible", "content", ".", "That", "is", "it", "will", "return", "x1", "y1", "x2", "y2", "where", "the", "upper", "left", "cell", "is", "position", "x1", "y1", "and", "the", "lower", "right", "is", "x2", "y2", ".", "These", "coordinates", "are", "in", "the", "space", "of", "the", "content", "that", "is", "the", "content", "area", "uses", "coordinate", "0", "0", "as", "its", "first", "cell", "position", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "GetPhysical", "(", ")", "(", "int", ",", "int", ",", "int", ",", "int", ")", "{", "return", "v", ".", "physx", ",", "v", ".", "physy", ",", "v", ".", "physx", "+", "v", ".", "width", "-", "1", ",", "v", ".", "physy", "+", "v", ".", "height", "-", "1", "\n", "}" ]

[ "GetPhysical", "returns", "the", "upper", "left", "and", "lower", "right", "coordinates", "of", "the", "visible", "content", "in", "the", "coordinate", "space", "of", "the", "parent", ".", "This", "is", "may", "be", "the", "physical", "coordinates", "of", "the", "screen", "if", "the", "screen", "is", "the", "view", "s", "parent", "." ]

[ "func", "(", "v", "*", "ViewPort", ")", "Resize", "(", "x", ",", "y", ",", "width", ",", "height", "int", ")", "{", "if", "v", ".", "v", "==", "nil", "{", "return", "\n", "}", "\n", "px", ",", "py", ":=", "v", ".", "v", ".", "Size", "(", ")", "\n", "if", "x", ">=", "0", "&&", "x", "<", "px", "{", "v", ".", "physx", "=", "x", "\n", "}", "\n", "if", "y", ">=", "0", "&&", "y", "<", "py", "{", "v", ".", "physy", "=", "y", "\n", "}", "\n", "if", "width", "<", "0", "{", "width", "=", "px", "-", "x", "\n", "}", "\n", "if", "height", "<", "0", "{", "height", "=", "py", "-", "y", "\n", "}", "\n", "if", "width", "<=", "x", "+", "px", "{", "v", ".", "width", "=", "width", "\n", "}", "\n", "if", "height", "<=", "y", "+", "py", "{", "v", ".", "height", "=", "height", "\n", "}", "\n", "}" ]

[ "Resize", "is", "called", "by", "the", "enclosing", "view", "to", "change", "the", "size", "of", "the", "ViewPort", "usually", "in", "response", "to", "a", "window", "resize", "event", ".", "The", "x", "y", "refer", "are", "the", "ViewPort", "s", "location", "relative", "to", "the", "parent", "View", ".", "A", "negative", "value", "for", "either", "width", "or", "height", "will", "cause", "the", "ViewPort", "to", "expand", "to", "fill", "to", "the", "end", "of", "parent", "View", "in", "the", "relevant", "dimension", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "SetCenter", "(", "s", "string", ",", "style", "tcell", ".", "Style", ")", "{", "t", ".", "initialize", "(", ")", "\n", "if", "style", "==", "tcell", ".", "StyleDefault", "{", "style", "=", "t", ".", "style", "\n", "}", "\n", "t", ".", "center", ".", "SetText", "(", "s", ")", "\n", "t", ".", "center", ".", "SetStyle", "(", "style", ")", "\n", "}" ]

[ "SetCenter", "sets", "the", "center", "text", "for", "the", "textbar", ".", "The", "text", "is", "always", "center", "aligned", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "SetStyle", "(", "style", "tcell", ".", "Style", ")", "{", "t", ".", "initialize", "(", ")", "\n", "t", ".", "style", "=", "style", "\n", "}" ]

[ "SetStyle", "is", "used", "to", "set", "a", "default", "style", "to", "use", "for", "the", "textbar", "including", "areas", "where", "no", "text", "is", "present", ".", "Note", "that", "this", "will", "not", "change", "the", "text", "already", "displayed", "so", "call", "this", "before", "changing", "or", "setting", "text", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "SetView", "(", "view", "View", ")", "{", "t", ".", "initialize", "(", ")", "\n", "t", ".", "view", "=", "view", "\n", "t", ".", "lview", ".", "SetView", "(", "view", ")", "\n", "t", ".", "rview", ".", "SetView", "(", "view", ")", "\n", "t", ".", "cview", ".", "SetView", "(", "view", ")", "\n", "t", ".", "changed", "=", "true", "\n", "}" ]

[ "SetView", "sets", "the", "View", "drawing", "context", "for", "this", "TextBar", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "Draw", "(", ")", "{", "t", ".", "initialize", "(", ")", "\n", "if", "t", ".", "changed", "{", "t", ".", "layout", "(", ")", "\n", "}", "\n", "w", ",", "h", ":=", "t", ".", "view", ".", "Size", "(", ")", "\n", "for", "y", ":=", "0", ";", "y", "<", "h", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "w", ";", "x", "++", "{", "t", ".", "view", ".", "SetContent", "(", "x", ",", "y", ",", "' '", ",", "nil", ",", "t", ".", "style", ")", "\n", "}", "\n", "}", "\n\n", "// Draw in reverse order -- if we clip, we will clip at the", "// right side.", "t", ".", "right", ".", "Draw", "(", ")", "\n", "t", ".", "center", ".", "Draw", "(", ")", "\n", "t", ".", "left", ".", "Draw", "(", ")", "\n", "}" ]

[ "Draw", "draws", "the", "TextBar", "into", "its", "View", "context", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "Resize", "(", ")", "{", "t", ".", "initialize", "(", ")", "\n", "t", ".", "layout", "(", ")", "\n\n", "t", ".", "left", ".", "Resize", "(", ")", "\n", "t", ".", "center", ".", "Resize", "(", ")", "\n", "t", ".", "right", ".", "Resize", "(", ")", "\n\n", "t", ".", "PostEventWidgetResize", "(", "t", ")", "\n", "}" ]

[ "Resize", "is", "called", "when", "the", "TextBar", "s", "View", "changes", "size", "and", "updates", "the", "layout", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "Size", "(", ")", "(", "int", ",", "int", ")", "{", "w", ",", "h", ":=", "0", ",", "0", "\n\n", "ww", ",", "wh", ":=", "t", ".", "left", ".", "Size", "(", ")", "\n", "w", "+=", "ww", "\n", "if", "wh", ">", "h", "{", "h", "=", "wh", "\n", "}", "\n", "ww", ",", "wh", "=", "t", ".", "center", ".", "Size", "(", ")", "\n", "w", "+=", "ww", "\n", "if", "wh", ">", "h", "{", "h", "=", "wh", "\n", "}", "\n", "ww", ",", "wh", "=", "t", ".", "right", ".", "Size", "(", ")", "\n", "w", "+=", "ww", "\n", "if", "wh", ">", "h", "{", "h", "=", "wh", "\n", "}", "\n", "return", "w", ",", "h", "\n", "}" ]

[ "Size", "implements", "the", "Size", "method", "for", "Widget", "returning", "the", "width", "and", "height", "in", "character", "cells", "." ]

[ "func", "(", "t", "*", "TextBar", ")", "HandleEvent", "(", "ev", "tcell", ".", "Event", ")", "bool", "{", "switch", "ev", ".", "(", "type", ")", "{", "case", "*", "EventWidgetContent", ":", "t", ".", "changed", "=", "true", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HandleEvent", "handles", "incoming", "events", ".", "The", "only", "events", "handled", "are", "those", "for", "the", "Text", "objects", ";", "when", "those", "change", "the", "TextBar", "adjusts", "the", "layout", "to", "accommodate", "." ]

[ "func", "(", "c", "Color", ")", "Hex", "(", ")", "int32", "{", "if", "c", "&", "ColorIsRGB", "!=", "0", "{", "return", "(", "int32", "(", "c", ")", "&", "0xffffff", ")", "\n", "}", "\n", "if", "v", ",", "ok", ":=", "ColorValues", "[", "c", "]", ";", "ok", "{", "return", "v", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "Hex", "returns", "the", "color", "s", "hexadecimal", "RGB", "24", "-", "bit", "value", "with", "each", "component", "consisting", "of", "a", "single", "byte", "ala", "R", "<<", "16", "|", "G", "<<", "8", "|", "B", ".", "If", "the", "color", "is", "unknown", "or", "unset", "-", "1", "is", "returned", "." ]

[ "func", "NewRGBColor", "(", "r", ",", "g", ",", "b", "int32", ")", "Color", "{", "return", "NewHexColor", "(", "(", "(", "r", "&", "0xff", ")", "<<", "16", ")", "|", "(", "(", "g", "&", "0xff", ")", "<<", "8", ")", "|", "(", "b", "&", "0xff", ")", ")", "\n", "}" ]

[ "NewRGBColor", "returns", "a", "new", "color", "with", "the", "given", "red", "green", "and", "blue", "values", ".", "Each", "value", "must", "be", "represented", "in", "the", "range", "0", "-", "255", "." ]

[ "func", "(", "cb", "*", "CellBuffer", ")", "Invalidate", "(", ")", "{", "for", "i", ":=", "range", "cb", ".", "cells", "{", "cb", ".", "cells", "[", "i", "]", ".", "lastMain", "=", "rune", "(", "0", ")", "\n", "}", "\n", "}" ]

[ "Invalidate", "marks", "all", "characters", "within", "the", "buffer", "as", "dirty", "." ]

[ "func", "(", "cb", "*", "CellBuffer", ")", "Dirty", "(", "x", ",", "y", "int", ")", "bool", "{", "if", "x", ">=", "0", "&&", "y", ">=", "0", "&&", "x", "<", "cb", ".", "w", "&&", "y", "<", "cb", ".", "h", "{", "c", ":=", "&", "cb", ".", "cells", "[", "(", "y", "*", "cb", ".", "w", ")", "+", "x", "]", "\n", "if", "c", ".", "lastMain", "==", "rune", "(", "0", ")", "{", "return", "true", "\n", "}", "\n", "if", "c", ".", "lastMain", "!=", "c", ".", "currMain", "{", "return", "true", "\n", "}", "\n", "if", "c", ".", "lastStyle", "!=", "c", ".", "currStyle", "{", "return", "true", "\n", "}", "\n", "if", "len", "(", "c", ".", "lastComb", ")", "!=", "len", "(", "c", ".", "currComb", ")", "{", "return", "true", "\n", "}", "\n", "for", "i", ":=", "range", "c", ".", "lastComb", "{", "if", "c", ".", "lastComb", "[", "i", "]", "!=", "c", ".", "currComb", "[", "i", "]", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Dirty", "checks", "if", "a", "character", "at", "the", "given", "location", "needs", "an", "to", "be", "refreshed", "on", "the", "physical", "display", ".", "This", "returns", "true", "if", "the", "cell", "content", "is", "different", "since", "the", "last", "time", "it", "was", "marked", "clean", "." ]

[ "func", "(", "cb", "*", "CellBuffer", ")", "Resize", "(", "w", ",", "h", "int", ")", "{", "if", "cb", ".", "h", "==", "h", "&&", "cb", ".", "w", "==", "w", "{", "return", "\n", "}", "\n\n", "newc", ":=", "make", "(", "[", "]", "cell", ",", "w", "*", "h", ")", "\n", "for", "y", ":=", "0", ";", "y", "<", "h", "&&", "y", "<", "cb", ".", "h", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "w", "&&", "x", "<", "cb", ".", "w", ";", "x", "++", "{", "oc", ":=", "&", "cb", ".", "cells", "[", "(", "y", "*", "cb", ".", "w", ")", "+", "x", "]", "\n", "nc", ":=", "&", "newc", "[", "(", "y", "*", "w", ")", "+", "x", "]", "\n", "nc", ".", "currMain", "=", "oc", ".", "currMain", "\n", "nc", ".", "currComb", "=", "oc", ".", "currComb", "\n", "nc", ".", "currStyle", "=", "oc", ".", "currStyle", "\n", "nc", ".", "width", "=", "oc", ".", "width", "\n", "nc", ".", "lastMain", "=", "rune", "(", "0", ")", "\n", "}", "\n", "}", "\n", "cb", ".", "cells", "=", "newc", "\n", "cb", ".", "h", "=", "h", "\n", "cb", ".", "w", "=", "w", "\n", "}" ]

[ "Resize", "is", "used", "to", "resize", "the", "cells", "array", "with", "different", "dimensions", "while", "preserving", "the", "original", "contents", ".", "The", "cells", "will", "be", "invalidated", "so", "that", "they", "can", "be", "redrawn", "." ]

[ "func", "(", "cb", "*", "CellBuffer", ")", "Fill", "(", "r", "rune", ",", "style", "Style", ")", "{", "for", "i", ":=", "range", "cb", ".", "cells", "{", "c", ":=", "&", "cb", ".", "cells", "[", "i", "]", "\n", "c", ".", "currMain", "=", "r", "\n", "c", ".", "currComb", "=", "nil", "\n", "c", ".", "currStyle", "=", "style", "\n", "c", ".", "width", "=", "1", "\n", "}", "\n", "}" ]

[ "Fill", "fills", "the", "entire", "cell", "buffer", "array", "with", "the", "specified", "character", "and", "style", ".", "Normally", "choose", "to", "clear", "the", "screen", ".", "This", "API", "doesn", "t", "support", "combining", "characters", "or", "characters", "with", "a", "width", "larger", "than", "one", "." ]

[ "func", "(", "ww", "*", "WidgetWatchers", ")", "Watch", "(", "handler", "tcell", ".", "EventHandler", ")", "{", "if", "ww", ".", "watchers", "==", "nil", "{", "ww", ".", "watchers", "=", "make", "(", "map", "[", "tcell", ".", "EventHandler", "]", "struct", "{", "}", ")", "\n", "}", "\n", "ww", ".", "watchers", "[", "handler", "]", "=", "struct", "{", "}", "{", "}", "\n", "}" ]

[ "Watch", "monitors", "this", "WidgetWatcher", "causing", "the", "handler", "to", "be", "fired", "with", "EventWidget", "as", "they", "are", "occur", "on", "the", "watched", "Widget", "." ]

[ "func", "(", "ww", "*", "WidgetWatchers", ")", "Unwatch", "(", "handler", "tcell", ".", "EventHandler", ")", "{", "if", "ww", ".", "watchers", "!=", "nil", "{", "delete", "(", "ww", ".", "watchers", ",", "handler", ")", "\n", "}", "\n", "}" ]

[ "Unwatch", "stops", "monitoring", "this", "WidgetWatcher", ".", "The", "handler", "will", "no", "longer", "be", "fired", "for", "Widget", "events", "." ]

[ "func", "(", "ww", "*", "WidgetWatchers", ")", "PostEvent", "(", "wev", "EventWidget", ")", "{", "for", "watcher", ":=", "range", "ww", ".", "watchers", "{", "// Deliver events to all listeners, ignoring return value.", "watcher", ".", "HandleEvent", "(", "wev", ")", "\n", "}", "\n", "}" ]

[ "PostEvent", "delivers", "the", "EventWidget", "to", "all", "registered", "watchers", ".", "It", "is", "to", "be", "called", "by", "the", "Widget", "implementation", "." ]

[ "func", "(", "ww", "*", "WidgetWatchers", ")", "PostEventWidgetContent", "(", "w", "Widget", ")", "{", "ev", ":=", "&", "EventWidgetContent", "{", "}", "\n", "ev", ".", "SetWidget", "(", "w", ")", "\n", "ev", ".", "SetEventNow", "(", ")", "\n", "ww", ".", "PostEvent", "(", "ev", ")", "\n", "}" ]

[ "PostEventWidgetContent", "is", "called", "by", "the", "Widget", "when", "its", "content", "is", "changed", "delivering", "EventWidgetContent", "to", "all", "watchers", "." ]

[ "func", "(", "ww", "*", "WidgetWatchers", ")", "PostEventWidgetResize", "(", "w", "Widget", ")", "{", "ev", ":=", "&", "EventWidgetResize", "{", "}", "\n", "ev", ".", "SetWidget", "(", "w", ")", "\n", "ev", ".", "SetEventNow", "(", ")", "\n", "ww", ".", "PostEvent", "(", "ev", ")", "\n", "}" ]

[ "PostEventWidgetResize", "is", "called", "by", "the", "Widget", "when", "the", "underlying", "View", "has", "resized", "delivering", "EventWidgetResize", "to", "all", "watchers", "." ]

[ "func", "(", "ww", "*", "WidgetWatchers", ")", "PostEventWidgetMove", "(", "w", "Widget", ")", "{", "ev", ":=", "&", "EventWidgetMove", "{", "}", "\n", "ev", ".", "SetWidget", "(", "w", ")", "\n", "ev", ".", "SetEventNow", "(", ")", "\n", "ww", ".", "PostEvent", "(", "ev", ")", "\n", "}" ]

[ "PostEventWidgetMove", "is", "called", "by", "the", "Widget", "when", "it", "is", "moved", "to", "a", "new", "location", "delivering", "EventWidgetMove", "to", "all", "watchers", "." ]

[ "func", "(", "ta", "*", "TextArea", ")", "SetLines", "(", "lines", "[", "]", "string", ")", "{", "ta", ".", "Init", "(", ")", "\n", "m", ":=", "ta", ".", "model", "\n", "m", ".", "width", "=", "0", "\n", "m", ".", "height", "=", "len", "(", "lines", ")", "\n", "m", ".", "lines", "=", "append", "(", "[", "]", "string", "{", "}", ",", "lines", "...", ")", "\n", "for", "_", ",", "l", ":=", "range", "lines", "{", "if", "len", "(", "l", ")", ">", "m", ".", "width", "{", "m", ".", "width", "=", "len", "(", "l", ")", "\n", "}", "\n", "}", "\n", "ta", ".", "CellView", ".", "SetModel", "(", "m", ")", "\n", "}" ]

[ "SetLines", "sets", "the", "content", "text", "to", "display", "." ]

[ "func", "(", "ta", "*", "TextArea", ")", "EnableCursor", "(", "on", "bool", ")", "{", "ta", ".", "Init", "(", ")", "\n", "ta", ".", "model", ".", "cursor", "=", "on", "\n", "}" ]

[ "EnableCursor", "enables", "a", "soft", "cursor", "in", "the", "TextArea", "." ]

[ "func", "(", "ta", "*", "TextArea", ")", "HideCursor", "(", "on", "bool", ")", "{", "ta", ".", "Init", "(", ")", "\n", "ta", ".", "model", ".", "hide", "=", "on", "\n", "}" ]

[ "HideCursor", "hides", "or", "shows", "the", "cursor", "in", "the", "TextArea", ".", "If", "on", "is", "true", "the", "cursor", "is", "hidden", ".", "Note", "that", "a", "cursor", "is", "only", "shown", "if", "it", "is", "enabled", "." ]

[ "func", "(", "ta", "*", "TextArea", ")", "SetContent", "(", "text", "string", ")", "{", "ta", ".", "Init", "(", ")", "\n", "lines", ":=", "strings", ".", "Split", "(", "strings", ".", "Trim", "(", "text", ",", "\"", "\\n", "\"", ")", ",", "\"", "\\n", "\"", ")", "\n", "ta", ".", "SetLines", "(", "lines", ")", "\n", "}" ]

[ "SetContent", "is", "used", "to", "set", "the", "textual", "content", "passed", "as", "a", "single", "string", ".", "Lines", "within", "the", "string", "are", "delimited", "by", "newlines", "." ]

[ "func", "(", "ta", "*", "TextArea", ")", "Init", "(", ")", "{", "ta", ".", "once", ".", "Do", "(", "func", "(", ")", "{", "lm", ":=", "&", "linesModel", "{", "lines", ":", "[", "]", "string", "{", "}", ",", "width", ":", "0", "}", "\n", "ta", ".", "model", "=", "lm", "\n", "ta", ".", "CellView", ".", "Init", "(", ")", "\n", "ta", ".", "CellView", ".", "SetModel", "(", "lm", ")", "\n", "}", ")", "\n", "}" ]

[ "Init", "initializes", "the", "TextArea", "." ]

[ "func", "(", "t", "*", "Text", ")", "calcY", "(", "height", "int", ")", "int", "{", "if", "t", ".", "align", "&", "VAlignCenter", "!=", "0", "{", "return", "(", "height", "-", "len", "(", "t", ".", "lengths", ")", ")", "/", "2", "\n", "}", "\n", "if", "t", ".", "align", "&", "VAlignBottom", "!=", "0", "{", "return", "height", "-", "len", "(", "t", ".", "lengths", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "calcY", "figures", "the", "initial", "Y", "offset", ".", "Alignment", "is", "top", "by", "default", "." ]

[ "func", "(", "t", "*", "Text", ")", "calcX", "(", "width", ",", "line", "int", ")", "int", "{", "if", "t", ".", "align", "&", "HAlignCenter", "!=", "0", "{", "return", "(", "width", "-", "t", ".", "lengths", "[", "line", "]", ")", "/", "2", "\n", "}", "\n", "if", "t", ".", "align", "&", "HAlignRight", "!=", "0", "{", "return", "width", "-", "t", ".", "lengths", "[", "line", "]", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "calcX", "figures", "the", "initial", "X", "offset", "for", "the", "given", "line", ".", "Alignment", "is", "left", "by", "default", "." ]

[ "func", "(", "t", "*", "Text", ")", "Draw", "(", ")", "{", "v", ":=", "t", ".", "view", "\n", "if", "v", "==", "nil", "{", "return", "\n", "}", "\n\n", "width", ",", "height", ":=", "v", ".", "Size", "(", ")", "\n", "if", "width", "==", "0", "||", "height", "==", "0", "{", "return", "\n", "}", "\n\n", "t", ".", "clear", "(", ")", "\n\n", "// Note that we might wind up with a negative X if the width", "// is larger than the length. That's OK, and correct even.", "// The view will clip it properly in that case.", "// We align to the left & top by default.", "y", ":=", "t", ".", "calcY", "(", "height", ")", "\n", "r", ":=", "rune", "(", "0", ")", "\n", "w", ":=", "0", "\n", "x", ":=", "0", "\n", "var", "styl", "tcell", ".", "Style", "\n", "var", "comb", "[", "]", "rune", "\n", "line", ":=", "0", "\n", "newline", ":=", "true", "\n", "for", "i", ",", "l", ":=", "range", "t", ".", "text", "{", "if", "newline", "{", "x", "=", "t", ".", "calcX", "(", "width", ",", "line", ")", "\n", "newline", "=", "false", "\n", "}", "\n", "if", "l", "==", "'\\n'", "{", "if", "w", "!=", "0", "{", "v", ".", "SetContent", "(", "x", ",", "y", ",", "r", ",", "comb", ",", "styl", ")", "\n", "}", "\n", "newline", "=", "true", "\n", "w", "=", "0", "\n", "comb", "=", "nil", "\n", "line", "++", "\n", "y", "++", "\n", "continue", "\n", "}", "\n", "if", "t", ".", "widths", "[", "i", "]", "==", "0", "{", "comb", "=", "append", "(", "comb", ",", "l", ")", "\n", "continue", "\n", "}", "\n", "if", "w", "!=", "0", "{", "v", ".", "SetContent", "(", "x", ",", "y", ",", "r", ",", "comb", ",", "styl", ")", "\n", "x", "+=", "w", "\n", "}", "\n", "r", "=", "l", "\n", "w", "=", "t", ".", "widths", "[", "i", "]", "\n", "styl", "=", "t", ".", "styles", "[", "i", "]", "\n", "comb", "=", "nil", "\n", "}", "\n", "if", "w", "!=", "0", "{", "v", ".", "SetContent", "(", "x", ",", "y", ",", "r", ",", "comb", ",", "styl", ")", "\n", "}", "\n", "}" ]

[ "Draw", "draws", "the", "Text", "." ]

[ "func", "(", "t", "*", "Text", ")", "Size", "(", ")", "(", "int", ",", "int", ")", "{", "if", "len", "(", "t", ".", "text", ")", "!=", "0", "{", "return", "t", ".", "width", ",", "t", ".", "height", "\n", "}", "\n", "return", "0", ",", "0", "\n", "}" ]

[ "Size", "returns", "the", "width", "and", "height", "in", "character", "cells", "of", "the", "Text", "." ]

[ "func", "(", "t", "*", "Text", ")", "SetAlignment", "(", "align", "Alignment", ")", "{", "if", "align", "!=", "t", ".", "align", "{", "t", ".", "align", "=", "align", "\n", "t", ".", "PostEventWidgetContent", "(", "t", ")", "\n", "}", "\n", "}" ]

[ "SetAlignment", "sets", "the", "alignment", ".", "Negative", "values", "indicate", "right", "justification", "positive", "values", "are", "left", "and", "zero", "indicates", "center", "aligned", "." ]

[ "func", "(", "t", "*", "Text", ")", "SetText", "(", "s", "string", ")", "{", "t", ".", "width", "=", "0", "\n", "t", ".", "text", "=", "[", "]", "rune", "(", "s", ")", "\n", "if", "len", "(", "t", ".", "widths", ")", "<", "len", "(", "t", ".", "text", ")", "{", "t", ".", "widths", "=", "make", "(", "[", "]", "int", ",", "len", "(", "t", ".", "text", ")", ")", "\n", "}", "else", "{", "t", ".", "widths", "=", "t", ".", "widths", "[", "0", ":", "len", "(", "t", ".", "text", ")", "]", "\n", "}", "\n", "if", "len", "(", "t", ".", "styles", ")", "<", "len", "(", "t", ".", "text", ")", "{", "t", ".", "styles", "=", "make", "(", "[", "]", "tcell", ".", "Style", ",", "len", "(", "t", ".", "text", ")", ")", "\n", "}", "else", "{", "t", ".", "styles", "=", "t", ".", "styles", "[", "0", ":", "len", "(", "t", ".", "text", ")", "]", "\n", "}", "\n", "t", ".", "lengths", "=", "[", "]", "int", "{", "}", "\n", "length", ":=", "0", "\n", "for", "i", ",", "r", ":=", "range", "t", ".", "text", "{", "t", ".", "widths", "[", "i", "]", "=", "runewidth", ".", "RuneWidth", "(", "r", ")", "\n", "t", ".", "styles", "[", "i", "]", "=", "t", ".", "style", "\n", "if", "r", "==", "'\\n'", "{", "t", ".", "lengths", "=", "append", "(", "t", ".", "lengths", ",", "length", ")", "\n", "if", "length", ">", "t", ".", "width", "{", "t", ".", "width", "=", "length", "\n", "length", "=", "0", "\n", "}", "\n\n", "}", "else", "if", "t", ".", "widths", "[", "i", "]", "==", "0", "&&", "length", "==", "0", "{", "// If first character on line is combining, inject", "// a leading space. (Shame on the caller!)", "t", ".", "widths", "=", "append", "(", "t", ".", "widths", ",", "0", ")", "\n", "copy", "(", "t", ".", "widths", "[", "i", "+", "1", ":", "]", ",", "t", ".", "widths", "[", "i", ":", "]", ")", "\n", "t", ".", "widths", "[", "i", "]", "=", "1", "\n\n", "t", ".", "text", "=", "append", "(", "t", ".", "text", ",", "' '", ")", "\n", "copy", "(", "t", ".", "text", "[", "i", "+", "1", ":", "]", ",", "t", ".", "text", "[", "i", ":", "]", ")", "\n", "t", ".", "text", "[", "i", "]", "=", "' '", "\n\n", "t", ".", "styles", "=", "append", "(", "t", ".", "styles", ",", "t", ".", "style", ")", "\n", "copy", "(", "t", ".", "styles", "[", "i", "+", "1", ":", "]", ",", "t", ".", "styles", "[", "i", ":", "]", ")", "\n", "t", ".", "styles", "[", "i", "]", "=", "t", ".", "style", "\n", "length", "++", "\n", "}", "else", "{", "length", "+=", "t", ".", "widths", "[", "i", "]", "\n", "}", "\n", "}", "\n", "if", "length", ">", "0", "{", "t", ".", "lengths", "=", "append", "(", "t", ".", "lengths", ",", "length", ")", "\n", "if", "length", ">", "t", ".", "width", "{", "t", ".", "width", "=", "length", "\n", "}", "\n", "}", "\n", "t", ".", "height", "=", "len", "(", "t", ".", "lengths", ")", "\n", "t", ".", "PostEventWidgetContent", "(", "t", ")", "\n", "}" ]

[ "SetText", "sets", "the", "text", "used", "for", "the", "string", ".", "Any", "previously", "set", "styles", "on", "individual", "rune", "indices", "are", "reset", "and", "the", "default", "style", "for", "the", "widget", "is", "set", "." ]

[ "func", "(", "t", "*", "Text", ")", "SetStyle", "(", "style", "tcell", ".", "Style", ")", "{", "t", ".", "style", "=", "style", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "t", ".", "text", ")", ";", "i", "++", "{", "if", "t", ".", "widths", "[", "i", "]", "!=", "0", "{", "t", ".", "styles", "[", "i", "]", "=", "t", ".", "style", "\n", "}", "\n", "}", "\n", "t", ".", "PostEventWidgetContent", "(", "t", ")", "\n", "}" ]

[ "SetStyle", "sets", "the", "style", "used", ".", "This", "applies", "to", "every", "cell", "in", "the", "in", "the", "text", "." ]

[ "func", "(", "t", "*", "Text", ")", "StyleAt", "(", "pos", "int", ")", "tcell", ".", "Style", "{", "if", "pos", "<", "0", "||", "pos", ">=", "len", "(", "t", ".", "text", ")", "||", "t", ".", "widths", "[", "pos", "]", "<", "1", "{", "return", "tcell", ".", "StyleDefault", "\n", "}", "\n", "return", "t", ".", "styles", "[", "pos", "]", "\n", "}" ]

[ "StyleAt", "gets", "the", "style", "at", "the", "given", "rune", "index", ".", "If", "an", "invalid", "index", "is", "given", "or", "the", "index", "is", "a", "combining", "character", "then", "tcell", ".", "StyleDefault", "is", "returned", "." ]

[ "func", "(", "s", "*", "SimpleStyledTextBar", ")", "SetCenter", "(", "m", "string", ")", "{", "s", ".", "initialize", "(", ")", "\n", "s", ".", "center", ".", "SetMarkup", "(", "m", ")", "\n", "}" ]

[ "SetCenter", "sets", "the", "center", "text", "for", "the", "textbar", ".", "It", "is", "always", "centered", "." ]

[ "func", "Init", "(", ")", "error", "{", "outMode", "=", "OutputNormal", "\n", "if", "s", ",", "e", ":=", "tcell", ".", "NewScreen", "(", ")", ";", "e", "!=", "nil", "{", "return", "e", "\n", "}", "else", "if", "e", "=", "s", ".", "Init", "(", ")", ";", "e", "!=", "nil", "{", "return", "e", "\n", "}", "else", "{", "screen", "=", "s", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "Init", "initializes", "the", "screen", "for", "use", "." ]

[ "func", "Clear", "(", "fg", ",", "bg", "Attribute", ")", "{", "st", ":=", "mkStyle", "(", "fg", ",", "bg", ")", "\n", "w", ",", "h", ":=", "screen", ".", "Size", "(", ")", "\n", "for", "row", ":=", "0", ";", "row", "<", "h", ";", "row", "++", "{", "for", "col", ":=", "0", ";", "col", "<", "w", ";", "col", "++", "{", "screen", ".", "SetContent", "(", "col", ",", "row", ",", "' '", ",", "nil", ",", "st", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Clear", "clears", "the", "screen", "with", "the", "given", "attributes", "." ]

[ "func", "SetOutputMode", "(", "mode", "OutputMode", ")", "OutputMode", "{", "if", "screen", ".", "Colors", "(", ")", "<", "256", "{", "mode", "=", "OutputNormal", "\n", "}", "\n", "switch", "mode", "{", "case", "OutputCurrent", ":", "return", "outMode", "\n", "case", "OutputNormal", ",", "Output256", ",", "Output216", ",", "OutputGrayscale", ":", "outMode", "=", "mode", "\n", "return", "mode", "\n", "default", ":", "return", "outMode", "\n", "}", "\n", "}" ]

[ "SetOutputMode", "is", "used", "to", "set", "the", "color", "palette", "used", "." ]

[ "func", "ParseEvent", "(", "data", "[", "]", "byte", ")", "Event", "{", "// Not supported", "return", "Event", "{", "Type", ":", "EventError", ",", "Err", ":", "errors", ".", "New", "(", "\"", "\"", ")", "}", "\n", "}" ]

[ "ParseEvent", "is", "not", "supported", "." ]

[ "func", "NewEventError", "(", "err", "error", ")", "*", "EventError", "{", "return", "&", "EventError", "{", "t", ":", "time", ".", "Now", "(", ")", ",", "err", ":", "err", "}", "\n", "}" ]

[ "NewEventError", "creates", "an", "ErrorEvent", "with", "the", "given", "error", "payload", "." ]

[ "func", "(", "s", "Style", ")", "Foreground", "(", "c", "Color", ")", "Style", "{", "if", "c", "==", "ColorDefault", "{", "return", "(", "s", "&^", "(", "0x1ffffff00000000", "|", "styleFgSet", ")", ")", "\n", "}", "\n", "return", "(", "s", "&^", "Style", "(", "0x1ffffff00000000", ")", ")", "|", "(", "(", "Style", "(", "c", ")", "&", "0x1ffffff", ")", "<<", "32", ")", "|", "styleFgSet", "\n", "}" ]

[ "Foreground", "returns", "a", "new", "style", "based", "on", "s", "with", "the", "foreground", "color", "set", "as", "requested", ".", "ColorDefault", "can", "be", "used", "to", "select", "the", "global", "default", "." ]

[ "func", "(", "s", "Style", ")", "Background", "(", "c", "Color", ")", "Style", "{", "if", "c", "==", "ColorDefault", "{", "return", "(", "s", "&^", "(", "0x1ffffff", "|", "styleBgSet", ")", ")", "\n", "}", "\n", "return", "(", "s", "&^", "(", "0x1ffffff", ")", ")", "|", "(", "Style", "(", "c", ")", "&", "0x1ffffff", ")", "|", "styleBgSet", "\n", "}" ]

[ "Background", "returns", "a", "new", "style", "based", "on", "s", "with", "the", "background", "color", "set", "as", "requested", ".", "ColorDefault", "can", "be", "used", "to", "select", "the", "global", "default", "." ]

[ "func", "(", "s", "Style", ")", "Decompose", "(", ")", "(", "fg", "Color", ",", "bg", "Color", ",", "attr", "AttrMask", ")", "{", "if", "s", "&", "styleFgSet", "!=", "0", "{", "fg", "=", "Color", "(", "s", ">>", "32", ")", "&", "0x1ffffff", "\n", "}", "else", "{", "fg", "=", "ColorDefault", "\n", "}", "\n", "if", "s", "&", "styleBgSet", "!=", "0", "{", "bg", "=", "Color", "(", "s", "&", "0x1ffffff", ")", "\n", "}", "else", "{", "bg", "=", "ColorDefault", "\n", "}", "\n", "attr", "=", "AttrMask", "(", "s", ")", "&", "attrAll", "\n\n", "return", "fg", ",", "bg", ",", "attr", "\n", "}" ]

[ "Decompose", "breaks", "a", "style", "up", "returning", "the", "foreground", "background", "and", "other", "attributes", "." ]

[ "func", "(", "s", "Style", ")", "Bold", "(", "on", "bool", ")", "Style", "{", "return", "s", ".", "setAttrs", "(", "Style", "(", "AttrBold", ")", ",", "on", ")", "\n", "}" ]

[ "Bold", "returns", "a", "new", "style", "based", "on", "s", "with", "the", "bold", "attribute", "set", "as", "requested", "." ]

[ "func", "(", "s", "Style", ")", "Blink", "(", "on", "bool", ")", "Style", "{", "return", "s", ".", "setAttrs", "(", "Style", "(", "AttrBlink", ")", ",", "on", ")", "\n", "}" ]

[ "Blink", "returns", "a", "new", "style", "based", "on", "s", "with", "the", "blink", "attribute", "set", "as", "requested", "." ]

[ "func", "(", "s", "Style", ")", "Dim", "(", "on", "bool", ")", "Style", "{", "return", "s", ".", "setAttrs", "(", "Style", "(", "AttrDim", ")", ",", "on", ")", "\n", "}" ]

[ "Dim", "returns", "a", "new", "style", "based", "on", "s", "with", "the", "dim", "attribute", "set", "as", "requested", "." ]

[ "func", "(", "s", "Style", ")", "Underline", "(", "on", "bool", ")", "Style", "{", "return", "s", ".", "setAttrs", "(", "Style", "(", "AttrUnderline", ")", ",", "on", ")", "\n", "}" ]

[ "Underline", "returns", "a", "new", "style", "based", "on", "s", "with", "the", "underline", "attribute", "set", "as", "requested", "." ]

[ "func", "(", "ev", "*", "EventKey", ")", "Name", "(", ")", "string", "{", "s", ":=", "\"", "\"", "\n", "m", ":=", "[", "]", "string", "{", "}", "\n", "if", "ev", ".", "mod", "&", "ModShift", "!=", "0", "{", "m", "=", "append", "(", "m", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "ev", ".", "mod", "&", "ModAlt", "!=", "0", "{", "m", "=", "append", "(", "m", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "ev", ".", "mod", "&", "ModMeta", "!=", "0", "{", "m", "=", "append", "(", "m", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "ev", ".", "mod", "&", "ModCtrl", "!=", "0", "{", "m", "=", "append", "(", "m", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ok", ":=", "false", "\n", "if", "s", ",", "ok", "=", "KeyNames", "[", "ev", ".", "key", "]", ";", "!", "ok", "{", "if", "ev", ".", "key", "==", "KeyRune", "{", "s", "=", "\"", "\"", "+", "string", "(", "ev", ".", "ch", ")", "+", "\"", "\"", "\n", "}", "else", "{", "s", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ev", ".", "key", ",", "int", "(", "ev", ".", "ch", ")", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "m", ")", "!=", "0", "{", "if", "ev", ".", "mod", "&", "ModCtrl", "!=", "0", "&&", "strings", ".", "HasPrefix", "(", "s", ",", "\"", "\"", ")", "{", "s", "=", "s", "[", "5", ":", "]", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "m", ",", "\"", "\"", ")", ",", "s", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "Name", "returns", "a", "printable", "value", "or", "the", "key", "stroke", ".", "This", "can", "be", "used", "when", "printing", "the", "event", "for", "example", "." ]

[ "func", "FindColor", "(", "c", "Color", ",", "palette", "[", "]", "Color", ")", "Color", "{", "match", ":=", "ColorDefault", "\n", "dist", ":=", "float64", "(", "0", ")", "\n", "r", ",", "g", ",", "b", ":=", "c", ".", "RGB", "(", ")", "\n", "c1", ":=", "colorful", ".", "Color", "{", "R", ":", "float64", "(", "r", ")", "/", "255.0", ",", "G", ":", "float64", "(", "g", ")", "/", "255.0", ",", "B", ":", "float64", "(", "b", ")", "/", "255.0", ",", "}", "\n", "for", "_", ",", "d", ":=", "range", "palette", "{", "r", ",", "g", ",", "b", "=", "d", ".", "RGB", "(", ")", "\n", "c2", ":=", "colorful", ".", "Color", "{", "R", ":", "float64", "(", "r", ")", "/", "255.0", ",", "G", ":", "float64", "(", "g", ")", "/", "255.0", ",", "B", ":", "float64", "(", "b", ")", "/", "255.0", ",", "}", "\n", "// CIE94 is more accurate, but really really expensive.", "nd", ":=", "c1", ".", "DistanceCIE76", "(", "c2", ")", "\n", "if", "math", ".", "IsNaN", "(", "nd", ")", "{", "nd", "=", "math", ".", "Inf", "(", "1", ")", "\n", "}", "\n", "if", "match", "==", "ColorDefault", "||", "nd", "<", "dist", "{", "match", "=", "d", "\n", "dist", "=", "nd", "\n", "}", "\n", "}", "\n", "return", "match", "\n", "}" ]

[ "FindColor", "attempts", "to", "find", "a", "given", "color", "or", "the", "best", "match", "possible", "for", "it", "from", "the", "palette", "given", ".", "This", "is", "an", "expensive", "operation", "so", "results", "should", "be", "cached", "by", "the", "caller", "." ]

[ "func", "(", "t", "*", "tScreen", ")", "buildAcsMap", "(", ")", "{", "acsstr", ":=", "t", ".", "ti", ".", "AltChars", "\n", "t", ".", "acs", "=", "make", "(", "map", "[", "rune", "]", "string", ")", "\n", "for", "len", "(", "acsstr", ")", ">", "2", "{", "srcv", ":=", "acsstr", "[", "0", "]", "\n", "dstv", ":=", "string", "(", "acsstr", "[", "1", "]", ")", "\n", "if", "r", ",", "ok", ":=", "vtACSNames", "[", "srcv", "]", ";", "ok", "{", "t", ".", "acs", "[", "r", "]", "=", "t", ".", "ti", ".", "EnterAcs", "+", "dstv", "+", "t", ".", "ti", ".", "ExitAcs", "\n", "}", "\n", "acsstr", "=", "acsstr", "[", "2", ":", "]", "\n", "}", "\n", "}" ]

[ "buildAcsMap", "builds", "a", "map", "of", "characters", "that", "we", "translate", "from", "Unicode", "to", "alternate", "character", "encodings", ".", "To", "do", "this", "we", "use", "the", "standard", "VT100", "ACS", "maps", ".", "This", "is", "only", "done", "if", "the", "terminal", "lacks", "support", "for", "Unicode", ";", "we", "always", "prefer", "to", "emit", "Unicode", "glyphs", "when", "we", "are", "able", "." ]

[ "func", "(", "t", "*", "tScreen", ")", "parseXtermMouse", "(", "buf", "*", "bytes", ".", "Buffer", ")", "(", "bool", ",", "bool", ")", "{", "b", ":=", "buf", ".", "Bytes", "(", ")", "\n\n", "state", ":=", "0", "\n", "btn", ":=", "0", "\n", "x", ":=", "0", "\n", "y", ":=", "0", "\n\n", "for", "i", ":=", "range", "b", "{", "switch", "state", "{", "case", "0", ":", "switch", "b", "[", "i", "]", "{", "case", "'\\x1b'", ":", "state", "=", "1", "\n", "case", "'\\x9b'", ":", "state", "=", "2", "\n", "default", ":", "return", "false", ",", "false", "\n", "}", "\n", "case", "1", ":", "if", "b", "[", "i", "]", "!=", "'['", "{", "return", "false", ",", "false", "\n", "}", "\n", "state", "=", "2", "\n", "case", "2", ":", "if", "b", "[", "i", "]", "!=", "'M'", "{", "return", "false", ",", "false", "\n", "}", "\n", "state", "++", "\n", "case", "3", ":", "btn", "=", "int", "(", "b", "[", "i", "]", ")", "\n", "state", "++", "\n", "case", "4", ":", "x", "=", "int", "(", "b", "[", "i", "]", ")", "-", "32", "-", "1", "\n", "state", "++", "\n", "case", "5", ":", "y", "=", "int", "(", "b", "[", "i", "]", ")", "-", "32", "-", "1", "\n", "for", "i", ">=", "0", "{", "buf", ".", "ReadByte", "(", ")", "\n", "i", "--", "\n", "}", "\n", "t", ".", "postMouseEvent", "(", "x", ",", "y", ",", "btn", ")", "\n", "return", "true", ",", "true", "\n", "}", "\n", "}", "\n", "return", "true", ",", "false", "\n", "}" ]

[ "parseXtermMouse", "is", "like", "parseSgrMouse", "but", "it", "parses", "a", "legacy", "X11", "mouse", "record", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "Resize", "(", ")", "{", "b", ".", "layout", "(", ")", "\n\n", "// Now also let the children know we resized.", "for", "i", ":=", "range", "b", ".", "cells", "{", "b", ".", "cells", "[", "i", "]", ".", "widget", ".", "Resize", "(", ")", "\n", "}", "\n", "b", ".", "PostEventWidgetResize", "(", "b", ")", "\n", "}" ]

[ "Resize", "adjusts", "the", "layout", "when", "the", "underlying", "View", "changes", "size", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "Draw", "(", ")", "{", "if", "b", ".", "view", "==", "nil", "{", "return", "\n", "}", "\n", "if", "b", ".", "changed", "{", "b", ".", "layout", "(", ")", "\n", "}", "\n", "b", ".", "view", ".", "Fill", "(", "' '", ",", "b", ".", "style", ")", "\n", "for", "i", ":=", "range", "b", ".", "cells", "{", "b", ".", "cells", "[", "i", "]", ".", "widget", ".", "Draw", "(", ")", "\n", "}", "\n", "}" ]

[ "Draw", "is", "called", "to", "update", "the", "displayed", "content", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "SetView", "(", "view", "View", ")", "{", "b", ".", "changed", "=", "true", "\n", "b", ".", "view", "=", "view", "\n", "for", "_", ",", "c", ":=", "range", "b", ".", "cells", "{", "c", ".", "view", ".", "SetView", "(", "view", ")", "\n", "}", "\n", "}" ]

[ "SetView", "sets", "the", "View", "object", "used", "for", "the", "text", "bar", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "HandleEvent", "(", "ev", "tcell", ".", "Event", ")", "bool", "{", "switch", "ev", ".", "(", "type", ")", "{", "case", "*", "EventWidgetContent", ":", "// This can only have come from one of our children.", "b", ".", "changed", "=", "true", "\n", "b", ".", "PostEventWidgetContent", "(", "b", ")", "\n", "return", "true", "\n", "}", "\n", "for", "_", ",", "c", ":=", "range", "b", ".", "cells", "{", "if", "c", ".", "widget", ".", "HandleEvent", "(", "ev", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HandleEvent", "implements", "a", "tcell", ".", "EventHandler", ".", "The", "only", "events", "we", "care", "about", "are", "Widget", "change", "events", "from", "our", "children", ".", "We", "watch", "for", "those", "so", "that", "if", "the", "child", "changes", "we", "can", "arrange", "to", "update", "our", "layout", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "AddWidget", "(", "widget", "Widget", ",", "fill", "float64", ")", "{", "c", ":=", "&", "boxLayoutCell", "{", "widget", ":", "widget", ",", "fill", ":", "fill", ",", "view", ":", "NewViewPort", "(", "b", ".", "view", ",", "0", ",", "0", ",", "0", ",", "0", ")", ",", "}", "\n", "widget", ".", "SetView", "(", "c", ".", "view", ")", "\n", "b", ".", "cells", "=", "append", "(", "b", ".", "cells", ",", "c", ")", "\n", "b", ".", "changed", "=", "true", "\n", "widget", ".", "Watch", "(", "b", ")", "\n", "b", ".", "layout", "(", ")", "\n", "b", ".", "PostEventWidgetContent", "(", "b", ")", "\n", "}" ]

[ "AddWidget", "adds", "a", "widget", "to", "the", "end", "of", "the", "BoxLayout", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "InsertWidget", "(", "index", "int", ",", "widget", "Widget", ",", "fill", "float64", ")", "{", "c", ":=", "&", "boxLayoutCell", "{", "widget", ":", "widget", ",", "fill", ":", "fill", ",", "view", ":", "NewViewPort", "(", "b", ".", "view", ",", "0", ",", "0", ",", "0", ",", "0", ")", ",", "}", "\n", "c", ".", "widget", ".", "SetView", "(", "c", ".", "view", ")", "\n", "if", "index", "<", "0", "{", "index", "=", "0", "\n", "}", "\n", "if", "index", ">", "len", "(", "b", ".", "cells", ")", "{", "index", "=", "len", "(", "b", ".", "cells", ")", "\n", "}", "\n", "b", ".", "cells", "=", "append", "(", "b", ".", "cells", ",", "c", ")", "\n", "copy", "(", "b", ".", "cells", "[", "index", "+", "1", ":", "]", ",", "b", ".", "cells", "[", "index", ":", "]", ")", "\n", "b", ".", "cells", "[", "index", "]", "=", "c", "\n", "widget", ".", "Watch", "(", "b", ")", "\n", "b", ".", "layout", "(", ")", "\n", "b", ".", "PostEventWidgetContent", "(", "b", ")", "\n", "}" ]

[ "InsertWidget", "inserts", "a", "widget", "at", "the", "given", "offset", ".", "Offset", "0", "is", "the", "front", ".", "If", "the", "index", "is", "longer", "than", "the", "number", "of", "widgets", "then", "it", "just", "gets", "appended", "to", "the", "end", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "RemoveWidget", "(", "widget", "Widget", ")", "{", "changed", ":=", "false", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "b", ".", "cells", ")", ";", "i", "++", "{", "if", "b", ".", "cells", "[", "i", "]", ".", "widget", "==", "widget", "{", "b", ".", "cells", "=", "append", "(", "b", ".", "cells", "[", ":", "i", "]", ",", "b", ".", "cells", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "changed", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "changed", "{", "return", "\n", "}", "\n", "b", ".", "changed", "=", "true", "\n", "widget", ".", "Unwatch", "(", "b", ")", "\n", "b", ".", "layout", "(", ")", "\n", "b", ".", "PostEventWidgetContent", "(", "b", ")", "\n", "}" ]

[ "RemoveWidget", "removes", "a", "Widget", "from", "the", "layout", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "Widgets", "(", ")", "[", "]", "Widget", "{", "w", ":=", "make", "(", "[", "]", "Widget", ",", "0", ",", "len", "(", "b", ".", "cells", ")", ")", "\n", "for", "_", ",", "c", ":=", "range", "b", ".", "cells", "{", "w", "=", "append", "(", "w", ",", "c", ".", "widget", ")", "\n", "}", "\n", "return", "w", "\n", "}" ]

[ "Widgets", "returns", "the", "list", "of", "Widgets", "for", "this", "BoxLayout", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "SetOrientation", "(", "orient", "Orientation", ")", "{", "if", "b", ".", "orient", "!=", "orient", "{", "b", ".", "orient", "=", "orient", "\n", "b", ".", "changed", "=", "true", "\n", "b", ".", "PostEventWidgetContent", "(", "b", ")", "\n", "}", "\n", "}" ]

[ "SetOrientation", "sets", "the", "orientation", "as", "either", "Horizontal", "or", "Vertical", "." ]

[ "func", "(", "b", "*", "BoxLayout", ")", "SetStyle", "(", "style", "tcell", ".", "Style", ")", "{", "b", ".", "style", "=", "style", "\n", "b", ".", "PostEventWidgetContent", "(", "b", ")", "\n", "}" ]

[ "SetStyle", "sets", "the", "style", "used", "." ]

[ "func", "mod2mask", "(", "cks", "uint32", ")", "ModMask", "{", "mm", ":=", "ModNone", "\n", "// Left or right control", "if", "(", "cks", "&", "(", "0x0008", "|", "0x0004", ")", ")", "!=", "0", "{", "mm", "|=", "ModCtrl", "\n", "}", "\n", "// Left or right alt", "if", "(", "cks", "&", "(", "0x0002", "|", "0x0001", ")", ")", "!=", "0", "{", "mm", "|=", "ModAlt", "\n", "}", "\n", "// Any shift", "if", "(", "cks", "&", "0x0010", ")", "!=", "0", "{", "mm", "|=", "ModShift", "\n", "}", "\n", "return", "mm", "\n", "}" ]

[ "Convert", "windows", "dwControlKeyState", "to", "modifier", "mask" ]

[ "func", "mapColor2RGB", "(", "c", "Color", ")", "uint16", "{", "winLock", ".", "Lock", "(", ")", "\n", "if", "v", ",", "ok", ":=", "winColors", "[", "c", "]", ";", "ok", "{", "c", "=", "v", "\n", "}", "else", "{", "v", "=", "FindColor", "(", "c", ",", "winPalette", ")", "\n", "winColors", "[", "c", "]", "=", "v", "\n", "c", "=", "v", "\n", "}", "\n", "winLock", ".", "Unlock", "(", ")", "\n\n", "if", "vc", ",", "ok", ":=", "vgaColors", "[", "c", "]", ";", "ok", "{", "return", "vc", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "Windows", "uses", "RGB", "signals" ]

[ "func", "(", "s", "*", "cScreen", ")", "mapStyle", "(", "style", "Style", ")", "uint16", "{", "f", ",", "b", ",", "a", ":=", "style", ".", "Decompose", "(", ")", "\n", "fa", ":=", "s", ".", "oscreen", ".", "attrs", "&", "0xf", "\n", "ba", ":=", "(", "s", ".", "oscreen", ".", "attrs", ")", ">>", "4", "&", "0xf", "\n", "if", "f", "!=", "ColorDefault", "{", "fa", "=", "mapColor2RGB", "(", "f", ")", "\n", "}", "\n", "if", "b", "!=", "ColorDefault", "{", "ba", "=", "mapColor2RGB", "(", "b", ")", "\n", "}", "\n", "var", "attr", "uint16", "\n", "// We simulate reverse by doing the color swap ourselves.", "// Apparently windows cannot really do this except in DBCS", "// views.", "if", "a", "&", "AttrReverse", "!=", "0", "{", "attr", "=", "ba", "\n", "attr", "|=", "(", "fa", "<<", "4", ")", "\n", "}", "else", "{", "attr", "=", "fa", "\n", "attr", "|=", "(", "ba", "<<", "4", ")", "\n", "}", "\n", "if", "a", "&", "AttrBold", "!=", "0", "{", "attr", "|=", "0x8", "\n", "}", "\n", "if", "a", "&", "AttrDim", "!=", "0", "{", "attr", "&^=", "0x8", "\n", "}", "\n", "if", "a", "&", "AttrUnderline", "!=", "0", "{", "// Best effort -- doesn't seem to work though.", "attr", "|=", "0x8000", "\n", "}", "\n", "// Blink is unsupported", "return", "attr", "\n", "}" ]

[ "Map", "a", "tcell", "style", "to", "Windows", "attributes" ]

[ "func", "(", "t", "*", "SimpleStyledText", ")", "LookupStyle", "(", "r", "rune", ")", "tcell", ".", "Style", "{", "return", "t", ".", "styles", "[", "r", "]", "\n", "}" ]

[ "LookupStyle", "returns", "the", "style", "registered", "for", "the", "given", "rune", ".", "Returns", "tcell", ".", "StyleDefault", "if", "no", "style", "was", "previously", "registered", "for", "the", "rune", "." ]

[ "func", "NewSimpleStyledText", "(", ")", "*", "SimpleStyledText", "{", "ss", ":=", "&", "SimpleStyledText", "{", "}", "\n", "// Create map and establish default styles.", "ss", ".", "styles", "=", "make", "(", "map", "[", "rune", "]", "tcell", ".", "Style", ")", "\n", "ss", ".", "styles", "[", "'N'", "]", "=", "tcell", ".", "StyleDefault", "\n", "ss", ".", "styles", "[", "'S'", "]", "=", "tcell", ".", "StyleDefault", ".", "Reverse", "(", "true", ")", "\n", "ss", ".", "styles", "[", "'U'", "]", "=", "tcell", ".", "StyleDefault", ".", "Underline", "(", "true", ")", "\n", "ss", ".", "styles", "[", "'B'", "]", "=", "tcell", ".", "StyleDefault", ".", "Bold", "(", "true", ")", "\n", "return", "ss", "\n", "}" ]

[ "NewSimpleStyledText", "creates", "an", "empty", "Text", "." ]

[ "func", "(", "p", "*", "Panel", ")", "Draw", "(", ")", "{", "p", ".", "BoxLayout", ".", "SetOrientation", "(", "Vertical", ")", "\n", "p", ".", "BoxLayout", ".", "Draw", "(", ")", "\n", "}" ]

[ "Draw", "draws", "the", "Panel", "." ]

[ "func", "(", "p", "*", "Panel", ")", "SetTitle", "(", "w", "Widget", ")", "{", "if", "p", ".", "title", "!=", "nil", "{", "p", ".", "RemoveWidget", "(", "p", ".", "title", ")", "\n", "}", "\n", "p", ".", "InsertWidget", "(", "0", ",", "w", ",", "0.0", ")", "\n", "p", ".", "title", "=", "w", "\n", "}" ]

[ "SetTitle", "sets", "the", "Widget", "to", "display", "in", "the", "title", "area", "." ]

[ "func", "(", "p", "*", "Panel", ")", "SetMenu", "(", "w", "Widget", ")", "{", "index", ":=", "0", "\n", "if", "p", ".", "title", "!=", "nil", "{", "index", "++", "\n", "}", "\n", "if", "p", ".", "menu", "!=", "nil", "{", "p", ".", "RemoveWidget", "(", "p", ".", "menu", ")", "\n", "}", "\n", "p", ".", "InsertWidget", "(", "index", ",", "w", ",", "0.0", ")", "\n", "p", ".", "menu", "=", "w", "\n", "}" ]

[ "SetMenu", "sets", "the", "Widget", "to", "display", "in", "the", "menu", "area", "which", "is", "just", "below", "the", "title", "." ]

[ "func", "(", "p", "*", "Panel", ")", "SetContent", "(", "w", "Widget", ")", "{", "index", ":=", "0", "\n", "if", "p", ".", "title", "!=", "nil", "{", "index", "++", "\n", "}", "\n", "if", "p", ".", "menu", "!=", "nil", "{", "index", "++", "\n", "}", "\n", "if", "p", ".", "content", "!=", "nil", "{", "p", ".", "RemoveWidget", "(", "p", ".", "content", ")", "\n", "}", "\n", "p", ".", "InsertWidget", "(", "index", ",", "w", ",", "1.0", ")", "\n", "p", ".", "content", "=", "w", "\n", "}" ]

[ "SetContent", "sets", "the", "Widget", "to", "display", "in", "the", "content", "area", "." ]

[ "func", "(", "p", "*", "Panel", ")", "SetStatus", "(", "w", "Widget", ")", "{", "index", ":=", "0", "\n", "if", "p", ".", "title", "!=", "nil", "{", "index", "++", "\n", "}", "\n", "if", "p", ".", "menu", "!=", "nil", "{", "index", "++", "\n", "}", "\n", "if", "p", ".", "content", "!=", "nil", "{", "index", "++", "\n", "}", "\n", "if", "p", ".", "status", "!=", "nil", "{", "p", ".", "RemoveWidget", "(", "p", ".", "status", ")", "\n", "}", "\n", "p", ".", "InsertWidget", "(", "index", ",", "w", ",", "0.0", ")", "\n", "p", ".", "status", "=", "w", "\n", "}" ]

[ "SetStatus", "sets", "the", "Widget", "to", "display", "in", "the", "status", "area", "which", "is", "at", "the", "bottom", "of", "the", "panel", "." ]

[ "func", "(", "a", "*", "CellView", ")", "Draw", "(", ")", "{", "port", ":=", "a", ".", "port", "\n", "model", ":=", "a", ".", "model", "\n", "port", ".", "Fill", "(", "' '", ",", "a", ".", "style", ")", "\n\n", "if", "a", ".", "view", "==", "nil", "{", "return", "\n", "}", "\n", "if", "model", "==", "nil", "{", "return", "\n", "}", "\n", "vw", ",", "vh", ":=", "a", ".", "view", ".", "Size", "(", ")", "\n", "for", "y", ":=", "0", ";", "y", "<", "vh", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "vw", ";", "x", "++", "{", "a", ".", "view", ".", "SetContent", "(", "x", ",", "y", ",", "' '", ",", "nil", ",", "a", ".", "style", ")", "\n", "}", "\n", "}", "\n\n", "ex", ",", "ey", ":=", "model", ".", "GetBounds", "(", ")", "\n", "vx", ",", "vy", ":=", "port", ".", "Size", "(", ")", "\n", "if", "ex", "<", "vx", "{", "ex", "=", "vx", "\n", "}", "\n", "if", "ey", "<", "vy", "{", "ey", "=", "vy", "\n", "}", "\n\n", "cx", ",", "cy", ",", "en", ",", "sh", ":=", "a", ".", "model", ".", "GetCursor", "(", ")", "\n", "for", "y", ":=", "0", ";", "y", "<", "ey", ";", "y", "++", "{", "for", "x", ":=", "0", ";", "x", "<", "ex", ";", "x", "++", "{", "ch", ",", "style", ",", "comb", ",", "wid", ":=", "model", ".", "GetCell", "(", "x", ",", "y", ")", "\n", "if", "ch", "==", "0", "{", "ch", "=", "' '", "\n", "style", "=", "a", ".", "style", "\n", "}", "\n", "if", "en", "&&", "x", "==", "cx", "&&", "y", "==", "cy", "&&", "sh", "{", "style", "=", "style", ".", "Reverse", "(", "true", ")", "\n", "}", "\n", "port", ".", "SetContent", "(", "x", ",", "y", ",", "ch", ",", "comb", ",", "style", ")", "\n", "x", "+=", "wid", "-", "1", "\n", "}", "\n", "}", "\n", "}" ]

[ "Draw", "draws", "the", "content", "." ]

[ "func", "(", "a", "*", "CellView", ")", "MakeCursorVisible", "(", ")", "{", "if", "a", ".", "model", "==", "nil", "{", "return", "\n", "}", "\n", "x", ",", "y", ",", "enabled", ",", "_", ":=", "a", ".", "model", ".", "GetCursor", "(", ")", "\n", "if", "enabled", "{", "a", ".", "MakeVisible", "(", "x", ",", "y", ")", "\n", "}", "\n", "}" ]

[ "MakeCursorVisible", "ensures", "that", "the", "cursor", "is", "visible", "panning", "the", "ViewPort", "as", "necessary", "if", "the", "cursor", "is", "enabled", "." ]

[ "func", "(", "a", "*", "CellView", ")", "HandleEvent", "(", "e", "tcell", ".", "Event", ")", "bool", "{", "if", "a", ".", "model", "==", "nil", "{", "return", "false", "\n", "}", "\n", "switch", "e", ":=", "e", ".", "(", "type", ")", "{", "case", "*", "tcell", ".", "EventKey", ":", "switch", "e", ".", "Key", "(", ")", "{", "case", "tcell", ".", "KeyUp", ",", "tcell", ".", "KeyCtrlP", ":", "a", ".", "keyUp", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyDown", ",", "tcell", ".", "KeyCtrlN", ":", "a", ".", "keyDown", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyRight", ",", "tcell", ".", "KeyCtrlF", ":", "a", ".", "keyRight", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyLeft", ",", "tcell", ".", "KeyCtrlB", ":", "a", ".", "keyLeft", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyPgDn", ":", "a", ".", "keyPgDn", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyPgUp", ":", "a", ".", "keyPgUp", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyEnd", ":", "a", ".", "keyEnd", "(", ")", "\n", "return", "true", "\n", "case", "tcell", ".", "KeyHome", ":", "a", ".", "keyHome", "(", ")", "\n", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HandleEvent", "handles", "events", ".", "In", "particular", "it", "handles", "certain", "key", "events", "to", "move", "the", "cursor", "or", "pan", "the", "view", "." ]

[ "func", "(", "a", "*", "CellView", ")", "Size", "(", ")", "(", "int", ",", "int", ")", "{", "// We always return a minimum of two rows, and two columns.", "w", ",", "h", ":=", "a", ".", "model", ".", "GetBounds", "(", ")", "\n", "// Clip to a 2x2 minimum square; we can scroll within that.", "if", "w", ">", "2", "{", "w", "=", "2", "\n", "}", "\n", "if", "h", ">", "2", "{", "h", "=", "2", "\n", "}", "\n", "return", "w", ",", "h", "\n", "}" ]

[ "Size", "returns", "the", "content", "size", "based", "on", "the", "model", "." ]

[ "func", "(", "a", "*", "CellView", ")", "SetModel", "(", "model", "CellModel", ")", "{", "w", ",", "h", ":=", "model", ".", "GetBounds", "(", ")", "\n", "model", ".", "SetCursor", "(", "0", ",", "0", ")", "\n", "a", ".", "model", "=", "model", "\n", "a", ".", "port", ".", "SetContentSize", "(", "w", ",", "h", ",", "true", ")", "\n", "a", ".", "port", ".", "ValidateView", "(", ")", "\n", "a", ".", "PostEventWidgetContent", "(", "a", ")", "\n", "}" ]

[ "SetModel", "sets", "the", "model", "for", "this", "CellView", "." ]

[ "func", "(", "a", "*", "CellView", ")", "SetView", "(", "view", "View", ")", "{", "port", ":=", "a", ".", "port", "\n", "port", ".", "SetView", "(", "view", ")", "\n", "a", ".", "view", "=", "view", "\n", "if", "view", "==", "nil", "{", "return", "\n", "}", "\n", "width", ",", "height", ":=", "view", ".", "Size", "(", ")", "\n", "a", ".", "port", ".", "Resize", "(", "0", ",", "0", ",", "width", ",", "height", ")", "\n", "if", "a", ".", "model", "!=", "nil", "{", "w", ",", "h", ":=", "a", ".", "model", ".", "GetBounds", "(", ")", "\n", "a", ".", "port", ".", "SetContentSize", "(", "w", ",", "h", ",", "true", ")", "\n", "}", "\n", "a", ".", "Resize", "(", ")", "\n", "}" ]

[ "SetView", "sets", "the", "View", "context", "." ]

[ "func", "(", "a", "*", "CellView", ")", "Resize", "(", ")", "{", "// We might want to reflow text", "width", ",", "height", ":=", "a", ".", "view", ".", "Size", "(", ")", "\n", "a", ".", "port", ".", "Resize", "(", "0", ",", "0", ",", "width", ",", "height", ")", "\n", "a", ".", "port", ".", "ValidateView", "(", ")", "\n", "a", ".", "MakeCursorVisible", "(", ")", "\n", "}" ]

[ "Resize", "is", "called", "when", "the", "View", "is", "resized", ".", "It", "will", "ensure", "that", "the", "cursor", "is", "visible", "if", "present", "." ]

[ "func", "(", "a", "*", "CellView", ")", "SetCursor", "(", "x", ",", "y", "int", ")", "{", "a", ".", "cursorX", "=", "x", "\n", "a", ".", "cursorY", "=", "y", "\n", "a", ".", "model", ".", "SetCursor", "(", "x", ",", "y", ")", "\n", "}" ]

[ "SetCursor", "sets", "the", "the", "cursor", "position", "." ]

[ "func", "(", "a", "*", "CellView", ")", "SetCursorX", "(", "x", "int", ")", "{", "a", ".", "SetCursor", "(", "x", ",", "a", ".", "cursorY", ")", "\n", "}" ]

[ "SetCursorX", "sets", "the", "the", "cursor", "column", "." ]