github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/GUI/lists/lists.go

package lists

import (
	"fmt"
	"sort"

	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"

	"github.com/benoitkugler/goACVE/client/GUI/basic"
	"github.com/therecipe/qt/core"
	"github.com/therecipe/qt/gui"
	"github.com/therecipe/qt/widgets"
)

const debounceDelay = 200 // ms

// Liste est le widget top-level contenant une liste,
// une ligne de titre, et un bouton d'ajout.
// Attention à bien appeler `Init` !
type Liste struct {
	*widgets.QFrame

	model       model
	View        view
	labelTitle  *widgets.QLabel
	searchField *widgets.QLineEdit // nil if OnSearch is nil

	Headers          []rd.Header
	Title            string
	HighlightOnHover bool
	SingleSelection  bool
	Placeholder      string
	MinHeight        int
	MinWidth         int
	MaxWidth         int

	// Callback d'ajout d'un élément, déclenché par le bouton nouveau.
	OnAdd func()

	// index est valide uniquement pour une Table (ambigu pour un Tree)
	OnClick func(acces rd.Item, index int)

	OnDoubleClick func(acces rd.Item, index int)

	OnRightClick func(acces rd.Item, pos *core.QPoint)

	// Callback déclenché par le tri.
	OnSort func(field rd.Field, reverse bool)

	// Callback déclenché sur recherche de l'utilisateur
	OnSearch func(pattern string)

	// Valide seulement pour une Table
	OnDelete func(acces rd.Item, index int)

	// Widgets supplémentaires en haut à droite
	RightHeader *widgets.QHBoxLayout
}

type Table struct {
	Liste

	HideHeaders      bool
	ResizeToContents bool
}

type Tree struct {
	Liste

	FoldButton *widgets.QPushButton
}

type view interface {
	widgets.QWidget_ITF

	SetObjectName(string)
	SetModel(model core.QAbstractItemModel_ITF)
	Model() *core.QAbstractItemModel
	SetSortingEnabled(bool)
	SetAlternatingRowColors(bool)
	SetItemDelegate(itf widgets.QAbstractItemDelegate_ITF)

	SetMouseTracking(bool)
	SetProperty(string, core.QVariant_ITF) bool

	SetSelectionBehavior(behavior widgets.QAbstractItemView__SelectionBehavior)
	SetSelectionMode(mode widgets.QAbstractItemView__SelectionMode)

	SetSizeAdjustPolicy(policy widgets.QAbstractScrollArea__SizeAdjustPolicy)
	SetSizePolicy2(widgets.QSizePolicy__Policy, widgets.QSizePolicy__Policy)
	SetMinimumHeight(int)
	SetMinimumWidth(int)
	SetMaximumWidth(int)
	SetColumnWidth(int, int)

	ConnectPaintEvent(f func(event *gui.QPaintEvent))
	PaintEventDefault(event gui.QPaintEvent_ITF)
	Viewport() *widgets.QWidget
	Rect() *core.QRect
	ScrollTo(index core.QModelIndex_ITF, hint widgets.QAbstractItemView__ScrollHint)

	ConnectActivated(f func(index *core.QModelIndex))
	ConnectPressed(f func(index *core.QModelIndex))
	ConnectDoubleClicked(f func(index *core.QModelIndex))

	SetContextMenuPolicy(policy core.Qt__ContextMenuPolicy)
	ConnectCustomContextMenuRequested(f func(point *core.QPoint))
	IndexAt(point core.QPoint_ITF) *core.QModelIndex

	ClearSelection()
	SelectionModel() *core.QItemSelectionModel
	CurrentIndex() *core.QModelIndex
	SelectedIndexes() []*core.QModelIndex

	ConnectKeyPressEvent(f func(event *gui.QKeyEvent))
	KeyPressEventDefault(event gui.QKeyEvent_ITF)
}

type model interface {
	core.QAbstractItemModel_ITF

	Index(int, int, core.QModelIndex_ITF) *core.QModelIndex

	//remove(section int)
	dataAt(index *core.QModelIndex) (rd.Item, bool)

	getHeaders() []rd.Header
	BeginResetModel()
	EndResetModel()
	ConnectColumnCount(f func(index *core.QModelIndex) int)

	ConnectSort(f func(section int, reverse core.Qt__SortOrder))

	ConnectModelReset(func())
	ConnectRowsRemoved(func(parent *core.QModelIndex, first int, last int))
}

// DefaultSort tri les données présentes et remplace les données du model
func DefaultSort(liste Table, field rd.Field, reverse bool) {
	data := liste.Model().GetData()
	dm.SortBy(data, field, reverse)
	liste.Model().SetData(data)
}

