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

package fields

import (
	"fmt"
	"strconv"

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

	"github.com/therecipe/qt/core"

	"github.com/benoitkugler/goACVE/client/GUI/basic"

	"github.com/therecipe/qt/widgets"
)

type materielSkiCamp struct {
	*widgets.QGroupBox

	prixAcve   Euros
	prixLoueur Euros
}

func newMaterielSkiCamp(editable bool) materielSkiCamp {
	w := materielSkiCamp{QGroupBox: widgets.NewQGroupBox2("Matériel de ski",
		nil)}
	w.SetCheckable(true)
	w.prixAcve = NewEuros(editable)
	w.prixLoueur = NewEuros(editable)
	lay := widgets.NewQHBoxLayout2(w)
	lay.AddWidget(basic.Label("prix ACVE"), 2, 0)
	lay.AddWidget(w.prixAcve, 1, 0)
	lay.AddWidget(basic.Label("prix Loueur"), 2, 0)
	lay.AddWidget(w.prixLoueur, 1, 0)
	w.SetEnabled(editable)
	return w
}

func (f materielSkiCamp) GetData() rd.MaterielSkiCamp {
	return rd.MaterielSkiCamp{
		Actif:      f.IsChecked(),
		PrixAcve:   f.prixAcve.GetData(),
		PrixLoueur: f.prixLoueur.GetData(),
	}
}

func (f materielSkiCamp) SetData(data rd.MaterielSkiCamp) {
	f.SetChecked(data.Actif)
	f.prixAcve.SetData(data.PrixAcve)
	f.prixLoueur.SetData(data.PrixLoueur)
}

type trajetBus struct {
	rendezVous String
	prix       Euros
}

func newTrajetBus(editable bool) trajetBus {
	w := trajetBus{}
	w.rendezVous = NewString(editable)
	w.prix = NewEuros(editable)
	return w
}

func (f trajetBus) GetData() rd.TrajetBus {
	return rd.TrajetBus{
		RendezVous: f.rendezVous.GetData(),
		Prix:       f.prix.GetData(),
	}
}

func (f trajetBus) SetData(data rd.TrajetBus) {
	f.rendezVous.SetData(data.RendezVous)
	f.prix.SetData(data.Prix)
}

type busCamp struct {
	*widgets.QGroupBox

	commentaire MultiLineString
	aller       trajetBus
	retour      trajetBus
}

func newBusCamp(editable bool) busCamp {
	w := busCamp{QGroupBox: widgets.NewQGroupBox2("Navette",
		nil)}
	w.SetCheckable(true)
	w.commentaire = NewMultiLineString(editable, "Description...")
	w.aller = newTrajetBus(editable)
	w.retour = newTrajetBus(editable)
	lay := widgets.NewQGridLayout(w)

	lay.AddWidget3(basic.Label("Description :"), 0, 0, 1, 5, 0)
	lay.AddWidget3(w.commentaire, 0, 0, 1, 5, 0)
	lay.AddWidget2(basic.Label("<i>Aller</i>"), 1, 0, 0)
	lay.AddWidget2(basic.Label("rendez-vous"), 1, 1, 0)
	lay.AddWidget2(w.aller.rendezVous, 1, 2, 0)
	lay.AddWidget2(basic.Label("prix"), 1, 3, 0)
	lay.AddWidget2(w.aller.prix, 1, 4, 0)
	lay.AddWidget2(basic.Label("<i>Retour</i>"), 2, 0, 0)
	lay.AddWidget2(basic.Label("rendez-vous"), 2, 1, 0)
	lay.AddWidget2(w.retour.rendezVous, 2, 2, 0)
	lay.AddWidget2(basic.Label("prix"), 2, 3, 0)
	lay.AddWidget2(w.retour.prix, 2, 4, 0)

	w.SetEnabled(editable)
	return w
}

