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

package messages

import (
	"fmt"

	"github.com/therecipe/qt/core"

	"github.com/benoitkugler/goACVE/client/GUI/basic"
	"github.com/benoitkugler/goACVE/client/controllers"
	dm "github.com/benoitkugler/goACVE/server/core/datamodel"
	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	"github.com/therecipe/qt/widgets"
)

const style = `
	.QListWidget {
		background: transparent;
	}

	QFrame#message {
		border: 1px solid transparent;
		border-radius: 10px;
	}
`

type messageRow struct {
	*widgets.QFrame
	contenu widgets.QWidget_ITF
	kind    rd.MessageKind

	OnMarqueVu      func(bool)
	OnEdit          func(allGroupe bool)
	OnDelete        func(allGroupe bool)
	OnMessageGroupe func()
}

func newMessageRow(ct *controllers.SuiviDossiers, message controllers.PseudoMessage) *messageRow {
	m := messageRow{QFrame: basic.Frame(), kind: message.Kind}
	lay := widgets.NewQVBoxLayout2(nil)
	lay.SetContentsMargins(5, 5, 5, 5)
	m.SetLayout(lay)
	m.SetObjectName("message")
	m.SetStyleSheet(m.StyleSheet() + fmt.Sprintf("QFrame#message { background: %s; }", message.Color.AHex()))

	modifie := ""
	if !message.Modified.Time().IsZero() {
		modifie = fmt.Sprintf("modifié le %s", message.Modified)
	}
	infos := basic.Label(fmt.Sprintf("%s <i>%s</i>", message.Created, modifie))
	infos.SetMinimumHeight(25)

	title := basic.Label(fmt.Sprintf("<b>%s</b>", message.Label))
	title.SetMinimumHeight(25)

	buttonF := basic.Frame()
	buttons := widgets.NewQHBoxLayout2(buttonF)
	buttons.SetContentsMargins(0, 0, 0, 0)
	isInGroupe := len(message.Groupe) > 0
	if isInGroupe {
		view := widgets.NewQToolButton(nil)
		view.SetIcon(basic.Icons.Mails)
		view.SetToolTip("Répondre au groupe")
		view.ConnectClicked(func(vu bool) { m.OnMessageGroupe() })
		buttons.AddWidget(view, 1, core.Qt__AlignRight)
	}
	if message.IsEditable {
		view := widgets.NewQToolButton(nil)
		view.SetIcon(basic.Icons.Edit)
		view.SetToolTip("Modifier le message...")
		if isInGroupe {
			menu := widgets.NewQMenu(nil)
			view.SetMenu(menu)
			view.SetPopupMode(widgets.QToolButton__InstantPopup)
			modifGroupe := menu.AddAction(fmt.Sprintf("Modifier les %d messages du groupe", len(message.Groupe)))
			modifGroupe.ConnectTriggered(func(_ bool) {
				m.OnEdit(true)
			})
			modifSolo := menu.AddAction("Modifier uniquement ce message")
			modifSolo.ConnectTriggered(func(_ bool) {
				m.OnEdit(false)
			})
		} else {
			view.ConnectClicked(func(vu bool) { m.OnEdit(false) })
		}
		buttons.AddWidget(view, 1, core.Qt__AlignRight)
	}

	if message.IsDeletable {
		view := widgets.NewQToolButton(nil)
		view.SetIcon(basic.Icons.Delete)
		view.SetToolTip("Supprimer le message")
		if isInGroupe {
			menu := widgets.NewQMenu(nil)
			view.SetMenu(menu)
			view.SetPopupMode(widgets.QToolButton__InstantPopup)
			modifGroupe := menu.AddAction(fmt.Sprintf("Supprimer les %d messages du groupe", len(message.Groupe)))
			modifGroupe.ConnectTriggered(func(_ bool) {
				m.OnDelete(true)
			})
			modifSolo := menu.AddAction("Supprimer uniquement ce message")
			modifSolo.ConnectTriggered(func(_ bool) {
				m.OnDelete(false)
			})
		} else {
			view.ConnectClicked(func(vu bool) { m.OnDelete(false) })
		}
		buttons.AddWidget(view, 1, core.Qt__AlignRight)
	}

	if message.IsViewable {
		view := widgets.NewQToolButton(nil)
		view.SetIcon(basic.Icons.Star)
		view.SetCheckable(true)
		view.SetChecked(message.Vu)
		tooltip := "Marquer comme vu"
		if message.Vu {
			tooltip = "Marquer comme non vu"
		}
		view.SetToolTip(tooltip)
		view.ConnectClicked(func(vu bool) { m.OnMarqueVu(vu) })
		if !message.Vu {
			buttons.AddWidget(basic.Label("<b>Nouveau</b>"), 2, core.Qt__AlignRight)
		}
		buttons.AddWidget(view, 1, core.Qt__AlignRight)
	}

	header := widgets.NewQHBoxLayout()
	infos.SetSizePolicy2(widgets.QSizePolicy__Ignored, widgets.QSizePolicy__Expanding)
	title.SetSizePolicy2(widgets.QSizePolicy__Ignored, widgets.QSizePolicy__Expanding)
	buttonF.SetSizePolicy2(widgets.QSizePolicy__Ignored, widgets.QSizePolicy__Expanding)

	header.AddWidget(infos, 3, 0)
	header.AddWidget(title, 2, 0)
	header.AddWidget(buttonF, 1, core.Qt__AlignRight)

	m.contenu = initContenu(ct, message.PseudoMessage)

	lay.AddLayout(header, 1)
	if m.contenu != nil {
		lay.AddWidget(m.contenu, 3, 0)
	}
	return &m
}

