internal/action/tab.go

   1 package action
   2
   3 import (
   4         "github.com/zyedidia/micro/internal/buffer"
   5         "github.com/zyedidia/micro/internal/config"
   6         "github.com/zyedidia/micro/internal/display"
   7         "github.com/zyedidia/micro/internal/screen"
   8         "github.com/zyedidia/micro/internal/views"
   9         "github.com/zyedidia/tcell"
  10 )
  11
  12 // The TabList is a list of tabs and a window to display the tab bar
  13 // at the top of the screen
  14 type TabList struct {
  15         *display.TabWindow
  16         List []*Tab
  17 }
  18
  19 // NewTabList creates a TabList from a list of buffers by creating a Tab
  20 // for each buffer
  21 func NewTabList(bufs []*buffer.Buffer) *TabList {
  22         w, h := screen.Screen.Size()
  23         iOffset := config.GetInfoBarOffset()
  24         tl := new(TabList)
  25         tl.List = make([]*Tab, len(bufs))
  26         if len(bufs) > 1 {
  27                 for i, b := range bufs {
  28                         tl.List[i] = NewTabFromBuffer(0, 1, w, h-1-iOffset, b)
  29                 }
  30         } else {
  31                 tl.List[0] = NewTabFromBuffer(0, 0, w, h-iOffset, bufs[0])
  32         }
  33         tl.TabWindow = display.NewTabWindow(w, 0)
  34         tl.Names = make([]string, len(bufs))
  35
  36         return tl
  37 }
  38
  39 // UpdateNames makes sure that the list of names the tab window has access to is
  40 // correct
  41 func (t *TabList) UpdateNames() {
  42         t.Names = t.Names[:0]
  43         for _, p := range t.List {
  44                 t.Names = append(t.Names, p.Panes[p.active].Name())
  45         }
  46 }
  47
  48 // AddTab adds a new tab to this TabList
  49 func (t *TabList) AddTab(p *Tab) {
  50         t.List = append(t.List, p)
  51         t.Resize()
  52         t.UpdateNames()
  53 }
  54
  55 // RemoveTab removes a tab with the given id from the TabList
  56 func (t *TabList) RemoveTab(id uint64) {
  57         for i, p := range t.List {
  58                 if len(p.Panes) == 0 {
  59                         continue
  60                 }
  61                 if p.Panes[0].ID() == id {
  62                         copy(t.List[i:], t.List[i+1:])
  63                         t.List[len(t.List)-1] = nil
  64                         t.List = t.List[:len(t.List)-1]
  65                         if t.Active() >= len(t.List) {
  66                                 t.SetActive(len(t.List) - 1)
  67                         }
  68                         t.Resize()
  69                         t.UpdateNames()
  70                         return
  71                 }
  72         }
  73 }
  74
  75 // Resize resizes all elements within the tab list
  76 // One thing to note is that when there is only 1 tab
  77 // the tab bar should not be drawn so resizing must take
  78 // that into account
  79 func (t *TabList) Resize() {
  80         w, h := screen.Screen.Size()
  81         iOffset := config.GetInfoBarOffset()
  82         InfoBar.Resize(w, h-1)
  83         if len(t.List) > 1 {
  84                 for _, p := range t.List {
  85                         p.Y = 1
  86                         p.Node.Resize(w, h-1-iOffset)
  87                         p.Resize()
  88                 }
  89         } else if len(t.List) == 1 {
  90                 t.List[0].Y = 0
  91                 t.List[0].Node.Resize(w, h-iOffset)
  92                 t.List[0].Resize()
  93         }
  94 }
  95
  96 // HandleEvent checks for a resize event or a mouse event on the tab bar
  97 // otherwise it will forward the event to the currently active tab
  98 func (t *TabList) HandleEvent(event tcell.Event) {
  99         switch e := event.(type) {
 100         case *tcell.EventResize:
 101                 t.Resize()
 102         case *tcell.EventMouse:
 103                 mx, my := e.Position()
 104                 switch e.Buttons() {
 105                 case tcell.Button1:
 106                         if len(t.List) > 1 {
 107                                 ind := t.LocFromVisual(buffer.Loc{mx, my})
 108                                 if ind != -1 {
 109                                         t.SetActive(ind)
 110                                         return
 111                                 }
 112                                 if my == 0 {
 113                                         return
 114                                 }
 115                         }
 116                 case tcell.WheelUp:
 117                         if my == t.Y {
 118                                 t.Scroll(4)
 119                                 return
 120                         }
 121                 case tcell.WheelDown:
 122                         if my == t.Y {
 123                                 t.Scroll(-4)
 124                                 return
 125                         }
 126                 }
 127         }
 128         t.List[t.Active()].HandleEvent(event)
 129 }
 130
 131 // Display updates the names and then displays the tab bar
 132 func (t *TabList) Display() {
 133         t.UpdateNames()
 134         if len(t.List) > 1 {
 135                 t.TabWindow.Display()
 136         }
 137 }
 138
 139 // Tabs is the global tab list
 140 var Tabs *TabList
 141
 142 func InitTabs(bufs []*buffer.Buffer) {
 143         Tabs = NewTabList(bufs)
 144 }
 145
 146 func MainTab() *Tab {
 147         return Tabs.List[Tabs.Active()]
 148 }
 149
 150 // A Tab represents a single tab
 151 // It consists of a list of edit panes (the open buffers),
 152 // a split tree (stored as just the root node), and a uiwindow
 153 // to display the UI elements like the borders between splits
 154 type Tab struct {
 155         *views.Node
 156         *display.UIWindow
 157         Panes  []Pane
 158         active int
 159
 160         resizing *views.Node // node currently being resized
 161 }
 162
 163 // NewTabFromBuffer creates a new tab from the given buffer
 164 func NewTabFromBuffer(x, y, width, height int, b *buffer.Buffer) *Tab {
 165         t := new(Tab)
 166         t.Node = views.NewRoot(x, y, width, height)
 167         t.UIWindow = display.NewUIWindow(t.Node)
 168
 169         e := NewBufPaneFromBuf(b)
 170         e.SetID(t.ID())
 171
 172         t.Panes = append(t.Panes, e)
 173         return t
 174 }
 175
 176 func NewTabFromPane(x, y, width, height int, pane Pane) *Tab {
 177         t := new(Tab)
 178         t.Node = views.NewRoot(x, y, width, height)
 179         t.UIWindow = display.NewUIWindow(t.Node)
 180
 181         pane.SetID(t.ID())
 182
 183         t.Panes = append(t.Panes, pane)
 184         return t
 185 }
 186
 187 // HandleEvent takes a tcell event and usually dispatches it to the current
 188 // active pane. However if the event is a resize or a mouse event where the user
 189 // is interacting with the UI (resizing splits) then the event is consumed here
 190 // If the event is a mouse event in a pane, that pane will become active and get
 191 // the event
 192 func (t *Tab) HandleEvent(event tcell.Event) {
 193         switch e := event.(type) {
 194         case *tcell.EventMouse:
 195                 mx, my := e.Position()
 196                 switch e.Buttons() {
 197                 case tcell.Button1:
 198                         resizeID := t.GetMouseSplitID(buffer.Loc{mx, my})
 199                         if t.resizing != nil {
 200                                 var size int
 201                                 if t.resizing.Kind == views.STVert {
 202                                         size = mx - t.resizing.X
 203                                 } else {
 204                                         size = my - t.resizing.Y + 1
 205                                 }
 206                                 t.resizing.ResizeSplit(size)
 207                                 t.Resize()
 208                                 return
 209                         }
 210
 211                         if resizeID != 0 {
 212                                 t.resizing = t.GetNode(uint64(resizeID))
 213                                 return
 214                         }
 215
 216                         for i, p := range t.Panes {
 217                                 v := p.GetView()
 218                                 inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
 219                                 if inpane {
 220                                         t.SetActive(i)
 221                                         break
 222                                 }
 223                         }
 224                 case tcell.ButtonNone:
 225                         t.resizing = nil
 226                 default:
 227                         for _, p := range t.Panes {
 228                                 v := p.GetView()
 229                                 inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
 230                                 if inpane {
 231                                         p.HandleEvent(event)
 232                                         return
 233                                 }
 234                         }
 235                 }
 236
 237         }
 238         t.Panes[t.active].HandleEvent(event)
 239 }
 240
 241 // SetActive changes the currently active pane to the specified index
 242 func (t *Tab) SetActive(i int) {
 243         t.active = i
 244         for j, p := range t.Panes {
 245                 if j == i {
 246                         p.SetActive(true)
 247                 } else {
 248                         p.SetActive(false)
 249                 }
 250         }
 251 }
 252
 253 // GetPane returns the pane with the given split index
 254 func (t *Tab) GetPane(splitid uint64) int {
 255         for i, p := range t.Panes {
 256                 if p.ID() == splitid {
 257                         return i
 258                 }
 259         }
 260         return 0
 261 }
 262
 263 // Remove pane removes the pane with the given index
 264 func (t *Tab) RemovePane(i int) {
 265         copy(t.Panes[i:], t.Panes[i+1:])
 266         t.Panes[len(t.Panes)-1] = nil
 267         t.Panes = t.Panes[:len(t.Panes)-1]
 268 }
 269
 270 // Resize resizes all panes according to their corresponding split nodes
 271 func (t *Tab) Resize() {
 272         for _, p := range t.Panes {
 273                 n := t.GetNode(p.ID())
 274                 pv := p.GetView()
 275                 offset := 0
 276                 if n.X != 0 {
 277                         offset = 1
 278                 }
 279                 pv.X, pv.Y = n.X+offset, n.Y
 280                 p.SetView(pv)
 281                 p.Resize(n.W-offset, n.H)
 282         }
 283 }
 284
 285 // CurPane returns the currently active pane
 286 func (t *Tab) CurPane() Pane {
 287         return t.Panes[t.active]
 288 }