func (f busCamp) GetData() rd.BusCamp {
	return rd.BusCamp{
		Actif:       f.IsChecked(),
		Commentaire: f.commentaire.GetData(),
		Aller:       f.aller.GetData(),
		Retour:      f.retour.GetData(),
	}
}

func (f busCamp) SetData(data rd.BusCamp) {
	f.SetChecked(data.Actif)
	f.commentaire.SetData(data.Commentaire)
	f.aller.SetData(data.Aller)
	f.retour.SetData(data.Retour)
}

// OptionsCamp accède aux options d'un camp.
// Voir aussi OptionsParticipant
type OptionsCamp struct {
	*widgets.QGroupBox

	bus         busCamp
	materielSki materielSkiCamp
}

func NewOptionsCamp(editable bool) OptionsCamp {
	w := OptionsCamp{QGroupBox: widgets.NewQGroupBox2("Options", nil)}
	w.bus = newBusCamp(editable)
	w.materielSki = newMaterielSkiCamp(editable)
	lay := widgets.NewQFormLayout(w)
	lay.AddRow5(w.bus)
	lay.AddRow5(w.materielSki)
	w.SetEditable(editable)
	return w
}

func (f OptionsCamp) SetEditable(b bool) {
	f.bus.SetEnabled(b)
	f.materielSki.SetEnabled(b)
}

func (f OptionsCamp) GetData() rd.OptionsCamp {
	return rd.OptionsCamp{
		Bus:         f.bus.GetData(),
		MaterielSki: f.materielSki.GetData(),
	}
}

func (f OptionsCamp) SetData(data rd.OptionsCamp) {
	f.bus.SetData(data.Bus)
	f.materielSki.SetData(data.MaterielSki)
}

type materielSki struct {
	*widgets.QGroupBox

	need     materielSkiNeed
	pointure Int
	taille   Int
	poids    Int
	mode     materielSkiMode
	casque   Bool
}

func newMaterielSki(editable bool) materielSki {
	w := materielSki{QGroupBox: widgets.NewQGroupBox2("Matériel de ski", nil)}
	w.need = newMaterielSkiNeed(editable)
	w.pointure = NewInt(editable)
	w.pointure.SetMaximum(99)
	w.taille = NewInt(editable)
	w.taille.SetSuffix("cm")
	w.taille.SetMaximum(300)
	w.poids = NewInt(editable)
	w.poids.SetSuffix("kg")
	w.poids.SetMaximum(400)
	w.mode = newMaterielSkiMode(editable)
	w.casque = NewBool(editable)

	layout1 := widgets.NewQFormLayout(nil)
	layout1.AddRow3("Besoin", w.need)
	layout1.AddRow3("Catégorie", w.mode)
	layout1.AddRow3("Avec un casque", w.casque)
	layout2 := widgets.NewQFormLayout(nil)
	layout2.AddRow3("Poids", w.poids)
	layout2.AddRow3("Taille", w.taille)
	layout2.AddRow3("Pointure", w.pointure)
	layout := widgets.NewQHBoxLayout2(w)
	layout.AddLayout(layout1, 1)
	layout.AddLayout(layout2, 1)

	w.need.ConnectCurrentIndexChanged(func(_ int) {
		w.SetData(w.GetData())
	})
	w.SetEnabled(editable)
	return w
}

func (f materielSki) activeFields(actif bool) {
	f.pointure.SetEnabled(actif)
	f.taille.SetEnabled(actif)
	f.poids.SetEnabled(actif)
	f.mode.SetEnabled(actif)
	f.casque.SetEnabled(actif)
}

func (f materielSki) GetData() rd.MaterielSki {
	return rd.MaterielSki{
		Need:     f.need.GetData(),
		Pointure: int(f.pointure.GetData()),
		Taille:   int(f.taille.GetData()),
		Poids:    int(f.poids.GetData()),
		Mode:     f.mode.GetData(),
		Casque:   bool(f.casque.GetData()),
	}
}