// dispatch suivant le type de message
func initContenu(ct *controllers.SuiviDossiers, message dm.PseudoMessage) widgets.QWidget_ITF {
	switch message.Kind {
	case rd.MResponsable, rd.MCentre:
		return newContenuPerso(message.Contenu.(dm.ContenuPerso))
	case rd.MFacture, rd.MFactureAcquittee:
		ac := ct.Base.NewFacture(message.IdFacture)
		isRappel := ac.GetEtat(nil, nil).IsFactureRappel(message)
		w := newContenuFacture(message.Kind == rd.MFactureAcquittee, isRappel, message.Modified)
		w.onShow = func() {
			ct.Onglet.ShowPreviewFacture(ac)
		}
		return w
	case rd.MDocuments:
		w := newContenuDocument(ct.Base, message.Contenu.(dm.ContenuDocument))
		w.onGoToCamp = func(id int64) {
			ct.Main().Controllers.Camps.SelectCamp(id)
		}
		return w
	case rd.MAttestationPresence:
		w := newContenuAttestation(message.Modified)
		w.onShow = func() {
			path := ct.RenderAttestation()
			if path != "" {
				basic.ShowFile(path)
			}
		}
		return w
	case rd.MSondage:
		w := newContenuSondage(ct.Base, message.Contenu.(dm.ContenuSondage))
		w.onGoToCamp = func(id int64) {
			ct.Main().Controllers.Camps.SelectCamp(id)
		}
		return w
	case rd.MPlaceLiberee:
		w := newContenuPlaceLiberee(ct.Base, message.Contenu.(dm.ContenuPlaceLiberee))
		w.onGoToParticipant = func(id int64) {
			ct.Main().Controllers.Camps.SelectParticipant(ct.Base.NewParticipant(id))
		}
		return w
	case rd.MPaiement:
		w := newContenuPaiement(ct.Base, message.Id)
		w.onGoToPaiement = func(id int64) {
			ct.Main().Controllers.Paiements.SelectPaiement(id)
		}
		return w
	default:
		return nil
	}
}

