Why is my Go event only being handled once per two events?

I have the following settings_manager.go

package main
type Settings struct {
globalTrackingDisabled      bool
textTracking                bool
imageTracking               bool
debug                       bool
Event                       chan string
EventTextTracking           string
EventImageTracking          string
EventGlobalTrackingDisabled string
EventDebugToggled           string
}
type DefaultValues struct {
GlobalTrackingDisabled bool
TextTracking           bool
ImageTracking          bool
DebugEnabled           bool
}
func NewSettings(defaults DefaultValues) *Settings {
return &Settings{
globalTrackingDisabled:      defaults.GlobalTrackingDisabled,
textTracking:                defaults.TextTracking,
imageTracking:               defaults.ImageTracking,
debug:                       defaults.DebugEnabled,
Event:                       make(chan string, 1),
EventTextTracking:           "textTracking",
EventImageTracking:          "imageTracking",
EventGlobalTrackingDisabled: "globalTrackingDisabled",
EventDebugToggled:           "debugToggled",
}
}
// Get the current value of textTracking
func (s *Settings) TextTrackingEnabled() bool {
return s.textTracking
}
// Get the current value of imageTracking
func (s *Settings) ImageTrackingEnabled() bool {
return s.imageTracking
}
// Get the current value of globalTrackingDisabled
func (s *Settings) GlobalTrackingDisabled() bool {
return s.globalTrackingDisabled
}
// Get inverse of TextTrackingEnabled()
func (s *Settings) TextTrackingDisabled() bool {
return !s.TextTrackingEnabled()
}
// Get inverse of ImageTrackingEnabled()
func (s *Settings) ImageTrackingDisabled() bool {
return !s.ImageTrackingEnabled()
}
// Get the inverse of GlobalTrackingDisabled()
func (s *Settings) GlobalTrackingEnabled() bool {
return !s.GlobalTrackingDisabled()
}
// Get the inverse of GlobalTrackingDisabled()
func (s *Settings) Debug() bool {
return s.debug
}
// SetGlobalTracking sets the globalTrackingDisabled property and fires an event
func (s *Settings) SetGlobalTracking(value bool) {
s.textTracking = value
s.Event <- s.EventGlobalTrackingDisabled
}
// SetTextTracking sets the textTracking property and fires an event
func (s *Settings) SetTextTracking(value bool) {
Debug("setter to ", value, s.EventTextTracking)
s.textTracking = value
s.Event <- s.EventTextTracking
Debug("Sent event %s\n", s.EventTextTracking)
}
// SetImageTracking sets the imageTracking property and fires an event
func (s *Settings) SetImageTracking(value bool) {
s.imageTracking = value
s.Event <- s.EventImageTracking
}
// SetDebug sets the debug property and fires an event
func (s *Settings) SetDebug(value bool) {
s.debug = value
s.Event <- s.EventDebugToggled
}
// DebugDisable sets the debug property to false and fires an event
func (s *Settings) DebugDisable() {
s.debug = false
s.Event <- s.EventDebugToggled
}
// DebugEnable sets the debug property to true and fires an event
func (s *Settings) DebugEnable() {
s.debug = true
s.Event <- s.EventDebugToggled
}

I have a systray menu item that I want to toggle the TextTracking setting when clicked.

// Click action

	go func() {
		for {
			select {
			case <-captureTextMenuItem.ClickedCh:
				Debug("Menu item clicked. New Value should be ", !captureTextMenuItem.Checked())
				if captureTextMenuItem.Checked() {
					settings.SetTextTracking(false)
				} else {
					settings.SetTextTracking(true)
				}
				//settings.SetTextTracking(!settings.TextTrackingEnabled())
				//Debug(settings.TextTrackingEnabled())
			}
		}
	}()

Here is how I am handling the event:

// event handler


	go func() {
		for {
			select {
			case event := <-settings.Event:
				Debug("Received Event", event)
				switch event {
				case settings.EventTextTracking:
					Debug("Ready to do something with the text event")
					if settings.TextTrackingEnabled() {
						Debug("Enabling checkmark")
						captureTextMenuItem.Check()
					} else {
						Debug("Removing checkmark")
						captureTextMenuItem.Uncheck()
					}
				case settings.EventGlobalTrackingDisabled:
					Debug("Ready to do something with the global tracker event")
					if settings.GlobalTrackingEnabled() {
						Debug("enabling global tracker")
						captureTextMenuItem.Enable()
					} else {
						Debug("disabling global tracker")
						captureTextMenuItem.Disabled()
					}
				default:
					fmt.Println("received unknown event:", event)
				}
			}
		}
	}()

The problem that I having is each time that I click the menu item, I can see that SetTextTracking is triggered, however, my event handler is only called once every two times the event is fired.

Because you use buffered channels.
You send a payload to the channel and nothing happens. When you send another payload the buffer will be flushed and the receiver side will start to run.

Try to use an unbuffered channel.