0.3.8 Cleanup logfile. /JL

canvas.go

@@ -13,18 +13,33 @@ type (
 )
 
 func CreateCanvasGroup(mw *MyMainWindow) {
-	log.Println("Creating canvas group...")
+	cg, err := walk.NewGroupBox(mw.content)
-	cg, _ := walk.NewGroupBox(mw.content)
+	if err != nil {
-	cg.SetTitle("Canvas")
+		log.Println("Error creating canvas group: ", err)
-	cg.SetAlignment(walk.AlignHNearVNear)
+	}
-	cg.SetLayout(walk.NewVBoxLayout())
+	err = cg.SetTitle("Canvas")
-	log.Println("Creating canvas...")
+	if err != nil {
-	mw.canvasScroll, _ = walk.NewScrollView(cg)
+		log.Println("Error setting canvas group title: ", err)
+	}
+	err = cg.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting canvas group alignment: ", err)
+	}
+	err = cg.SetLayout(walk.NewVBoxLayout())
+	if err != nil {
+		log.Println("Error setting canvas group layout: ", err)
+	}
+	mw.canvasScroll, err = walk.NewScrollView(cg)
+	if err != nil {
+		log.Println("Error creating canvas scroll: ", err)
+	}
 	vb := walk.NewVBoxLayout()
-	mw.canvasScroll.SetLayout(vb)
+	err = mw.canvasScroll.SetLayout(vb)
-	mw.canvasScroll.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
-	//vb.SetMargins(walk.Margins{0, 0, 0, 0})
+		log.Println("Error setting canvas scroll layout: ", err)
-	//dw, _ := walk.NewCustomWidgetPixels(mw.canvasScroll, 0, mw.drawStuff)
+	}
-	//dw.SetClearsBackground(true)
+	err = mw.canvasScroll.SetAlignment(walk.AlignHNearVNear)
-	//dw.SetInvalidatesOnResize(true)
+	if err != nil {
+		log.Println("Error setting canvas scroll alignment: ", err)
+	}
 }

color.go

