package tview

import (

"math"

"github.com/gdamore/tcell"

)

// gridItem represents one primitive and its possible position on a grid.

type gridItem struct {

}

// Grid is an implementation of a grid-based layout. It works by defining the

// size of the rows and columns, then placing primitives into the grid.

//

// Some settings can lead to the grid exceeding its available space. SetOffset()

// can then be used to scroll in steps of rows and columns. These offset values

// can also be controlled with the arrow keys (or the "g","G", "j", "k", "h",

// and "l" keys) while the grid has focus and none of its contained primitives

// do.

//

// See https://github.com/rivo/tview/wiki/Grid for an example.

type Grid struct {

}

// NewGrid returns a new grid-based layout container with no initial primitives.

//

// Note that Box, the superclass of Grid, will have its background color set to

// transparent so that any grid areas not covered by any primitives will leave

// their background unchanged. To clear a Grid's background before any items are

// drawn, set it to the desired color:

//

// grid.SetBackgroundColor(tview.Styles.PrimitiveBackgroundColor)

func NewGrid() *Grid {

}

// SetColumns defines how the columns of the grid are distributed. Each value

// defines the size of one column, starting with the leftmost column. Values

// greater 0 represent absolute column widths (gaps not included). Values less

// or equal 0 represent proportional column widths or fractions of the remaining

// free space, where 0 is treated the same as -1. That is, a column with a value

// of -3 will have three times the width of a column with a value of -1 (or 0).

// The minimum width set with SetMinSize() is always observed.

//

// Primitives may extend beyond the columns defined explicitly with this

// function. A value of 0 is assumed for any undefined column. In fact, if you

// never call this function, all columns occupied by primitives will have the

// same width. On the other hand, unoccupied columns defined with this function

// will always take their place.

//

// Assuming a total width of the grid of 100 cells and a minimum width of 0, the

// following call will result in columns with widths of 30, 10, 15, 15, and 30

// cells:

//

// grid.Setcolumns(30, 10, -1, -1, -2)

//

// If a primitive were then placed in the 6th and 7th column, the resulting

// widths would be: 30, 10, 10, 10, 20, 10, and 10 cells.

//

// If you then called SetMinSize() as follows:

//

// grid.SetMinSize(15, 20)

//

// The resulting widths would be: 30, 15, 15, 15, 20, 15, and 15 cells, a total

// of 125 cells, 25 cells wider than the available grid width.

func (g *Grid) SetColumns(columns ...int) *Grid {

g.columns = columns

return g

}

// SetRows defines how the rows of the grid are distributed. These values behave

// the same as the column values provided with SetColumns(), see there for a

// definition and examples.

//

// The provided values correspond to row heights, the first value defining

// the height of the topmost row.

func (g *Grid) SetRows(rows ...int) *Grid {

g.rows = rows

return g

}

// SetSize is a shortcut for SetRows() and SetColumns() where all row and column

// values are set to the given size values. See SetColumns() for details on sizes.

func (g *Grid) SetSize(numRows, numColumns, rowSize, columnSize int) *Grid {

}

// SetMinSize sets an absolute minimum width for rows and an absolute minimum

// height for columns. Panics if negative values are provided.

func (g *Grid) SetMinSize(row, column int) *Grid {

}

// SetGap sets the size of the gaps between neighboring primitives on the grid.

// If borders are drawn (see SetBorders()), these values are ignored and a gap

// of 1 is assumed. Panics if negative values are provided.

func (g *Grid) SetGap(row, column int) *Grid {

}

// SetBorders sets whether or not borders are drawn around grid items. Setting

// this value to true will cause the gap values (see SetGap()) to be ignored and

// automatically assumed to be 1 where the border graphics are drawn.

func (g *Grid) SetBorders(borders bool) *Grid {

g.borders = borders

return g

}

// SetBordersColor sets the color of the item borders.

func (g *Grid) SetBordersColor(color tcell.Color) *Grid {

g.bordersColor = color

return g

}

// AddItem adds a primitive and its position to the grid. The top-left corner

// of the primitive will be located in the top-left corner of the grid cell at

// the given row and column and will span "rowSpan" rows and "colSpan" columns.

// For example, for a primitive to occupy rows 2, 3, and 4 and columns 5 and 6:

//

// grid.AddItem(p, 2, 5, 3, 2, 0, 0, true)

//

// If rowSpan or colSpan is 0, the primitive will not be drawn.

//

// You can add the same primitive multiple times with different grid positions.

// The minGridWidth and minGridHeight values will then determine which of those

// positions will be used. This is similar to CSS media queries. These minimum

// values refer to the overall size of the grid. If multiple items for the same

// primitive apply, the one that has at least one highest minimum value will be

// used, or the primitive added last if those values are the same. Example:

//

// grid.AddItem(p, 0, 0, 0, 0, 0, 0, true). // Hide in small grids.

// AddItem(p, 0, 0, 1, 2, 100, 0, true). // One-column layout for medium grids.

// AddItem(p, 1, 1, 3, 2, 300, 0, true) // Multi-column layout for large grids.

//

// To use the same grid layout for all sizes, simply set minGridWidth and

// minGridHeight to 0.

//

// If the item's focus is set to true, it will receive focus when the grid

// receives focus. If there are multiple items with a true focus flag, the last

// visible one that was added will receive focus.

func (g *Grid) AddItem(p Primitive, row, column, rowSpan, colSpan, minGridHeight, minGridWidth int, focus bool) *Grid {

}

// RemoveItem removes all items for the given primitive from the grid, keeping

// the order of the remaining items intact.

func (g *Grid) RemoveItem(p Primitive) *Grid {

}

// Clear removes all items from the grid.

func (g *Grid) Clear() *Grid {

g.items = nil

return g

}

// SetOffset sets the number of rows and columns which are skipped before

// drawing the first grid cell in the top-left corner. As the grid will never

// completely move off the screen, these values may be adjusted the next time

// the grid is drawn. The actual position of the grid may also be adjusted such

// that contained primitives that have focus remain visible.

func (g *Grid) SetOffset(rows, columns int) *Grid {

g.rowOffset, g.columnOffset = rows, columns

return g

}

// GetOffset returns the current row and column offset (see SetOffset() for

// details).

func (g *Grid) GetOffset() (rows, columns int) {

return g.rowOffset, g.columnOffset

}

// Focus is called when this primitive receives focus.

func (g *Grid) Focus(delegate func(p Primitive)) {

}

// Blur is called when this primitive loses focus.

func (g *Grid) Blur() {

g.hasFocus = false

}

// HasFocus returns whether or not this primitive has focus.

func (g *Grid) HasFocus() bool {

}

// InputHandler returns the handler for this primitive.

func (g *Grid) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive)) {

}

// Draw draws this primitive onto the screen.

func (g *Grid) Draw(screen tcell.Screen) {

}

// MouseHandler returns the mouse handler for this primitive.

func (g *Grid) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive) {

}