type List struct {
	*widgets.QListWidget
	msgs []*messageRow // a synchroniser

	controller *controllers.SuiviDossiers

	scrollPositions map[int64]int

	OnMessageGroupe func(rd.Ids)
}

func NewList(ct *controllers.SuiviDossiers) *List {
	out := &List{QListWidget: widgets.NewQListWidget(nil)}
	out.controller = ct
	out.scrollPositions = map[int64]int{}
	out.SetStyleSheet(out.StyleSheet() + style)
	out.SetVerticalScrollMode(widgets.QAbstractItemView__ScrollPerPixel)
	out.SetSelectionMode(widgets.QAbstractItemView__NoSelection)
	out.SetSpacing(1)
	out.VerticalScrollBar().ConnectValueChanged(out.storeScrollPosition)
	return out
}

func (m List) storeScrollPosition(value int) {
	id := m.controller.Etat.FactureCurrent
	if id == nil {
		return
	}
	m.scrollPositions[id.Int64()] = value
}

func (m List) restoreScrollPosition() (int, bool) {
	id := m.controller.Etat.FactureCurrent
	if id != nil {
		s, has := m.scrollPositions[id.Int64()]
		return s, has
	}
	return 0, false
}

func (m List) applyScroll(scroll int, hasScroll bool) {
	if hasScroll {
		m.VerticalScrollBar().SetValue(scroll)
	} else {
		m.ScrollToBottom()
	}
}

// SetData reset la liste et affiche les messages.
func (m *List) SetData(messages []controllers.PseudoMessage) {
	// save scroll value before modifying
	scroll, hasScroll := m.restoreScrollPosition()

	// on ajoute les lignes manquantes
	for i := m.Count(); i < len(messages); i++ {
		li := widgets.NewQListWidgetItem(nil, 0)
		m.AddItem2(li)
	}
	// on supprime les lignes en trop
	maxI := m.Count()
	for i := len(messages); i < maxI; i++ {
		//attention TakeItem redimensionne la liste
		m.TakeItem(m.Count() - 1)
	}
	m.msgs = make([]*messageRow, len(messages))
	for i, message := range messages {
		message := message // closure in loop
		wg := newMessageRow(m.controller, message)
		wg.SetMaximumWidth(m.Width())

		wg.OnMarqueVu = func(b bool) {
			m.controller.ToggleMessageVu(message.Id, b)
		}
		wg.OnMessageGroupe = func() {
			m.OnMessageGroupe(message.Groupe)
		}
		wg.OnEdit = func(allGroupe bool) {
			ids := rd.Ids{message.Id}
			if allGroupe {
				ids = message.Groupe
			}
			contenu, ok := EditMessage(string(message.Contenu.(dm.ContenuPerso)), false, len(ids))
			if !ok {
				m.controller.Main().ShowStandard("Edition annulée.", false)
				return
			}
			m.controller.EditMessageCentre(ids, contenu)
		}
		wg.OnDelete = func(allGroupe bool) {
			ids := rd.Ids{message.Id}
			if allGroupe {
				ids = message.Groupe
			}
			m.controller.SupprimeMessages(ids)
		}
		m.set(i, wg)
		m.msgs[i] = wg
	}
	m.applyScroll(scroll, hasScroll)
}

func (m *List) set(i int, wg *messageRow) {
	item := m.Item(i)
	item.SetSizeHint(wg.SizeHint())
	m.SetItemWidget(item, wg)
}

// ToogleContent montre/masque le contenu de tous les messages
func (m *List) ToogleContent(visible bool) {
	for i, wg := range m.msgs {
		if wg.contenu == nil {
			continue
		}
		wg.contenu.QWidget_PTR().SetVisible(visible)
		m.set(i, wg)
	}
}

// ShowDeleted montre/masque les message supprimés
func (m *List) ShowDeleted(show bool) {
	for i, msg := range m.msgs {
		m.SetRowHidden(i, !show && msg.kind == rd.MSupprime)
	}
}