selectpalettewidget: use state to store mpq and project explorers

OpenDiablo2 · Jul 3, 2021 · 48e5427 · 48e5427
1 parent 22b1a25
commit 48e5427
Show file tree

Hide file tree

Showing 4 changed files with 130 additions and 111 deletions.
diff --git a/hswidget/select_palette_widget.go b/hswidget/select_palette_widget.go
@@ -1,6 +1,7 @@
 package hswidget
 
 import (
+	"fmt"
 	"log"
 	"path/filepath"
 
@@ -22,14 +23,24 @@ 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
-	isOpen          *bool
-	id              string
-	onSelect        func(colors *[256]d2interface.Color)
+	isOpen   *bool
+	id       string
+	onSelect func(colors *[256]d2interface.Color)
+	config   *hsconfig.Config
+	project  *hsproject.Project
 }
 
 // NewSelectPaletteWidget creates a select palette widget
@@ -39,71 +50,88 @@ func NewSelectPaletteWidget(
 	config *hsconfig.Config,
 ) *SelectPaletteWidget {
 	result := &SelectPaletteWidget{
-		id: id,
+		id:      id,
+		config:  config,
+		project: project,
 	}
 
-	callback := func(path *hscommon.PathEntry) {
-		bytes, bytesErr := path.GetFileBytes()
-		if bytesErr != nil {
-			log.Print(bytesErr)
+	return result
+}
 
-			return
-		}
+// OnSelect sets a callback for ppalette selection
+func (p *SelectPaletteWidget) OnSelect(cb func(colors *[256]d2interface.Color)) *SelectPaletteWidget {
+	p.onSelect = cb
+	return p
+}
 
-		ft, err := hsfiletypes.GetFileTypeFromExtension(filepath.Ext(path.FullPath), &bytes)
-		if err != nil {
-			log.Print(err)
+func (p *SelectPaletteWidget) getState() *selectPaletteState {
+	var state *selectPaletteState
 
-			return
-		}
+	stateID := fmt.Sprintf("selectPalette_%s", p.id)
+	s := giu.Context.GetState(stateID)
 
-		if ft == hsfiletypes.FileTypePalette {
-			// load new palette:
-			paletteData, err := path.GetFileBytes()
-			if err != nil {
-				log.Print(err)
+	if s != nil {
+		state = s.(*selectPaletteState)
+	} else {
+		state = &selectPaletteState{}
+		callback := func(path *hscommon.PathEntry) {
+			bytes, bytesErr := path.GetFileBytes()
+			if bytesErr != nil {
+				log.Print(bytesErr)
+
+				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)
+				}
 
-			if result.onSelect != nil {
-				result.onSelect(&colors)
-			}
+				palette, err := d2dat.Load(paletteData)
+				if err != nil {
+					log.Print(err)
+				}
 
-			*result.isOpen = false
-		}
-	}
+				colors := palette.GetColors()
 
-	mpqExplorer, err := hsmpqexplorer.Create(callback, config, 0, 0)
-	if err != nil {
-		log.Print(err)
-	}
+				if p.onSelect != nil {
+					p.onSelect(&colors)
+				}
 
-	mpqExplorer.SetProject(project)
+				*p.isOpen = false
+			}
+		}
 
-	result.mpqExplorer = mpqExplorer
+		mpqExplorer, err := hsmpqexplorer.Create(callback, p.config, 0, 0)
+		if err != nil {
+			log.Print(err)
+		}
 
-	projectExplorer, err := hsprojectexplorer.Create(nil, callback, 0, 0)
-	if err != nil {
-		log.Print(err)
-	}
+		mpqExplorer.SetProject(p.project)
 
-	projectExplorer.SetProject(project)
+		state.mpqExplorer = mpqExplorer
 
-	result.projectExplorer = projectExplorer
+		projectExplorer, err := hsprojectexplorer.Create(nil, callback, 0, 0)
+		if err != nil {
+			log.Print(err)
+		}
 
-	return result
-}
+		projectExplorer.SetProject(p.project)
 
-// OnSelect sets a callback for ppalette selection
-func (p *SelectPaletteWidget) OnSelect(cb func(colors *[256]d2interface.Color)) *SelectPaletteWidget {
-	p.onSelect = cb
-	return p
+		state.projectExplorer = projectExplorer
+		giu.Context.SetState(stateID, state)
+	}
+
+	return state
 }
 
 // IsOpen sets pointer to isOpen variable - determinates if a widget is visible