func (f materielSki) SetData(data rd.MaterielSki) {
	f.need.SetData(data.Need)
	f.pointure.SetData(rd.Int(data.Pointure))
	f.taille.SetData(rd.Int(data.Taille))
	f.poids.SetData(rd.Int(data.Poids))
	f.mode.SetData(data.Mode)
	f.casque.SetData(rd.Bool(data.Casque))
	f.activeFields(data.Need != "")
}

// OptionsParticipant accède aux options d'un participant.
// Répond à OptionsCamp
type OptionsParticipant struct {
	*widgets.QFrame

	bus         Bus
	materielSki materielSki
}

func NewOptionsParticipant(editable bool) OptionsParticipant {
	w := OptionsParticipant{QFrame: basic.Frame()}
	w.bus = NewBus(editable)
	w.materielSki = newMaterielSki(editable)
	lay := widgets.NewQFormLayout(w)
	lay.AddRow3("Trajet en bus", w.bus)
	lay.AddRow5(w.materielSki)
	w.SetEnabled(editable)
	return w
}

func (f OptionsParticipant) GetData() rd.OptionsParticipant {
	return rd.OptionsParticipant{
		Bus:         f.bus.GetData(),
		MaterielSki: f.materielSki.GetData(),
	}
}

func (f OptionsParticipant) SetData(data rd.OptionsParticipant) {
	f.bus.SetData(data.Bus)
	f.materielSki.SetData(data.MaterielSki)
}

type optionSemaineCamp struct {
	*widgets.QFrame

	plage1 Plage
	prix1  Euros
	plage2 Plage
	prix2  Euros
}

func newOptionSemaineCamp(editable bool) optionSemaineCamp {
	w := optionSemaineCamp{QFrame: basic.Frame()}

	w.plage1 = NewPlage(editable)
	w.plage2 = NewPlage(editable)
	w.prix1 = NewEuros(editable)
	w.prix2 = NewEuros(editable)

	layout := widgets.NewQFormLayout(w)
	layout.AddRow5(basic.Label("<i>Le camp est accessible sur une des deux semaines suivantes.<i><br>"))
	layout.AddRow3("Semaine 1", w.plage1)
	layout.AddRow3("Prix de la semaine 1", w.prix1)
	layout.AddRow3("Semaine 2", w.plage2)
	layout.AddRow3("Prix de la semaine 2", w.prix2)

	w.SetEnabled(editable)
	return w
}

func (f optionSemaineCamp) GetData() rd.OptionSemaineCamp {
	return rd.OptionSemaineCamp{
		Plage1: f.plage1.GetData(),
		Plage2: f.plage2.GetData(),
		Prix1:  f.prix1.GetData(),
		Prix2:  f.prix2.GetData(),
	}
}

func (f optionSemaineCamp) SetData(data rd.OptionSemaineCamp) {
	f.plage1.SetData(data.Plage1)
	f.plage2.SetData(data.Plage2)
	f.prix1.SetData(data.Prix1)
	f.prix2.SetData(data.Prix2)
}

type optionQuotientFamilial struct {
	*widgets.QFrame

	prix [4]Euros
}

func newOptionQuotientFamilial(editable bool) optionQuotientFamilial {
	w := optionQuotientFamilial{QFrame: basic.Frame()}
	outerLayout := widgets.NewQVBoxLayout2(w)
	lay := widgets.NewQGridLayout2()
	lay.SetSpacing(15)
	for index, borneInf := range rd.QuotientFamilial {
		w.prix[index] = NewEuros(editable)
		var label string
		if index == 3 {
			label = fmt.Sprintf("plus de %d", borneInf+1)
			w.prix[index].SetEnabled(false) // cohérence avec le prix de base
		} else {
			label = fmt.Sprintf("entre %d et %d", borneInf+1, rd.QuotientFamilial[index+1])
		}
		lay.AddWidget2(basic.Label(label), 1, index, 0)
		lay.AddWidget2(w.prix[index], 2, index, 0)
	}
	outerLayout.AddWidget(basic.Label(`<i>Le prix du camp dépend du quotient familial du participant (ou de son responsable).</i><br>`),
		0, 0)
	outerLayout.AddLayout(lay, 0)
	outerLayout.AddStretch(2)
	w.SetEnabled(editable)
	return w
}