func (l *Liste) init(_view view, _model model) {
	l.model = _model
	l.View = _view

	l.model.ConnectColumnCount(func(index *core.QModelIndex) int {
		return len(l.model.getHeaders())
	})

	l.View.SetSortingEnabled(true)
	if l.OnSort != nil { // on transmet le field et l'ordre
		l.model.ConnectSort(func(section int, reverse core.Qt__SortOrder) {
			l.OnSort(l.model.getHeaders()[section].Field, reverse == 0)
		})
	}

	l.QFrame = basic.Frame()
	l.QFrame.SetLayout(widgets.NewQVBoxLayout())
	l.QFrame.Layout().SetSpacing(1)
	l.QFrame.Layout().SetContentsMargins(0, 0, 0, 0)

	l.View.SetObjectName("liste")
	l.View.SetModel(l.model)
	l.View.SetAlternatingRowColors(true)
	l.View.SetSizeAdjustPolicy(widgets.QAbstractScrollArea__AdjustToContentsOnFirstShow) // overided in table
	l.View.SetSizePolicy2(widgets.QSizePolicy__Expanding, widgets.QSizePolicy__Expanding)
	l.View.SetMinimumHeight(l.MinHeight)
	l.View.SetMinimumWidth(l.MinWidth)
	if l.MaxWidth > 0 {
		l.View.SetMaximumWidth(l.MaxWidth)
	}

	l.View.ConnectPaintEvent(func(event *gui.QPaintEvent) {
		l.View.PaintEventDefault(event)
		drawPlaceholder(l.View, l.Placeholder)
	})

	if l.HighlightOnHover {
		l.View.SetMouseTracking(true)
		l.View.SetProperty("highlight", core.NewQVariant9(true))
	}

	l.View.SetSelectionBehavior(widgets.QAbstractItemView__SelectRows)
	if l.SingleSelection {
		l.View.SetSelectionMode(widgets.QAbstractItemView__SingleSelection)
	}

	if l.Title != "" || l.OnSearch != nil || l.RightHeader != nil {
		l.QFrame.SetObjectName("cadre")

		headerF := basic.Frame()
		header := widgets.NewQHBoxLayout2(headerF)
		header.SetContentsMargins(0, 0, 0, 3)
		header.SetSpacing(1)
		l.QFrame.Layout().SetContentsMargins(5, 8, 5, 5)
		if l.Title != "" {
			l.labelTitle = basic.Label(l.Title)
			header.AddWidget(l.labelTitle, 0, 0)
		}

		l.setupOnSearch(header)

		if l.RightHeader != nil {
			header.AddStretch(2)
			header.AddLayout(l.RightHeader, 0)
		}
		l.QFrame.Layout().AddWidget(headerF)
	}

	l.QFrame.Layout().AddWidget(l.View)

	if l.OnAdd != nil {
		newButton := basic.Button("Ajouter")
		newButton.SetObjectName(basic.ONAdd)
		newButton.ConnectClicked(func(_ bool) { l.OnAdd() })
		l.QFrame.Layout().AddWidget(newButton)
	}

	if l.OnClick != nil {
		l.View.ConnectPressed(func(current *core.QModelIndex) {
			if item, ok := l.model.dataAt(current); ok {
				l.OnClick(item, current.Row())
			}
		})
	}

	if l.OnDoubleClick != nil {
		l.View.ConnectDoubleClicked(func(index *core.QModelIndex) {
			if item, ok := l.model.dataAt(index); ok {
				l.OnDoubleClick(item, index.Row())
			}
		})
	}

	if l.OnRightClick != nil {
		l.View.SetContextMenuPolicy(core.Qt__CustomContextMenu)
		l.View.ConnectCustomContextMenuRequested(func(point *core.QPoint) {
			index := l.View.IndexAt(point)
			if item, ok := l.model.dataAt(index); ok {
				l.OnRightClick(item, point)
			}
		})
	}

	l.ConnectDataChanged(l.updateTitle)
	l.updateTitle()
}

func debounce(field *widgets.QLineEdit, callback func(text string)) {
	timer := core.NewQTimer(nil)
	timer.SetSingleShot(true)

	var finalText string

	// quand l'utilisateur arrête de tapper on déclenche
	// l'action avec le texte accumulé
	timer.ConnectTimeout(func() {
		callback(finalText)
	})

	// quand l'utilisateur tape, on stocke le texte et
	// on remet à zéro le Timer
	field.ConnectTextEdited(func(text string) {
		finalText = text
		timer.Start(debounceDelay)
	})
}