@@ -40,7 +40,6 @@ type (
 )
 
 func ShowBeads(mw *MyMainWindow, serie string) {
-	log.Println("Showing beads...")
 	for _, bead := range mw.beads {
 		bead.Color.SetVisible(false)
 		for _, s := range bead.Series {
@@ -80,10 +79,7 @@ func CreateBeadsGroup(mw *MyMainWindow) {
 func LoadBeads(mw *MyMainWindow) {
 	for _, brand := range mw.pallette.Brand {
 		if brand.BrandName == mw.brand_combo.Text() {
-			log.Println("Loading beads for brand: " + brand.BrandName + " ...")
-			log.Println("Loading beads for serie: " + mw.serie_combo.Text() + " ...")
 			for _, bead := range brand.Colors {
-				log.Println("Loading bead: " + bead.ColorName + " ...")
 				if !bead.Disabled {
 					bc := NewBeadColor(mw, bead.ColorName, bead.ColorIndex, bead.Red, bead.Green, bead.Blue)
 					for _, s := range bead.Series.Serie {
@@ -108,7 +104,6 @@ func LoadBeads(mw *MyMainWindow) {
 
 func NewBeadColor(mw *MyMainWindow, name string, id int, red byte, green byte, blue byte) *BeadColor {
 	var err error
-	log.Println("Creating bead color: " + name + " ...")
 	cm, _ := walk.NewComposite(mw.colors)
 	cm.SetAlignment(walk.AlignHNearVCenter)
 	hb := walk.NewHBoxLayout()
@@ -116,17 +111,15 @@ func NewBeadColor(mw *MyMainWindow, name string, id int, red byte, green byte, b
 	cm.SetLayout(hb)
 	color := new(BeadColor)
 	color.Color = cm
-	log.Println("Bead color struct: ", color)
 	color.SetBackgroundColor(walk.RGB(red, green, blue))
-	log.Println("Creating checkbox")
 	color.Checkbox, err = walk.NewCheckBox(cm)
 	if err != nil {
 		log.Panic(err)
 	}
-	log.Println("Checkbox created")
+	err = color.Checkbox.SetText(name)
-	log.Println("Setting checkbox name")
+	if err != nil {
-	color.Checkbox.SetText(name)
+		log.Panic(err)
-	log.Println("Checkbox name set")
+	}
 	walk.NewHSpacer(cm)
 	color.add, err = walk.NewImageView(cm)
 	if err != nil {
@@ -146,7 +139,13 @@ func NewBeadColor(mw *MyMainWindow, name string, id int, red byte, green byte, b
 				}
 			}
 			val := mw.addBeads(name, data, color.ColorID, color.backgroundColor, ret)
-			log.Println("Returned value: ", val)
+			if val == 1 {
+				log.Println("Accepted")
+			} else if val == 2 {
+				log.Println("Canceled")
+			} else {
+				log.Println("Returned value: ", val)
+			}
 		}
 	})
 	color.info, err = walk.NewImageView(cm)

main.go

@@ -30,7 +30,7 @@ type MyMainWindow struct {
 
 const (
 	AppName   string = "BeadImager"
-	Version   string = "0.3.7"
+	Version   string = "0.3.8"
 	CopyRight string = "©2022 Jan Lerking"
 	STD_MESS  string = "Ready"
 	LogFile   string = "BeadImager.log"
@@ -92,167 +92,12 @@ func main() {
 	SetupMainWindow(mw)
 	log.Println("MainWindow created")
 	CreatePallette(mw)
-	log.Println("Pallette created: ", mw.pallette)
 	mw.brand_model = CreateBrandsList(mw)
 	CreatePalletteGroup(mw)
 	CreateBeadsGroup(mw)
 	CreateCanvasGroup(mw)
 	CreateProperties(mw)
 
-	/*
-		DD_Pallette := GroupBox{
-			Title:  "Pallette",
-			Layout: VBox{},
-			Children: []Widget{
-				Composite{
-					Layout: HBox{MarginsZero: true},
-					Children: []Widget{
-						Label{
-							Text: "Brand:",
-						},
-						ComboBox{
-							Alignment: AlignHFarVCenter,
-							AssignTo:  &mw.brand_combo,
-							Model:     mw.brand_model,
-							Value:     ConfigBrand,
-							OnCurrentIndexChanged: func() {
-								if !brand_trigged {
-									log.Println("Brand changed to: ", mw.brand_combo.Text())
-									mw.serie_model = CreateSeriesList(mw)
-									mw.serie_combo.SetModel(mw.serie_model)
-									mw.serie_combo.SetEnabled(true)
-									mw.serie_combo.SetText(ConfigSerie)
-								}
-								brand_trigged = true
-							},
-						},
-					},
-				},
-				Composite{
-					Layout: HBox{MarginsZero: true},
-					Children: []Widget{
-						Label{
-							Text: "Serie:",
-						},
-						ComboBox{
-							Alignment: AlignHFarVCenter,
-							AssignTo:  &mw.serie_combo,
-							Enabled:   false,
-							OnCurrentIndexChanged: func() {
-								if !serie_trigged {
-									log.Println("Serie changed to: ", mw.serie_combo.Text())
-									LoadBeads(mw)
-									log.Println("Beads loaded: ", mw.beads)
-									mw.pegboard_model = CreatePegboardsList(mw)
-									mw.pegboard_combo.SetModel(mw.pegboard_model)
-									mw.pegboard_combo.SetEnabled(true)
-								}
-								serie_trigged = true
-							},
-						},
-					},
-				},
-				Composite{
-					Layout: HBox{MarginsZero: true},
-					Children: []Widget{
-						Label{
-							Text: "Pegboard:",
-						},
-						ComboBox{
-							Alignment: AlignHFarVCenter,
-							AssignTo:  &mw.pegboard_combo,
-							Enabled:   false,
-							OnCurrentIndexChanged: func() {
-								if !pegboard_trigged {
-									log.Println("Pegboard changed to: ", mw.pegboard_combo.Text())
-								}
-								pegboard_trigged = true
-							},
-						},
-					},
-				},
-			},
-		}
-
-		DD_Beads := GroupBox{
-			Title:  "Beads",
-			Layout: VBox{},
-			Children: []Widget{
-				PushButton{
-					Text: "Select all colors",
-					OnClicked: func() {
-						for _, c := range mw.beads {
-							c.Checkbox.SetChecked(true)
-						}
-					},
-				},
-				ScrollView{
-					AssignTo: &mw.colors,
-					Layout:   VBox{MarginsZero: true},
-				},
-			},
-		}
-
-			if _, err := (MainWindow{
-				AssignTo: &mw.MainWindow,
-				Title:    AppName + " " + Version,
-				MinSize:  Size{800, 600},
-				OnSizeChanged: func() {
-					if !settings_trigged {
-						ShowProperties(mw)
-						settings_trigged = true
-					}
-				},
-				Layout: VBox{MarginsZero: true},
-				Children: []Widget{
-					Composite{
-						AssignTo: &mw.leftPanel,
-						Layout:   HBox{},
-						Children: []Widget{
-							Composite{
-								Layout:  VBox{MarginsZero: true},
-								MaxSize: Size{280, 0},
-								Children: []Widget{
-									DD_Pallette,
-									DD_Beads,
-								},
-							},
-							GroupBox{
-								Title:  "Canvas",
-								Layout: VBox{},
-								Children: []Widget{
-									ScrollView{
-										AssignTo: &mw.canvasScroll,
-										Layout:   VBox{MarginsZero: true},
-										Children: []Widget{
-											CustomWidget{
-												AssignTo:            &mw.drawWidget,
-												ClearsBackground:    true,
-												InvalidatesOnResize: true,
-												Paint:               mw.drawStuff,
-											},
-										},
-									},
-								},
-							},
-							GroupBox{
-								Title:   "Settings",
-								Layout:  VBox{},
-								MaxSize: Size{220, 0},
-								Children: []Widget{
-									ScrollView{
-										AssignTo: &mw.propScroll,
-										Layout:   VBox{MarginsZero: true},
-									},
-								},
-							},
-						},
-					},
-				},
-			}.Run()); err != nil {
-				log.Fatal(err)
-			}
-	*/
 	mw.MainWindow.Show()
 	mw.MainWindow.Run()
 }

pallette.go

@@ -174,7 +174,7 @@ func CreatePegboardsList(mw *MyMainWindow) {
 			mw.Pegboards.Boards = append(mw.Pegboards.Boards, *pb)
 		}
 	}
-	log.Println("Pegboard: ", mw.Pegboards)
+	//log.Println("Pegboard: ", mw.Pegboards)
 }
 
 func CreateSeriesList(mw *MyMainWindow) []string {

properties.go

@@ -39,110 +39,230 @@ func CreateProperties(mw *MyMainWindow) {
 }
 
 func CreateSettingsGroup(mw *MyMainWindow) {
-	log.Println("Setting up settings...")
+	var err error
-	mw.rightPanel, _ = walk.NewComposite(mw.content)
+	//log.Println("Setting up settings...")
+	mw.rightPanel, err = walk.NewComposite(mw.content)
+	if err != nil {
+		log.Println("Error creating right panel: ", err)
+	}
 	vb := walk.NewVBoxLayout()
-	mw.rightPanel.SetLayout(vb)
+	err = mw.rightPanel.SetLayout(vb)
-	vb.SetMargins(walk.Margins{0, 0, 0, 0})
+	if err != nil {
+		log.Println("Error setting right panel layout: ", err)
+	}
+	err = vb.SetMargins(walk.Margins{0, 0, 0, 0})
+	if err != nil {
+		log.Println("Error setting right panel margins: ", err)
+	}
 	mw.rightPanel.SetMinMaxSize(walk.Size{Width: 220, Height: 0}, walk.Size{Width: 220, Height: 0})
-	sg, _ := walk.NewGroupBox(mw.rightPanel)
+	sg, err := walk.NewGroupBox(mw.rightPanel)
-	sg.SetTitle("Settings")
+	if err != nil {
-	sg.SetAlignment(walk.AlignHNearVNear)
+		log.Println("Error creating settings group: ", err)
+	}
+	err = sg.SetTitle("Settings")
+	if err != nil {
+		log.Println("Error setting settings group title: ", err)
+	}
+	err = sg.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting settings group alignment: ", err)
+	}
 	vb = walk.NewVBoxLayout()
-	sg.SetLayout(vb)
+	err = sg.SetLayout(vb)
-	mw.propScroll, _ = walk.NewScrollView(sg)
+	if err != nil {
+		log.Println("Error setting settings group layout: ", err)
+	}
+	mw.propScroll, err = walk.NewScrollView(sg)
+	if err != nil {
+		log.Println("Error creating property scroll: ", err)
+	}
 	vb = walk.NewVBoxLayout()
-	mw.propScroll.SetLayout(vb)
+	err = mw.propScroll.SetLayout(vb)
-	vb.SetMargins(walk.Margins{0, 0, 0, 0})
+	if err != nil {
+		log.Println("Error setting property scroll layout: ", err)
+	}
+	err = vb.SetMargins(walk.Margins{0, 0, 0, 0})
+	if err != nil {
+		log.Println("Error setting property scroll margins: ", err)
+	}
 	CreateColorProperties(mw)
 	CreateScaleProperties(mw)
 	CreateCanvasProperties(mw)
 }
 
 func CreateColorProperties(mw *MyMainWindow) {
-	log.Println("Creating color properties...")
+	var err error
-	mw.properties.propColor.property, _ = walk.NewComposite(mw.propScroll)
+	//log.Println("Creating color properties...")
-	mw.properties.propColor.property.SetAlignment(walk.AlignHNearVNear)
+	mw.properties.propColor.property, err = walk.NewComposite(mw.propScroll)
+	if err != nil {
+		log.Println("Error creating color property: ", err)
+	}
+	err = mw.properties.propColor.property.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting color property alignment: ", err)
+	}
 	vb := walk.NewVBoxLayout()
-	//vb.SetMargins(walk.Margins{5, 0, 5, 0})
+	err = mw.properties.propColor.property.SetLayout(vb)
-	mw.properties.propColor.property.SetLayout(vb)
+	if err != nil {
-	log.Println("Creating color label...")
+		log.Println("Error setting color property layout: ", err)
-	lbl, _ := walk.NewTextLabel(mw.properties.propColor.property)
+	}
-	log.Println("Setting color label text...")
+	lbl, err := walk.NewTextLabel(mw.properties.propColor.property)
-	lbl.SetText("Color: ")
+	if err != nil {
-	log.Println("Creating color background brush...")
+		log.Println("Error creating color label: ", err)
-	bg, _ := walk.NewSolidColorBrush(walk.RGB(167, 45, 234))
+	}
-	log.Println("Setting color background...")
+	err = lbl.SetText("Color: ")
+	if err != nil {
+		log.Println("Error setting color label text: ", err)
+	}
+	bg, err := walk.NewSolidColorBrush(walk.RGB(167, 45, 234))
+	if err != nil {
+		log.Println("Error creating color brush: ", err)
+	}
 	mw.properties.propColor.property.SetBackground(bg)
 }
 
 func CreateScaleProperties(mw *MyMainWindow) {
-	log.Println("Creating scale properties...")
+	var err error
-	mw.properties.propScale.property, _ = walk.NewComposite(mw.propScroll)
+	mw.properties.propScale.property, err = walk.NewComposite(mw.propScroll)
-	mw.properties.propScale.property.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error creating scale property: ", err)
+	}
+	err = mw.properties.propScale.property.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting scale property alignment: ", err)
+	}
 	vb := walk.NewVBoxLayout()
-	//vb.SetMargins(walk.Margins{5, 0, 5, 0})
+	err = mw.properties.propScale.property.SetLayout(vb)
-	mw.properties.propScale.property.SetLayout(vb)
+	if err != nil {
-	grcom, _ := walk.NewComposite(mw.properties.propScale.property)
+		log.Println("Error setting scale property layout: ", err)
-	grcom.SetAlignment(walk.AlignHNearVNear)
+	}
+	grcom, err := walk.NewComposite(mw.properties.propScale.property)
+	if err != nil {
+		log.Println("Error creating scale group: ", err)
+	}
+	err = grcom.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting scale group alignment: ", err)
+	}
 	hb := walk.NewVBoxLayout()
-	hb.SetMargins(walk.Margins{0, 0, 0, 0})
+	err = hb.SetMargins(walk.Margins{0, 0, 0, 0})
-	grcom.SetLayout(hb)
+	if err != nil {
-	log.Println("Creating scale label...")
+		log.Println("Error setting scale group margins: ", err)
-	lbl, _ := walk.NewTextLabel(grcom)
+	}
-	log.Println("Setting scale label text...")
+	err = grcom.SetLayout(hb)
-	lbl.SetText("Scale:")
+	if err != nil {
-	log.Println("Creating scale slider...")
+		log.Println("Error setting scale group layout: ", err)
-	slider, _ := walk.NewSlider(grcom)
+	}
-	log.Println("Setting scale slider properties...")
+	lbl, err := walk.NewTextLabel(grcom)
+	if err != nil {
+		log.Println("Error creating scale label: ", err)
+	}
+	err = lbl.SetText("Scale:")
+	if err != nil {
+		log.Println("Error setting scale label text: ", err)
+	}
+	slider, err := walk.NewSlider(grcom)
+	if err != nil {
+		log.Println("Error creating scale slider: ", err)
+	}
 	slider.SetTracking(true)
 	slider.SetRange(10, 200)
-	val, _ := strconv.Atoi(ConfigScale)
+	val, err := strconv.Atoi(ConfigScale)
+	if err != nil {
+		log.Println("Error converting scale config value to int: ", err)
+	}
 	slider.SetValue(val)
-	sc, _ := walk.NewNumberEdit(grcom)
+	sc, err := walk.NewNumberEdit(grcom)
+	if err != nil {
+		log.Println("Error creating scale number edit: ", err)
+	}
 	slider.ValueChanged().Attach(func() {
 		log.Println("Scale slider value changed")
 		nn := float64(slider.Value())
-		log.Println("Setting scale number edit value to: ", nn)
+		err = sc.SetValue(nn)
-		sc.SetValue(nn)
+		if err != nil {
+			log.Println("Error setting scale number edit value: ", err)
+		}
 		SetConfigScale(fmt.Sprintf("%0.0f", nn))
 	})
-	sc.SetDecimals(0)
+	err = sc.SetDecimals(0)
-	sc.SetRange(10, 200)
+	if err != nil {
+		log.Println("Error setting scale number edit decimals: ", err)
+	}
+	err = sc.SetRange(10, 200)
+	if err != nil {
+		log.Println("Error setting scale number edit range: ", err)
+	}
 	nn := float64(slider.Value())
-	sc.SetValue(nn)
+	err = sc.SetValue(nn)
+	if err != nil {
+		log.Println("Error setting scale number edit value: ", err)
+	}
 	sc.ValueChanged().Attach(func() {
 		log.Println("Scale number edit value changed")
 		nn := float64(sc.Value())
-		log.Println("Setting scale slider value to: ", nn)
 		slider.SetValue(int(nn))
 		SetConfigScale(fmt.Sprintf("%0.0f", nn))
 	})
-	log.Println("Setting background color...")
+	bg, err := walk.NewSolidColorBrush(walk.RGB(255, 255, 255))
-	bg, _ := walk.NewSolidColorBrush(walk.RGB(255, 255, 255))
+	if err != nil {
+		log.Println("Error creating scale brush: ", err)
+	}
 	mw.properties.propScale.property.SetBackground(bg)
 }
 
 func CreateCanvasProperties(mw *MyMainWindow) {
-	log.Println("Creating canvas properties...")
+	var err error
-	mw.properties.propCanvas.property, _ = walk.NewComposite(mw.propScroll)
+	mw.properties.propCanvas.property, err = walk.NewComposite(mw.propScroll)
-	mw.properties.propCanvas.property.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error creating canvas property: ", err)
+	}
+	err = mw.properties.propCanvas.property.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting canvas property alignment: ", err)
+	}
 	vb := walk.NewVBoxLayout()
-	//vb.SetMargins(walk.Margins{5, 0, 5, 0})
+	err = mw.properties.propCanvas.property.SetLayout(vb)
-	mw.properties.propCanvas.property.SetLayout(vb)
+	if err != nil {
-	log.Println("Creating canvas label...")
+		log.Println("Error setting canvas property layout: ", err)
-	lbl, _ := walk.NewTextLabel(mw.properties.propCanvas.property)
+	}
-	log.Println("Setting canvas label text...")
+	lbl, err := walk.NewTextLabel(mw.properties.propCanvas.property)
-	lbl.SetText("Canvas:")
+	if err != nil {
-	grcom, _ := walk.NewComposite(mw.properties.propCanvas.property)
+		log.Println("Error creating canvas label: ", err)
-	grcom.SetAlignment(walk.AlignHNearVNear)
+	}
+	err = lbl.SetText("Canvas:")
+	if err != nil {
+		log.Println("Error setting canvas label text: ", err)
+	}
+	grcom, err := walk.NewComposite(mw.properties.propCanvas.property)
+	if err != nil {
+		log.Println("Error creating canvas group: ", err)
+	}
+	err = grcom.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting canvas group alignment: ", err)
+	}
 	hb := walk.NewHBoxLayout()
-	hb.SetMargins(walk.Margins{0, 0, 0, 0})
+	err = hb.SetMargins(walk.Margins{0, 0, 0, 0})
-	grcom.SetLayout(hb)
+	if err != nil {
-	log.Println("Creating grid checkbox")
+		log.Println("Error setting canvas group margins: ", err)
-	cb, _ := walk.NewCheckBox(grcom)
+	}
-	cb.SetAlignment(walk.AlignHNearVNear)
+	err = grcom.SetLayout(hb)
-	cb.SetText("Show grid")
+	if err != nil {
+		log.Println("Error setting canvas group layout: ", err)
+	}
+	cb, err := walk.NewCheckBox(grcom)
+	if err != nil {
+		log.Println("Error creating canvas checkbox: ", err)
+	}
+	err = cb.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting canvas checkbox alignment: ", err)
+	}
+	err = cb.SetText("Show grid")
+	if err != nil {
+		log.Println("Error setting canvas checkbox text: ", err)
+	}
 	switch ConfigShowGrid {
 	case "true":
 		cb.SetChecked(true)
@@ -157,21 +277,35 @@ func CreateCanvasProperties(mw *MyMainWindow) {
 			SetConfigShowGrid("true")
 		}
 	})
-	log.Println("Grid checkbox created")
 	walk.NewHSpacer(grcom)
-	log.Println("Creating grid color button")
+	grcolb, err := walk.NewPushButton(grcom)
-	grcolb, _ := walk.NewPushButton(grcom)
+	if err != nil {
-	cb.SetAlignment(walk.AlignHFarVNear)
+		log.Println("Error creating grid color button: ", err)
-	grcolb.SetText("Grid color")
+	}
+	err = cb.SetAlignment(walk.AlignHFarVNear)
+	if err != nil {
+		log.Println("Error setting grid color button alignment: ", err)
+	}
+	err = grcolb.SetText("Grid color")
+	if err != nil {
+		log.Println("Error setting grid color button text: ", err)
+	}
 	grcolb.Clicked().Attach(func() {
 		log.Println("Grid color button clicked")
 		mw.openImage()
 	})
-	log.Println("Grid color button created")
+	cb, err = walk.NewCheckBox(mw.properties.propCanvas.property)
-	log.Println("Creating pixels checkbox")
+	if err != nil {
-	cb, _ = walk.NewCheckBox(mw.properties.propCanvas.property)
+		log.Println("Error creating pixels checkbox: ", err)
-	cb.SetAlignment(walk.AlignHNearVNear)
+	}
-	cb.SetText("Show pixels as beads")
+	err = cb.SetAlignment(walk.AlignHNearVNear)
+	if err != nil {
+		log.Println("Error setting pixels checkbox alignment: ", err)
+	}
+	err = cb.SetText("Show pixels as beads")
+	if err != nil {
+		log.Println("Error setting pixels checkbox text: ", err)
+	}
 	switch ConfigShowBeads {
 	case "true":
 		cb.SetChecked(true)
@@ -186,16 +320,25 @@ func CreateCanvasProperties(mw *MyMainWindow) {
 			SetConfigShowBeads("true")
 		}
 	})
-	log.Println("Pixels checkbox created")
+	grcolb, err = walk.NewPushButton(mw.properties.propCanvas.property)
-	log.Println("Creating canvas background color button")
+	if err != nil {
-	grcolb, _ = walk.NewPushButton(mw.properties.propCanvas.property)
+		log.Println("Error creating background color button: ", err)
-	grcolb.SetAlignment(walk.AlignHFarVNear)
+	}
-	grcolb.SetText("Background color")
+	err = grcolb.SetAlignment(walk.AlignHFarVNear)
+	if err != nil {
+		log.Println("Error setting background color button alignment: ", err)
+	}
+	err = grcolb.SetText("Background color")
+	if err != nil {
+		log.Println("Error setting background color button text: ", err)
+	}
 	grcolb.Clicked().Attach(func() {
 		log.Println("Background color button clicked")
 		mw.openImage()
 	})
-	log.Println("Background color button created")
+	bg, err := walk.NewSolidColorBrush(walk.RGB(255, 255, 255))
-	bg, _ := walk.NewSolidColorBrush(walk.RGB(255, 255, 255))
+	if err != nil {
+		log.Println("Error creating canvas brush: ", err)
+	}
 	mw.properties.propCanvas.property.SetBackground(bg)
 }