func (f optionQuotientFamilial) GetData() [4]rd.Euros {
	var out [4]rd.Euros
	for index, w := range f.prix {
		out[index] = w.GetData()
	}
	return out
}

func (f optionQuotientFamilial) SetData(data [4]rd.Euros, prixBase rd.Euros) {
	for index, val := range data {
		if index < 3 {
			f.prix[index].SetData(val)
		}
	}
	f.prix[3].SetData(prixBase)
}

type optionJoursCamp struct {
	*widgets.QFrame

	prix []Euros

	scrollArea *widgets.QScrollArea
}

func newOptionJours(editable bool) optionJoursCamp {
	w := optionJoursCamp{QFrame: basic.Frame()}
	outerLayout := widgets.NewQVBoxLayout2(w)

	outerLayout.AddWidget(basic.Label(`<i>Le prix est variable en fonction du nombre de jours de participation au camp.</i><br>`), 0, 0)
	s := widgets.NewQScrollArea(nil)
	s.SetMinimumWidth(800)
	s.SetMinimumHeight(150)
	s.SetSizeAdjustPolicy(widgets.QAbstractScrollArea__AdjustToContents)
	//s.SetWidgetResizable(true)
	outerLayout.AddWidget(s, 0, 0)
	outerLayout.AddStretch(1)
	w.scrollArea = s
	w.SetEnabled(editable)
	return w
}

func (f *optionJoursCamp) setupWidgets(prixBase rd.Euros, nbJoursMax int) {
	widgetPrix := basic.Frame()
	lay := widgets.NewQGridLayout(widgetPrix)
	lay.SetSpacing(15)
	f.prix = make([]Euros, nbJoursMax)
	for index := 0; index < nbJoursMax; index++ {
		f.prix[index] = NewEuros(true) // le parent se charge du caractère actif/inactif
		label := fmt.Sprintf("%d jour(s)", index+1)
		if index == nbJoursMax-1 {
			f.prix[index].SetEnabled(false) // cohérence avec le prix de base
			f.prix[index].SetData(prixBase)
		}
		lay.AddWidget2(basic.Label(label), 0, index, 0)
		lay.AddWidget2(f.prix[index], 1, index, 0)
	}
	f.scrollArea.SetWidget(widgetPrix)
}

func (f optionJoursCamp) GetData() []rd.Euros {
	out := make([]rd.Euros, len(f.prix))
	for index, w := range f.prix {
		out[index] = w.GetData()
	}
	return out
}

func (f *optionJoursCamp) SetData(data []rd.Euros, prixBase rd.Euros, nbJoursMax int) {
	f.setupWidgets(prixBase, nbJoursMax)
	if len(data) != len(f.prix) { // le nombre de jours ne colle pas, on ignore
		return
	}
	for index, widget := range f.prix {
		if index < len(f.prix)-1 {
			widget.SetData(data[index])
		}
	}
}

type OptionsPrixCamp struct {
	*widgets.QPushButton

	actif            Enum
	statut           *optionStatut
	jours            optionJoursCamp
	quotientFamilial optionQuotientFamilial
	semaine          optionSemaineCamp

	// requis pour pouvoir ajuster les options
	GetPrixBaseNbJoursMax func() (prixBase rd.Euros, nbJoursMax int)
}