func (l *Liste) setupOnSearch(header *widgets.QHBoxLayout) {
	if l.OnSearch == nil {
		return
	}

	l.searchField = widgets.NewQLineEdit(nil)
	l.searchField.SetMaximumWidth(400)
	l.searchField.SetPlaceholderText("Rechercher...")

	// debounce pour éviter des ralentissements sur les grosses listes
	debounce(l.searchField, l.OnSearch)

	cancel := widgets.NewQToolButton(nil)
	cancel.SetIcon(basic.Icons.Delete)
	cancel.ConnectClicked(func(_ bool) {
		l.OnSearch("")
		l.SetSearch("")
		l.searchField.SetFocus2()
	})
	header.AddWidget(l.searchField, 1, 0)
	header.AddWidget(cancel, 0, core.Qt__AlignLeft)
}

// SetSearch met à jour le champ de recherche, SANS
// déclencher la fonction de recherche
func (l *Liste) SetSearch(text string) {
	if l.searchField == nil {
		return
	}
	l.searchField.SetText(text)
}

func (l *Liste) ConnectDataChanged(f func()) {
	l.model.ConnectModelReset(f)
	l.model.ConnectRowsRemoved(func(_ *core.QModelIndex, _ int, _ int) { f() })
}

func (l *Liste) updateTitle() {
	if l.labelTitle == nil {
		return
	}
	nb := l.View.Model().RowCount(core.NewQModelIndex())
	l.labelTitle.SetText(fmt.Sprintf("<b>%s</b> <i>(%d)</i>", l.Title, nb))
}

func (l *Liste) Selection() rd.Ids {
	indexes := l.View.SelectedIndexes()
	ids := make(rd.Set, len(indexes))
	for _, index := range indexes {
		if item, ok := l.model.dataAt(index); ok {
			ids.Add(item.Id.Int64())
		}
	}
	out := ids.Keys()
	sort.Slice(out, func(i, j int) bool { // déterminisme
		return out[i] < out[j]
	})
	return out
}

func (l *Liste) ShowContextMenu(menu *widgets.QMenu, pos *core.QPoint) {
	menu.Exec2(l.View.QWidget_PTR().MapToGlobal(pos), nil)
}

func drawPlaceholder(view view, placeholder string) {
	if view.Model().RowCount(core.NewQModelIndex()) == 0 {
		painter := gui.NewQPainter2(view.Viewport())
		painter.SetFont(basic.ItalicFont)
		painter.DrawText4(view.Rect().Adjusted(0, 0, -5, -5), int(core.Qt__AlignCenter)|int(core.Qt__TextWordWrap), placeholder, nil)
		painter.DestroyQPainter()
	}
}

func (t *Table) Init() {
	view := widgets.NewQTableView(nil)
	model := newTableModel()
	model.headers = t.Headers
	t.init(view, model)

	view.VerticalHeader().SetVisible(t.OnDelete != nil)
	view.VerticalHeader().ConnectSectionClicked(func(logicalIndex int) {
		sourceIndex := t.model.Index(logicalIndex, 0, core.NewQModelIndex())
		if item, ok := t.model.dataAt(sourceIndex); ok {
			t.OnDelete(item, sourceIndex.Row())
		}
	})

	view.HorizontalHeader().SetStretchLastSection(true)
	view.HorizontalHeader().SetVisible(!t.HideHeaders)
	if t.ResizeToContents {
		view.HorizontalHeader().SetSectionResizeMode(widgets.QHeaderView__ResizeToContents)
		view.SetSizeAdjustPolicy(widgets.QAbstractScrollArea__AdjustToContents)
		view.VerticalHeader().SetSectionResizeMode(widgets.QHeaderView__ResizeToContents)
	}
}

func (t *Tree) Init() {
	view := widgets.NewQTreeView(nil)
	view.SetUniformRowHeights(true)
	model := NewTreeModel(nil)
	model.headers = t.Headers
	t.SingleSelection = true

	if t.RightHeader == nil {
		t.RightHeader = widgets.NewQHBoxLayout()
	}
	t.FoldButton = basic.Button("Déplier")
	t.FoldButton.SetCheckable(true)
	t.RightHeader.AddWidget(t.FoldButton, 0, 0)
	view.Header().SetStretchLastSection(true)
	t.init(view, model)
}

func (t *Tree) Fold(fold bool) {
	if fold {
		t.View.(*widgets.QTreeView).ExpandAll()
		t.FoldButton.SetText("Replier")
	} else {
		t.View.(*widgets.QTreeView).CollapseAll()
		t.FoldButton.SetText("Déplier")
	}
}

func selectIndex(view view, index *core.QModelIndex) {
	view.SelectionModel().Select(index, core.QItemSelectionModel__Rows|core.QItemSelectionModel__Select)
	view.ScrollTo(index, widgets.QAbstractItemView__EnsureVisible)
}

func (t *Table) SelectRow(id rd.IId) {
	for i, v := range t.Model().GetData() {
		if v.Id == id {
			index := t.model.Index(i, 0, core.NewQModelIndex())
			selectIndex(t.View, index)
		}
	}
}