@@ -114,10 +142,11 @@ func (p *SelectPaletteWidget) IsOpen(isOpen *bool) *SelectPaletteWidget {
 
 // Build builds a widget
 func (p *SelectPaletteWidget) Build() {
+	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{
-			p.projectExplorer.GetProjectTreeNodes(),
-			giu.Layout(p.mpqExplorer.GetMpqTreeNodes()),
+			state.projectExplorer.GetProjectTreeNodes(),
+			giu.Layout(state.mpqExplorer.GetMpqTreeNodes()),
 			giu.Separator(),
 			giu.Button("Don't use any palette##"+p.id+"selectPaletteDonotUseAny").
 				Size(actionButtonW, actionButtonH).

diff --git a/hswindow/hseditor/hsdc6editor/dc6_editor.go b/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
@@ -70,19 +69,17 @@ func (e *DC6Editor) Build() {
 		return
 	}
 
-	if e.selectPaletteWidget == nil {
-		e.selectPaletteWidget = hswidget.NewSelectPaletteWidget(
-			e.Path.GetUniqueID()+"selectPalette",
-			e.Project,
-			e.config,
-		).IsOpen(&e.selectPalette).OnSelect(
-			func(palette *[256]d2interface.Color) {
-				e.palette = palette
-			},
-		)
-	}
-
-	e.Layout(e.selectPaletteWidget)
+	selectPaletteWidget := hswidget.NewSelectPaletteWidget(
+		e.Path.GetUniqueID()+"selectPalette",
+		e.Project,
+		e.config,
+	).IsOpen(&e.selectPalette).OnSelect(
+		func(palette *[256]d2interface.Color) {
+			e.palette = palette
+		},
+	)
+
+	e.Layout(selectPaletteWidget)
 }
 
 // UpdateMainMenuLayout updates main menu to it contain DC6's editor menu

diff --git a/hswindow/hseditor/hsdcceditor/dcc_editor.go b/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
@@ -71,19 +70,17 @@ func (e *DCCEditor) Build() {
 		return
 	}
 
-	if e.selectPaletteWidget == nil {
-		e.selectPaletteWidget = hswidget.NewSelectPaletteWidget(
-			"##"+e.Path.GetUniqueID()+"SelectPaletteWidget",
-			e.Project,
-			e.config,
-		).IsOpen(&e.selectPalette).OnSelect(
-			func(colors *[256]d2interface.Color) {
-				e.palette = colors
-			},
-		)
-	}
-
-	e.Layout(e.selectPaletteWidget)
+	selectPaletteWidget := hswidget.NewSelectPaletteWidget(
+		"##"+e.Path.GetUniqueID()+"SelectPaletteWidget",
+		e.Project,
+		e.config,
+	).IsOpen(&e.selectPalette).OnSelect(
+		func(colors *[256]d2interface.Color) {
+			e.palette = colors
+		},
+	)
+
+	e.Layout(selectPaletteWidget)
 }
 
 // UpdateMainMenuLayout updates main menu to it contain editor's options

diff --git a/hswindow/hseditor/hsdt1editor/dt1_editor.go b/hswindow/hseditor/hsdt1editor/dt1_editor.go
@@ -26,13 +26,12 @@ var _ hscommon.EditorWindow = &DT1Editor{}
 // DT1Editor represents a dt1 editor
 type DT1Editor struct {
 	*hseditor.Editor
-	dt1                 *d2dt1.DT1
-	textureLoader       hscommon.TextureLoader
-	config              *hsconfig.Config
-	selectPalette       bool
-	palette             *[256]d2interface.Color
-	selectPaletteWidget g.Widget
-	state               []byte
+	dt1           *d2dt1.DT1
+	textureLoader hscommon.TextureLoader
+	config        *hsconfig.Config
+	selectPalette bool
+	palette       *[256]d2interface.Color
+	state         []byte
 }
 
 // Create creates new dt1 editor
@@ -72,20 +71,17 @@ func (e *DT1Editor) Build() {
 		return
 	}
 
-	// create mpq explorer if doesn't exist for now
-	if e.selectPaletteWidget == nil {
-		e.selectPaletteWidget = hswidget.NewSelectPaletteWidget(
-			e.Path.GetUniqueID(),
-			e.Project,
-			e.config,
-		).IsOpen(&e.selectPalette).OnSelect(
-			func(colors *[256]d2interface.Color) {
-				e.palette = colors
-			},
-		)
-	}
-
-	e.Layout(e.selectPaletteWidget)
+	selectPaletteWidget := hswidget.NewSelectPaletteWidget(
+		e.Path.GetUniqueID(),
+		e.Project,
+		e.config,
+	).IsOpen(&e.selectPalette).OnSelect(
+		func(colors *[256]d2interface.Color) {
+			e.palette = colors
+		},
+	)
+
+	e.Layout(selectPaletteWidget)
 }
 
 // UpdateMainMenuLayout updates main menu layout to it contains editors options