func NewOptionsPrixCamp(editable bool) *OptionsPrixCamp {
	w := OptionsPrixCamp{QPushButton: basic.Button("Options sur le prix")}
	w.ConnectClicked(w.onClick)
	w.statut = newOptionStatut(editable)
	w.jours = newOptionJours(editable)
	w.quotientFamilial = newOptionQuotientFamilial(editable)
	w.semaine = newOptionSemaineCamp(editable)

	w.actif = NewEnum([]Choice{
		{Field: "", Label: "Aucun"},
		{Field: rd.OptionsPrix.STATUT, Label: "Prix par statut"},
		{Field: rd.OptionsPrix.JOUR, Label: "Prix à la journée"},
		{Field: rd.OptionsPrix.QUOTIENT_FAMILIAL, Label: "Prix au quotient familial"},
		{Field: rd.OptionsPrix.SEMAINE, Label: "Prix à la semaine"},
	}, editable)
	return &w
}

func (f OptionsPrixCamp) SetEditable(b bool) {
	f.actif.SetEnabled(false)
	f.statut.SetEnabled(b)
	f.jours.SetEnabled(b)
	f.quotientFamilial.SetEnabled(b)
	f.semaine.SetEnabled(b)
}

func (f OptionsPrixCamp) setLabel() {
	l := f.GetData().String()
	msg := "Options sur le prix"
	style := ""
	if l != "" {
		msg += fmt.Sprintf(" (%s)", l)
		style = "bold"
	}
	f.SetStyleSheet("font-weight: " + style)
	f.SetText(msg)
}

func (f *OptionsPrixCamp) onClick(_ bool) {
	d := basic.Dialog2("Options sur le prix du camp")
	outerLayout := widgets.NewQFormLayout(d)
	stacks := widgets.NewQStackedWidget(nil)
	stacks.AddWidget(basic.Label("<i>Aucune modification sur le prix de base</i>"))
	stacks.AddWidget(f.statut)
	stacks.AddWidget(f.jours)
	stacks.AddWidget(f.quotientFamilial)
	stacks.AddWidget(f.semaine)
	currentIndex := map[string]int{
		rd.OptionsPrix.STATUT: 1, rd.OptionsPrix.JOUR: 2,
		rd.OptionsPrix.QUOTIENT_FAMILIAL: 3, rd.OptionsPrix.SEMAINE: 4,
	}[f.actif.GetData()]
	stacks.SetCurrentIndex(currentIndex)
	f.actif.ConnectCurrentIndexChanged(stacks.SetCurrentIndex)
	valid := basic.Button("Valider")
	valid.ConnectClicked(func(_ bool) {
		d.Accept()
	})

	outerLayout.AddRow3("Option sur le prix :", f.actif)
	outerLayout.AddRow5(stacks)
	outerLayout.AddRow5(valid)

	prixBase, nbJoursMax := f.GetPrixBaseNbJoursMax()

	f.SetData(f.GetData(), prixBase, nbJoursMax) // on ajuste si le reste a changé
	initialOptions := f.GetData()
	if d.Exec() == 0 { // on restaure les anciennes valeurs
		f.SetData(initialOptions, prixBase, nbJoursMax)
	}
	f.setLabel()
}

func (f OptionsPrixCamp) GetData() rd.OptionPrixCamp {
	return rd.OptionPrixCamp{
		Active:           f.actif.GetData(),
		Statut:           f.statut.GetData(),
		Jour:             f.jours.GetData(),
		QuotientFamilial: f.quotientFamilial.GetData(),
		Semaine:          f.semaine.GetData(),
	}
}

func (f *OptionsPrixCamp) SetData(data rd.OptionPrixCamp, prixBase rd.Euros, nbJoursMax int) {
	f.actif.SetData(data.Active)
	f.statut.SetData(data.Statut)
	f.jours.SetData(data.Jour, prixBase, nbJoursMax)
	f.quotientFamilial.SetData(data.QuotientFamilial, prixBase)
	f.semaine.SetData(data.Semaine)
	f.setLabel()
}