func (t *Tree) SelectRow(id rd.IId) {
	t.View.ClearSelection()
	model := t.Model()
	for rowParent, v := range model.GetData() {
		parentIndex := model.index(rowParent, 0, core.NewQModelIndex())
		if v.Id == id { // selection du parent
			selectIndex(t.View, parentIndex)
			return
		} else { // parcourt des enfants
			for rowEnfant, e := range v.Childs {
				if e.Id == id {
					enfantIndex := model.index(rowEnfant, 0, parentIndex)
					selectIndex(t.View, enfantIndex)
					t.View.(*widgets.QTreeView).Expand(parentIndex)
					return
				}
			}
		}
	}
}

func (t *Table) HorizontalHeader() *widgets.QHeaderView {
	return t.View.(*widgets.QTableView).HorizontalHeader()
}

func (t *Tree) HorizontalHeader() *widgets.QHeaderView {
	return t.View.(*widgets.QTreeView).Header()
}

func (l *Liste) CurrentData() (rd.Item, bool) {
	return l.model.dataAt(l.View.CurrentIndex())
}

func (t *Table) Model() *TableModel {
	return t.model.(*TableModel)
}

func (t *Tree) Model() *TreeModel {
	return t.model.(*TreeModel)
}

// ------------------------------ Models ------------------------------

func _headerData(section int, orientation core.Qt__Orientation, role int, headers []rd.Header) *core.QVariant {
	switch orientation {
	case core.Qt__Vertical:
		switch role {
		case int(core.Qt__DecorationRole):
			return basic.Icons.Delete.ToVariant()
		case int(core.Qt__ToolTipRole):
			return core.NewQVariant15("Supprimer")
		}
	case core.Qt__Horizontal:
		switch role {
		case int(core.Qt__DisplayRole):
			return core.NewQVariant15(headers[section].Label)
		case int(core.Qt__TextAlignmentRole):
			return core.NewQVariant7(int64(core.Qt__AlignCenter))
		case int(core.Qt__FontRole):
			return basic.BoldFont.ToVariant()
		}
	}
	return core.NewQVariant()
}

func safeColor(color rd.Color) *core.QVariant {
	if color == nil {
		return core.NewQVariant()
	}
	s := color.AHex()
	if s == "" {
		return core.NewQVariant()
	}
	return gui.NewQColor6(s).ToVariant()
}

func _data(index *core.QModelIndex, role int, headers []rd.Header, item rd.Item) *core.QVariant {
	field := headers[index.Column()].Field

	switch role {
	case int(core.Qt__DisplayRole), int(core.Qt__ToolTipRole):
		data := item.Fields.Data(field)
		return core.NewQVariant15(data.String())
	case int(core.Qt__TextAlignmentRole):
		return core.NewQVariant7(int64(core.Qt__AlignCenter))
	case int(core.Qt__FontRole):
		if item.Bolds[field] {
			return basic.BoldFont.ToVariant()
		}
	case int(core.Qt__BackgroundRole):
		color := item.BackgroundColor(field)
		return safeColor(color)
	case int(core.Qt__ForegroundRole):
		color := item.TextColor(field)
		return safeColor(color)
	case int(core.Qt__UserRole):
		return core.NewQVariant5(int(field))
	}

	return core.NewQVariant()
}

// ------------------------------------ Table ------------------------------------

type TableModel struct {
	*core.QAbstractTableModel

	headers   []rd.Header
	modelData rd.Table
}

func newTableModel() *TableModel {
	cm := TableModel{QAbstractTableModel: core.NewQAbstractTableModel(nil)}
	cm.ConnectHeaderData(cm.headerData)
	cm.ConnectRowCount(cm.rowCount)
	cm.ConnectData(cm.data)
	return &cm
}

func (m *TableModel) getHeaders() []rd.Header {
	return m.headers
}

func (m *TableModel) rowCount(_ *core.QModelIndex) int {
	return len(m.modelData)
}

func (m *TableModel) headerData(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
	return _headerData(section, orientation, role, m.headers)
}

func (m *TableModel) data(index *core.QModelIndex, role int) *core.QVariant {
	return _data(index, role, m.headers, m.modelData[index.Row()])
}

func (m *TableModel) remove(section int) {
	m.BeginRemoveRows(core.NewQModelIndex(), section, section)
	m.modelData = append(m.modelData[:section], m.modelData[section+1:]...)
	m.EndRemoveRows()
}

func (m *TableModel) SetData(data rd.Table) {
	m.BeginResetModel()
	m.modelData = data
	m.EndResetModel()
}

func (m *TableModel) GetData() rd.Table {
	return m.modelData
}

func (m *TableModel) dataAt(index *core.QModelIndex) (rd.Item, bool) {
	if !index.IsValid() {
		return rd.Item{}, false
	}
	return m.modelData[index.Row()], true
}