@GibranHL0 This is a good scenario for using an interface.

IIRC, giu.Widget is an interface that only needs a Build() method:

type Widget interface {
    Build()
}

There are a few things in common between the DCC and DC6 image files:

They both have directions, which are ordered sequences of images
They both are paletted images, so require a palette to be drawn.

with this information, we can define some interfaces to describe these commonalities:

type hasDirection interface {
	Direction() int
	SetDirection(int)
}

type hasFrames interface {
	Frame() int
	SetFrame(int)
}

type hasPalette interface {
	Palette() color.Palette
	SetPalette(color.Palette) error
}

Altogether, an AnimationWidget might look something like this:

type AnimationWidget interface {
	giu.Widget
	hasPalette
	hasDirection
	hasFrames
}

Exactly how you go about implementing is up to you, but I would try to separate the common stuff like this:

type state struct {
	currentDirection, currentFrame int
	palette color.Palette
}

type Widget struct {
	id            string
	*state
}

func (w *Widget) Build() {
	/*
	could do common stuff here,
	called from dcc or dc6 widget Build method
	*/
}

func (w *Widget) Palette() color.Palette {
	return w.state.palette
}

func (w *Widget) SetPalette(p color.Palette) error {
	if len(p) != colorsPerPalette {
		return fmt.Errorf("expected %v colors, but palette has %v colors", colorsPerPalette, len(p))
	}

	w.state.palette = p

	return nil
}

func (w *Widget) Frame() int {
	return w.state.currentFrame
}

func (w *Widget) SetFrame(n int) {
	w.state.currentFrame = n
}

func (w *Widget) Direction() int {
	return w.state.currentDirection
}

func (w *Widget) SetDirection(n int) {
	w.state.currentDirection = n
}

Then, the concrete animation widget implementations could look like this:

type Dc6Widget struct {
	*Widget
	dc6    *d2dc6.DC6
}

func (w *Dc6Widget) Build() {
	w.Widget.Build() // call the generic one

	// do DC6 specific stuff
}

type DccWidget struct {
	*Widget
	dcc    *d2dcc.DCC
}

func (w *DccWidget) Build() {
	w.Widget.Build() // call the generic one

	// do DCC specific stuff
}

EDIT:
It's also important to note that because *Widget is embedded inside of the DccWidget and Dc6Widget, the methods of Widget are also embedded! This means that Dc6Widget and DccWidget would implement the AnimationWidget interface. :)

You could check for this by adding the following code at the top of your file after the imports:

var _ AnimationWidget = &DccWidget{}
var _ AnimationWidget = &Dc6Widget{}

Those two lines will prevent the code from compiling if DccWidget or Dc6Widget do not implement AnimationWidget

Uh oh!

merge dccwidget and dc6widget #306

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

merge `dccwidget` and `dc6widget` #306