type optionJoursParticipant struct {
	*widgets.QScrollArea

	choix []*widgets.QCheckBox
}

func newOptionJoursParticipant(editable bool, dates rd.Plage) optionJoursParticipant {
	w := optionJoursParticipant{QScrollArea: widgets.NewQScrollArea(nil)}

	w.SetMinimumWidth(800)
	w.SetMinimumHeight(150)
	w.SetSizeAdjustPolicy(widgets.QAbstractScrollArea__AdjustToContents)
	//s.SetWidgetResizable(true)
	w.SetWidget(w.setupWidgets(dates))
	w.SetEnabled(editable)
	return w
}

func (f *optionJoursParticipant) setupWidgets(dates rd.Plage) *widgets.QFrame {
	widgetJours := basic.Frame()
	lay := widgets.NewQGridLayout(widgetJours)
	lay.SetContentsMargins(3, 0, 3, 0)
	lay.SetSpacing(15)
	f.choix = make([]*widgets.QCheckBox, dates.NbJours())
	for index := range f.choix {
		f.choix[index] = widgets.NewQCheckBox(f) // le parent se charge du caractère actif/inactif
		label := fmt.Sprintf("Jour %d", index+1)
		lay.AddWidget2(basic.Label(label), 0, index, 0)
		lay.AddWidget2(f.choix[index], 1, index, 0)
	}
	return widgetJours
}

func (f optionJoursParticipant) GetData() rd.Jours {
	var out rd.Jours
	for index, w := range f.choix {
		if w.IsChecked() {
			out = append(out, index)
		}
	}
	if len(out.Set()) == len(f.choix) {
		// tous cochés = zero value
		out = nil
	}
	return out
}

func (f *optionJoursParticipant) SetData(data rd.Jours) {
	crible := data.Set()
	isZero := len(data) == 0 // isZero = tous cochés
	for index, cb := range f.choix {
		cb.SetChecked(isZero || crible[index])
	}
}

type OptionPrixParticipant struct {
	*widgets.QFrame

	semaine          Semaine
	quotientFamilial Int
	jour             optionJoursParticipant
	statut           ChoixStatut

	layout *widgets.QFormLayout

	Categorie string
}

func NewOptionPrixParticipant(editable bool, categorie string, status []rd.PrixParStatut, datesCamp rd.Plage) OptionPrixParticipant {
	w := OptionPrixParticipant{QFrame: basic.Frame()}
	w.semaine = NewSemaine(editable)
	w.quotientFamilial = NewInt(editable)
	w.jour = newOptionJoursParticipant(editable, datesCamp)
	w.statut = NewChoixStatut(editable)
	w.layout = widgets.NewQFormLayout(w)

	w.setChoix(categorie, status)

	w.SetEnabled(editable)
	return w
}

func (f *OptionPrixParticipant) setChoix(categorie string, statuts []rd.PrixParStatut) {
	f.statut.SetChoix(statuts)
	for f.layout.Count() > 0 {
		f.layout.RemoveRow(f.layout.Count() - 1)
	}
	switch categorie {
	case rd.OptionsPrix.SEMAINE:
		f.layout.AddRow5(basic.Label("<i>Le camp propose un prix à la semaine.</i><br>"))
		f.layout.AddRow3("Semaine", f.semaine)
	case rd.OptionsPrix.STATUT:
		f.layout.AddRow5(basic.Label("<i>Le prix peut varier en fonction du statut du participant.</i><br>"))
		f.layout.AddRow3("Statut", f.statut)
	case rd.OptionsPrix.QUOTIENT_FAMILIAL:
		f.layout.AddRow5(basic.Label("<i>Le prix du camp varie en fonction du quotient familial du participant ou de son responsable.</i><br>"))
		f.layout.AddRow3("Quotient familial", f.quotientFamilial)
	case rd.OptionsPrix.JOUR:
		f.layout.AddRow5(basic.Label("<i>Le prix varie en fonction du nombre de jours de présence.</i><br>"))
		f.layout.AddRow3("Présence sur les jours", f.jour)
	default:
		f.layout.AddRow5(basic.Label("<i>Le camp ne propose aucune option sur le prix.</i><br>"))
	}
}

