hswidget/PaletteSelectWidget: refactor

hswidget/selectpalettewidget/widget.go

@@ -1,6 +1,7 @@
 package selectpalettewidget
 
 import (
+	"fmt"
 	"log"
 	"path/filepath"
 
@@ -22,107 +23,144 @@ const (
 	actionButtonW, actionButtonH   = 200, 30
 )
 
+type selectPaletteState struct {
+	mpqExplorer     *hsmpqexplorer.MPQExplorer
+	projectExplorer *hsprojectexplorer.ProjectExplorer
+}
+
+func (s *selectPaletteState) Dispose() {
+	s.mpqExplorer = nil
+	s.projectExplorer = nil
+}
+
 // SelectPaletteWidget represents an pop-up MPQ explorer, when we're
 // selectin DAT palette
 type SelectPaletteWidget struct {
-	mpqExplorer     *hsmpqexplorer.MPQExplorer
-	projectExplorer *hsprojectexplorer.ProjectExplorer
-	id              string
-	saveCB          func(colors *[256]d2interface.Color)
-	closeCB         func()
+	isOpen   *bool
+	id       string
+	onSelect func(colors *[256]d2interface.Color)
+	config   *hsconfig.Config
+	project  *hsproject.Project
 }
 
 // NewSelectPaletteWidget creates a select palette widget
 func NewSelectPaletteWidget(
 	id string,
 	project *hsproject.Project,
 	config *hsconfig.Config,
-	saveCB func(colors *[256]d2interface.Color),
-	closeCB func(),
 ) *SelectPaletteWidget {
 	result := &SelectPaletteWidget{
 		id:      id,
-		saveCB:  saveCB,
-		closeCB: closeCB,
+		config:  config,
+		project: project,
 	}
 
-	callback := func(path *hscommon.PathEntry) {
-		bytes, bytesErr := path.GetFileBytes()
-		if bytesErr != nil {
-			log.Print(bytesErr)
+	return result
+}
+
+// OnSelect sets a callback for ppalette selection
+func (p *SelectPaletteWidget) OnSelect(cb func(colors *[256]d2interface.Color)) *SelectPaletteWidget {
+	p.onSelect = cb
+	return p
+}
 
-			return
-		}
+func (p *SelectPaletteWidget) getState() *selectPaletteState {
+	var state *selectPaletteState
 
-		ft, err := hsfiletypes.GetFileTypeFromExtension(filepath.Ext(path.FullPath), &bytes)
-		if err != nil {
-			log.Print(err)
+	stateID := fmt.Sprintf("selectPalette_%s", p.id)
+	s := giu.Context.GetState(stateID)
 
-			return
-		}
+	if s != nil {
+		state = s.(*selectPaletteState)
+	} else {
+		state = &selectPaletteState{}
+		callback := func(path *hscommon.PathEntry) {
+			bytes, bytesErr := path.GetFileBytes()
+			if bytesErr != nil {
+				log.Print(bytesErr)
 
-		if ft == hsfiletypes.FileTypePalette {
-			// load new palette:
-			paletteData, err := path.GetFileBytes()
-			if err != nil {
-				log.Print(err)
+				return
 			}
 
-			palette, err := d2dat.Load(paletteData)
+			ft, err := hsfiletypes.GetFileTypeFromExtension(filepath.Ext(path.FullPath), &bytes)
 			if err != nil {
 				log.Print(err)
+
+				return
 			}
 
-			colors := palette.GetColors()
+			if ft == hsfiletypes.FileTypePalette {
+				// load new palette:
+				paletteData, err := path.GetFileBytes()
+				if err != nil {
+					log.Print(err)
+				}
+
+				palette, err := d2dat.Load(paletteData)
+				if err != nil {
+					log.Print(err)
+				}
+
+				colors := palette.GetColors()
 
-			saveCB(&colors)
-			closeCB()
+				if p.onSelect != nil {
+					p.onSelect(&colors)
+				}
+
+				*p.isOpen = false
+			}
 		}
-	}
 
-	mpqExplorer, err := hsmpqexplorer.Create(callback, config, 0, 0)
-	if err != nil {
-		log.Print(err)
-	}
+		mpqExplorer, err := hsmpqexplorer.Create(callback, p.config, 0, 0)
+		if err != nil {
+			log.Print(err)
+		}
 
-	mpqExplorer.SetProject(project)
+		mpqExplorer.SetProject(p.project)
 
-	result.mpqExplorer = mpqExplorer
+		state.mpqExplorer = mpqExplorer
 
-	projectExplorer, err := hsprojectexplorer.Create(nil, callback, 0, 0)
-	if err != nil {
-		log.Print(err)
-	}
+		projectExplorer, err := hsprojectexplorer.Create(nil, callback, 0, 0)
+		if err != nil {
+			log.Print(err)
+		}
 
-	projectExplorer.SetProject(project)
+		projectExplorer.SetProject(p.project)
 
-	result.projectExplorer = projectExplorer
+		state.projectExplorer = projectExplorer
+		giu.Context.SetState(stateID, state)
+	}
 
-	return result
+	return state
+}
+
+// IsOpen sets pointer to isOpen variable - determinates if a widget is visible
+func (p *SelectPaletteWidget) IsOpen(isOpen *bool) *SelectPaletteWidget {
+	p.isOpen = isOpen
+	return p
 }
 
 // Build builds a widget
 func (p *SelectPaletteWidget) Build() {
-	// always true (we don't use this feature in this case
-	isOpen := true
-	giu.Layout{
-		giu.PopupModal("##" + p.id + "popUpSelectPalette").IsOpen(&isOpen).Layout(giu.Layout{
-			giu.Child("##"+p.id+"popUpSelectPaletteChildWidget").Size(paletteSelectW, paletteSelectH).Layout(giu.Layout{
-				p.projectExplorer.GetProjectTreeNodes(),
-				giu.Layout(p.mpqExplorer.GetMpqTreeNodes()),
-				giu.Separator(),
-				giu.Button("Don't use any palette##"+p.id+"selectPaletteDonotUseAny").
-					Size(actionButtonW, actionButtonH).
-					OnClick(func() {
-						p.saveCB(nil)
-						p.closeCB()
-					}),
-				giu.Button("Exit##"+p.id+"selectPaletteExit").
-					Size(actionButtonW, actionButtonH).
-					OnClick(func() {
-						p.closeCB()
-					}),
-			}),
+	state := p.getState()
+	giu.PopupModal("##" + p.id + "popUpSelectPalette").IsOpen(p.isOpen).Layout(giu.Layout{
+		giu.Child("##"+p.id+"popUpSelectPaletteChildWidget").Size(paletteSelectW, paletteSelectH).Layout(giu.Layout{
+			state.projectExplorer.GetProjectTreeNodes(),
+			giu.Layout(state.mpqExplorer.GetMpqTreeNodes()),
+			giu.Separator(),
+			giu.Button("Don't use any palette##"+p.id+"selectPaletteDonotUseAny").
+				Size(actionButtonW, actionButtonH).
+				OnClick(func() {
+					if p.onSelect != nil {
+						p.onSelect(nil)
+					}
+					*p.isOpen = false
+				}),
+			giu.Button("Exit##"+p.id+"selectPaletteExit").
+				Size(actionButtonW, actionButtonH).
+				OnClick(func() {
+					*p.isOpen = false
+				}),
 		}),
-	}.Build()
+	}).Build()
 }

hswindow/hseditor/hsdc6editor/dc6_editor.go

@@ -25,13 +25,12 @@ var _ hscommon.EditorWindow = &DC6Editor{}
 // DC6Editor represents a dc6 editor
 type DC6Editor struct {
 	*hseditor.Editor
-	dc6                 *d2dc6.DC6
-	textureLoader       hscommon.TextureLoader
-	config              *hsconfig.Config
-	selectPalette       bool
-	palette             *[256]d2interface.Color
-	selectPaletteWidget g.Widget
-	state               []byte
+	dc6           *d2dc6.DC6
+	textureLoader hscommon.TextureLoader
+	config        *hsconfig.Config
+	selectPalette bool
+	palette       *[256]d2interface.Color
+	state         []byte
 }
 
 // Create creates a new dc6 editor
@@ -59,32 +58,28 @@ func Create(config *hsconfig.Config,
 
 // Build builds a new dc6 editor
 func (e *DC6Editor) Build() {
+	id := e.Path.GetUniqueID()
+
 	e.IsOpen(&e.Visible)
 	e.Flags(g.WindowFlagsAlwaysAutoResize)
 
-	if !e.selectPalette {
-		e.Layout(g.Layout{
-			dc6widget.Create(e.state, e.palette, e.textureLoader, e.Path.GetUniqueID(), e.dc6),
-		})
-
-		return
-	}
-
-	if e.selectPaletteWidget == nil {
-		e.selectPaletteWidget = selectpalettewidget.NewSelectPaletteWidget(
-			e.Path.GetUniqueID()+"selectPalette",
+	if e.selectPalette {
+		selectPaletteWidget := selectpalettewidget.NewSelectPaletteWidget(
+			id+"selectPalette",
 			e.Project,
 			e.config,
+		).IsOpen(&e.selectPalette).OnSelect(
 			func(palette *[256]d2interface.Color) {
 				e.palette = palette
 			},
-			func() {
-				e.selectPalette = false
-			},
 		)
+
+		e.Layout(selectPaletteWidget)
 	}
 
-	e.Layout(e.selectPaletteWidget)
+	e.Layout(
+		dc6widget.Create(e.state, e.palette, e.textureLoader, id, e.dc6),
+	)
 }
 
 // UpdateMainMenuLayout updates main menu to it contain DC6's editor menu

hswindow/hseditor/hsdcceditor/dcc_editor.go

@@ -26,13 +26,12 @@ var _ hscommon.EditorWindow = &DCCEditor{}
 // DCCEditor represents a new dcc editor
 type DCCEditor struct {
 	*hseditor.Editor
-	dcc                 *d2dcc.DCC
-	config              *hsconfig.Config
-	selectPalette       bool
-	palette             *[256]d2interface.Color
-	selectPaletteWidget g.Widget
-	state               []byte
-	textureLoader       hscommon.TextureLoader
+	dcc           *d2dcc.DCC
+	config        *hsconfig.Config
+	selectPalette bool
+	palette       *[256]d2interface.Color
+	state         []byte
+	textureLoader hscommon.TextureLoader
 }
 
 // Create creates a new dcc editor
@@ -63,29 +62,27 @@ func (e *DCCEditor) Build() {
 	e.IsOpen(&e.Visible)
 	e.Flags(g.WindowFlagsAlwaysAutoResize)
 
-	if !e.selectPalette {
-		e.Layout(g.Layout{
-			dccwidget.Create(e.textureLoader, e.state, e.palette, e.Path.GetUniqueID(), e.dcc),
-		})
+	id := e.Path.GetUniqueID()
 
-		return
-	}
-
-	if e.selectPaletteWidget == nil {
-		e.selectPaletteWidget = selectpalettewidget.NewSelectPaletteWidget(
-			"##"+e.Path.GetUniqueID()+"SelectPaletteWidget",
+	if e.selectPalette {
+		selectPaletteWidget := selectpalettewidget.NewSelectPaletteWidget(
+			"##"+id+"SelectPaletteWidget",
 			e.Project,
 			e.config,
+		).IsOpen(&e.selectPalette).OnSelect(
 			func(colors *[256]d2interface.Color) {
 				e.palette = colors
 			},
-			func() {
-				e.selectPalette = false
-			},
 		)
+
+		e.Layout(selectPaletteWidget)
+
+		return
 	}
 
-	e.Layout(g.Layout{e.selectPaletteWidget})
+	e.Layout(
+		dccwidget.Create(e.textureLoader, e.state, e.palette, id, e.dcc),
+	)
 }
 
 // UpdateMainMenuLayout updates main menu to it contain editor's options