cmd/micro/tab.go

   1 package main
   2
   3 import (
   4         "sort"
   5
   6         "github.com/zyedidia/tcell"
   7 )
   8
   9 var tabBarOffset int
  10
  11 type Tab struct {
  12         // This contains all the views in this tab
  13         // There is generally only one view per tab, but you can have
  14         // multiple views with splits
  15         views []*View
  16         // This is the current view for this tab
  17         CurView int
  18
  19         tree *SplitTree
  20 }
  21
  22 // NewTabFromView creates a new tab and puts the given view in the tab
  23 func NewTabFromView(v *View) *Tab {
  24         t := new(Tab)
  25         t.views = append(t.views, v)
  26         t.views[0].Num = 0
  27
  28         t.tree = new(SplitTree)
  29         t.tree.kind = VerticalSplit
  30         t.tree.children = []Node{NewLeafNode(t.views[0], t.tree)}
  31
  32         w, h := screen.Size()
  33         t.tree.width = w
  34         t.tree.height = h
  35
  36         if globalSettings["infobar"].(bool) {
  37                 t.tree.height--
  38         }
  39
  40         t.Resize()
  41
  42         return t
  43 }
  44
  45 // SetNum sets all this tab's views to have the correct tab number
  46 func (t *Tab) SetNum(num int) {
  47         t.tree.tabNum = num
  48         for _, v := range t.views {
  49                 v.TabNum = num
  50         }
  51 }
  52
  53 func (t *Tab) Cleanup() {
  54         t.tree.Cleanup()
  55 }
  56
  57 func (t *Tab) Resize() {
  58         w, h := screen.Size()
  59         t.tree.width = w
  60         t.tree.height = h
  61
  62         if globalSettings["infobar"].(bool) {
  63                 t.tree.height--
  64         }
  65
  66         t.tree.ResizeSplits()
  67
  68         for i, v := range t.views {
  69                 v.Num = i
  70         }
  71 }
  72
  73 // CurView returns the current view
  74 func CurView() *View {
  75         curTab := tabs[curTab]
  76         return curTab.views[curTab.CurView]
  77 }
  78
  79 // TabbarString returns the string that should be displayed in the tabbar
  80 // It also returns a map containing which indicies correspond to which tab number
  81 // This is useful when we know that the mouse click has occurred at an x location
  82 // but need to know which tab that corresponds to to accurately change the tab
  83 func TabbarString() (string, map[int]int) {
  84         str := ""
  85         indicies := make(map[int]int)
  86         for i, t := range tabs {
  87                 if i == curTab {
  88                         str += "["
  89                 } else {
  90                         str += " "
  91                 }
  92                 str += t.views[t.CurView].Buf.GetName()
  93                 if i == curTab {
  94                         str += "]"
  95                 } else {
  96                         str += " "
  97                 }
  98                 indicies[len(str)-1] = i + 1
  99                 str += " "
 100         }
 101         return str, indicies
 102 }
 103
 104 // TabbarHandleMouseEvent checks the given mouse event if it is clicking on the tabbar
 105 // If it is it changes the current tab accordingly
 106 // This function returns true if the tab is changed
 107 func TabbarHandleMouseEvent(event tcell.Event) bool {
 108         // There is no tabbar displayed if there are less than 2 tabs
 109         if len(tabs) <= 1 {
 110                 return false
 111         }
 112
 113         switch e := event.(type) {
 114         case *tcell.EventMouse:
 115                 button := e.Buttons()
 116                 // Must be a left click
 117                 if button == tcell.Button1 {
 118                         x, y := e.Position()
 119                         if y != 0 {
 120                                 return false
 121                         }
 122                         str, indicies := TabbarString()
 123                         if x+tabBarOffset >= len(str) {
 124                                 return false
 125                         }
 126                         var tabnum int
 127                         var keys []int
 128                         for k := range indicies {
 129                                 keys = append(keys, k)
 130                         }
 131                         sort.Ints(keys)
 132                         for _, k := range keys {
 133                                 if x+tabBarOffset <= k {
 134                                         tabnum = indicies[k] - 1
 135                                         break
 136                                 }
 137                         }
 138                         curTab = tabnum
 139                         return true
 140                 }
 141         }
 142
 143         return false
 144 }
 145
 146 // DisplayTabs displays the tabbar at the top of the editor if there are multiple tabs
 147 func DisplayTabs() {
 148         if len(tabs) <= 1 {
 149                 return
 150         }
 151
 152         str, indicies := TabbarString()
 153
 154         tabBarStyle := defStyle.Reverse(true)
 155         if style, ok := colorscheme["tabbar"]; ok {
 156                 tabBarStyle = style
 157         }
 158
 159         // Maybe there is a unicode filename?
 160         fileRunes := []rune(str)
 161         w, _ := screen.Size()
 162         tooWide := (w < len(fileRunes))
 163
 164         // if the entire tab-bar is longer than the screen is wide,
 165         // then it should be truncated appropriately to keep the
 166         // active tab visible on the UI.
 167         if tooWide == true {
 168                 // first we have to work out where the selected tab is
 169                 // out of the total length of the tab bar. this is done
 170                 // by extracting the hit-areas from the indicies map
 171                 // that was constructed by `TabbarString()`
 172                 var keys []int
 173                 for offset := range indicies {
 174                         keys = append(keys, offset)
 175                 }
 176                 // sort them to be in ascending order so that values will
 177                 // correctly reflect the displayed ordering of the tabs
 178                 sort.Ints(keys)
 179                 // record the offset of each tab and the previous tab so
 180                 // we can find the position of the tab's hit-box.
 181                 previousTabOffset := 0
 182                 currentTabOffset := 0
 183                 for _, k := range keys {
 184                         tabIndex := indicies[k] - 1
 185                         if tabIndex == curTab {
 186                                 currentTabOffset = k
 187                                 break
 188                         }
 189                         // this is +2 because there are two padding spaces that aren't accounted
 190                         // for in the display. please note that this is for cosmetic purposes only.
 191                         previousTabOffset = k + 2
 192                 }
 193                 // get the width of the hitbox of the active tab, from there calculate the offsets
 194                 // to the left and right of it to approximately center it on the tab bar display.
 195                 centeringOffset := (w - (currentTabOffset - previousTabOffset))
 196                 leftBuffer := previousTabOffset - (centeringOffset / 2)
 197                 rightBuffer := currentTabOffset + (centeringOffset / 2)
 198
 199                 // check to make sure we haven't overshot the bounds of the string,
 200                 // if we have, then take that remainder and put it on the left side
 201                 overshotRight := rightBuffer - len(fileRunes)
 202                 if overshotRight > 0 {
 203                         leftBuffer = leftBuffer + overshotRight
 204                 }
 205
 206                 overshotLeft := leftBuffer - 0
 207                 if overshotLeft < 0 {
 208                         leftBuffer = 0
 209                         rightBuffer = leftBuffer + (w - 1)
 210                 } else {
 211                         rightBuffer = leftBuffer + (w - 2)
 212                 }
 213
 214                 if rightBuffer > len(fileRunes)-1 {
 215                         rightBuffer = len(fileRunes) - 1
 216                 }
 217
 218                 // construct a new buffer of text to put the
 219                 // newly formatted tab bar text into.
 220                 var displayText []rune
 221
 222                 // if the left-side of the tab bar isn't at the start
 223                 // of the constructed tab bar text, then show that are
 224                 // more tabs to the left by displaying a "+"
 225                 if leftBuffer != 0 {
 226                         displayText = append(displayText, '+')
 227                 }
 228                 // copy the runes in from the original tab bar text string
 229                 // into the new display buffer
 230                 for x := leftBuffer; x < rightBuffer; x++ {
 231                         displayText = append(displayText, fileRunes[x])
 232                 }
 233                 // if there is more text to the right of the right-most
 234                 // column in the tab bar text, then indicate there are more
 235                 // tabs to the right by displaying a "+"
 236                 if rightBuffer < len(fileRunes)-1 {
 237                         displayText = append(displayText, '+')
 238                 }
 239
 240                 // now store the offset from zero of the left-most text
 241                 // that is being displayed. This is to ensure that when
 242                 // clicking on the tab bar, the correct tab gets selected.
 243                 tabBarOffset = leftBuffer
 244
 245                 // use the constructed buffer as the display buffer to print
 246                 // onscreen.
 247                 fileRunes = displayText
 248         } else {
 249                 tabBarOffset = 0
 250         }
 251
 252         // iterate over the width of the terminal display and for each column,
 253         // write a character into the tab display area with the appropriate style.
 254         for x := 0; x < w; x++ {
 255                 if x < len(fileRunes) {
 256                         screen.SetContent(x, 0, fileRunes[x], nil, tabBarStyle)
 257                 } else {
 258                         screen.SetContent(x, 0, ' ', nil, tabBarStyle)
 259                 }
 260         }
 261 }