func (f OptionPrixParticipant) GetData() rd.OptionPrixParticipant {
	return rd.OptionPrixParticipant{
		Semaine:          f.semaine.GetData(),
		QuotientFamilial: f.quotientFamilial.GetData(),
		Jour:             f.jour.GetData(),
		Statut:           f.statut.GetData(),
	}
}

func (f OptionPrixParticipant) SetData(data rd.OptionPrixParticipant) {
	f.semaine.SetData(data.Semaine)
	f.quotientFamilial.SetData(data.QuotientFamilial)
	f.jour.SetData(data.Jour)
	f.statut.SetData(data.Statut)
}

type remises struct {
	*widgets.QGroupBox

	Enfants   Pourcent
	Equipiers Pourcent
	Speciale  Euros
}

func newRemises(editable bool) remises {
	s := remises{QGroupBox: widgets.NewQGroupBox2("Remises", nil)}
	layR := widgets.NewQFormLayout(s)
	s.Enfants = NewPourcent(editable)
	s.Equipiers = NewPourcent(editable)
	s.Speciale = NewEuros(editable)

	layR.AddRow3("Nombre d'enfants", s.Enfants)
	layR.AddRow3("Equipiers", s.Equipiers)
	layR.AddRow3("Spéciale", s.Speciale)

	return s
}

func (f remises) GetData() rd.Remises {
	return rd.Remises{
		ReducEnfants:   f.Enfants.GetData(),
		ReducEquipiers: f.Equipiers.GetData(),
		ReducSpeciale:  f.Speciale.GetData(),
	}
}

func (f remises) SetData(data rd.Remises) {
	f.Enfants.SetData(data.ReducEnfants)
	f.Equipiers.SetData(data.ReducEquipiers)
	f.Speciale.SetData(data.ReducSpeciale)
}

// OptionsFinanceParticipant regroupe les remises
// et l'option sur le prix.
type OptionsFinanceParticipant struct {
	*widgets.QPushButton

	remises               remises
	OptionPrixParticipant OptionPrixParticipant

	DataChanged func()
}

func NewOptionsFinanceParticipant(editable bool, categorie string, status []rd.PrixParStatut, defaultPlage rd.Plage) *OptionsFinanceParticipant {
	f := OptionsFinanceParticipant{QPushButton: basic.Button("Options")}
	f.ConnectClicked(f.onClick)

	f.remises = newRemises(editable)
	f.OptionPrixParticipant = NewOptionPrixParticipant(editable, categorie, status, defaultPlage)

	return &f
}

func (f *OptionsFinanceParticipant) onClick(_ bool) {
	d := basic.Dialog2("Options financières")

	valid := basic.Button("Valider")
	valid.ConnectClicked(func(_ bool) {
		d.Accept()
		if f.DataChanged != nil {
			f.DataChanged()
		}
	})
	valid.SetEnabled(f.OptionPrixParticipant.IsEnabled())

	lay := widgets.NewQGridLayout(d)
	lay.AddWidget2(f.remises, 0, 0, 0)
	lay.AddWidget2(f.OptionPrixParticipant, 0, 1, 0)
	lay.AddWidget3(valid, 1, 0, 1, 2, 0)

	initialRemises, initialOption := f.GetData()
	if d.Exec() == 0 { // on restaure les anciennes valeurs
		f.SetData(initialRemises, initialOption)
	}
	f.setLabel()
}

func (f OptionsFinanceParticipant) setLabel() {
	msg := "Options"
	rem, optionPrix := f.GetData()
	isRemiseActive := rem.IsActive()
	isOptionActive := optionPrix.IsNonNil(f.OptionPrixParticipant.Categorie)

	if isRemiseActive {
		msg += " (remises actives)"
	}
	if isOptionActive {
		msg += " (option active)"
	}

	style := ""
	if isRemiseActive || isOptionActive {
		style = "bold"
	}
	f.SetStyleSheet("font-weight: " + style)
	f.SetText(msg)
}

func (f OptionsFinanceParticipant) GetData() (rd.Remises, rd.OptionPrixParticipant) {
	return f.remises.GetData(), f.OptionPrixParticipant.GetData()
}

func (f OptionsFinanceParticipant) SetData(rem rd.Remises, opt rd.OptionPrixParticipant) {
	f.remises.SetData(rem)
	f.OptionPrixParticipant.SetData(opt)
	f.setLabel()
}

type Exemplaires struct {
	*widgets.QFrame

	pubEte     Int
	pubHiver   Int
	echoRocher Int
}

func NewExemplaires(editable bool) Exemplaires {
	f := Exemplaires{QFrame: basic.Frame()}

	f.pubEte = NewInt(editable)
	f.pubHiver = NewInt(editable)
	f.echoRocher = NewInt(editable)

	lay := widgets.NewQFormLayout(f)
	lay.AddRow3("Publicité pour séjours d'été", f.pubEte)
	lay.AddRow3("Publicité pour séjours d'hiver", f.pubHiver)
	lay.AddRow3("Echo du Rocher", f.echoRocher)
	return f
}

func (f Exemplaires) GetData() rd.Exemplaires {
	return rd.Exemplaires{
		PubEte:     int(f.pubEte.GetData()),
		PubHiver:   int(f.pubHiver.GetData()),
		EchoRocher: int(f.echoRocher.GetData()),
	}
}

func (f Exemplaires) SetData(data rd.Exemplaires) {
	f.pubEte.SetData(rd.Int(data.PubEte))
	f.pubHiver.SetData(rd.Int(data.PubHiver))
	f.echoRocher.SetData(rd.Int(data.EchoRocher))
}

type Cotisation struct {
	*widgets.QPushButton

	cbs map[int]*widgets.QCheckBox
}

func NewCotisation(editable bool) Cotisation {
	w := Cotisation{QPushButton: basic.Button("Cotisations annuelles")}
	w.cbs = map[int]*widgets.QCheckBox{}
	for _, an := range rd.AnneesCotisations {
		cb := widgets.NewQCheckBox2(strconv.Itoa(an), nil)
		w.cbs[an] = cb
	}
	w.ConnectClicked(func(_ bool) {
		w.edit()
	})
	w.SetEnabled(editable)
	return w
}

func (f *Cotisation) edit() {
	current := f.GetData()
	dial := basic.Dialog2("Cotisations")
	layout := widgets.NewQVBoxLayout2(dial)
	row := widgets.NewQHBoxLayout()
	for _, an := range rd.AnneesCotisations {
		row.AddWidget(f.cbs[an], 1, core.Qt__AlignCenter)
	}
	valid := basic.Button("Valider")
	valid.SetObjectName(basic.ONAction)
	valid.ConnectClicked(func(_ bool) {
		dial.Accept()
	})
	layout.AddWidget(basic.Label("<i>Années de cotisations payées :</i>"), 1, 0)
	layout.AddLayout(row, 2)
	layout.AddWidget(valid, 1, 0)
	if dial.Exec() == 0 { // on restaure les valeurs précédentes
		f.SetData(current)
	}
}

func (f Cotisation) GetData() rd.Cotisation {
	var out rd.Cotisation
	for an, cb := range f.cbs {
		if cb.IsChecked() {
			out = append(out, int64(an))
		}
	}
	return out
}

func (f *Cotisation) SetData(data rd.Cotisation) {
	m := data.Map()
	for an, cb := range f.cbs {
		cb.SetChecked(m[an])
	}
}