// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"github.com/bnema/dumber/internal/domain/entity"
	"github.com/bnema/dumber/internal/ui/layout"
	"github.com/jwijenbergh/puregotk/v4/gtk"
	mock "github.com/stretchr/testify/mock"
)

// NewMockPaneViewFactory creates a new instance of MockPaneViewFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockPaneViewFactory(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPaneViewFactory {
	mock := &MockPaneViewFactory{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockPaneViewFactory is an autogenerated mock type for the PaneViewFactory type
type MockPaneViewFactory struct {
	mock.Mock
}

type MockPaneViewFactory_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPaneViewFactory) EXPECT() *MockPaneViewFactory_Expecter {
	return &MockPaneViewFactory_Expecter{mock: &_m.Mock}
}

// CreatePaneView provides a mock function for the type MockPaneViewFactory
func (_mock *MockPaneViewFactory) CreatePaneView(node *entity.PaneNode) layout.Widget {
	ret := _mock.Called(node)

	if len(ret) == 0 {
		panic("no return value specified for CreatePaneView")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func(*entity.PaneNode) layout.Widget); ok {
		r0 = returnFunc(node)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockPaneViewFactory_CreatePaneView_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePaneView'
type MockPaneViewFactory_CreatePaneView_Call struct {
	*mock.Call
}

// CreatePaneView is a helper method to define mock.On call
//   - node *entity.PaneNode
func (_e *MockPaneViewFactory_Expecter) CreatePaneView(node interface{}) *MockPaneViewFactory_CreatePaneView_Call {
	return &MockPaneViewFactory_CreatePaneView_Call{Call: _e.mock.On("CreatePaneView", node)}
}

func (_c *MockPaneViewFactory_CreatePaneView_Call) Run(run func(node *entity.PaneNode)) *MockPaneViewFactory_CreatePaneView_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *entity.PaneNode
		if args[0] != nil {
			arg0 = args[0].(*entity.PaneNode)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPaneViewFactory_CreatePaneView_Call) Return(widget layout.Widget) *MockPaneViewFactory_CreatePaneView_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockPaneViewFactory_CreatePaneView_Call) RunAndReturn(run func(node *entity.PaneNode) layout.Widget) *MockPaneViewFactory_CreatePaneView_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockWidget creates a new instance of MockWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWidget {
	mock := &MockWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockWidget is an autogenerated mock type for the Widget type
type MockWidget struct {
	mock.Mock
}

type MockWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWidget) EXPECT() *MockWidget_Expecter {
	return &MockWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockWidget
func (_mock *MockWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockWidget_Expecter) AddController(controller interface{}) *MockWidget_AddController_Call {
	return &MockWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_AddController_Call) Return() *MockWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockWidget
func (_mock *MockWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockWidget_Expecter) AddCssClass(cssClass interface{}) *MockWidget_AddCssClass_Call {
	return &MockWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_AddCssClass_Call) Return() *MockWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockWidget
func (_mock *MockWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockWidget_Expecter) ComputePoint(target interface{}) *MockWidget_ComputePoint_Call {
	return &MockWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockWidget
func (_mock *MockWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GetAllocatedHeight() *MockWidget_GetAllocatedHeight_Call {
	return &MockWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockWidget_GetAllocatedHeight_Call) Run(run func()) *MockWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GetAllocatedHeight_Call) Return(n int) *MockWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockWidget
func (_mock *MockWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GetAllocatedWidth() *MockWidget_GetAllocatedWidth_Call {
	return &MockWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockWidget_GetAllocatedWidth_Call) Run(run func()) *MockWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GetAllocatedWidth_Call) Return(n int) *MockWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockWidget
func (_mock *MockWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GetHexpand() *MockWidget_GetHexpand_Call {
	return &MockWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockWidget_GetHexpand_Call) Run(run func()) *MockWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GetHexpand_Call) Return(b bool) *MockWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockWidget
func (_mock *MockWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GetParent() *MockWidget_GetParent_Call {
	return &MockWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockWidget_GetParent_Call) Run(run func()) *MockWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GetParent_Call) Return(widget layout.Widget) *MockWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockWidget
func (_mock *MockWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GetVexpand() *MockWidget_GetVexpand_Call {
	return &MockWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockWidget_GetVexpand_Call) Run(run func()) *MockWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GetVexpand_Call) Return(b bool) *MockWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockWidget
func (_mock *MockWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GrabFocus() *MockWidget_GrabFocus_Call {
	return &MockWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockWidget_GrabFocus_Call) Run(run func()) *MockWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GrabFocus_Call) Return(b bool) *MockWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockWidget
func (_mock *MockWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockWidget_Expecter) GtkWidget() *MockWidget_GtkWidget_Call {
	return &MockWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockWidget_GtkWidget_Call) Run(run func()) *MockWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockWidget
func (_mock *MockWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockWidget_Expecter) HasCssClass(cssClass interface{}) *MockWidget_HasCssClass_Call {
	return &MockWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_HasCssClass_Call) Return(b bool) *MockWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockWidget
func (_mock *MockWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockWidget_Expecter) HasFocus() *MockWidget_HasFocus_Call {
	return &MockWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockWidget_HasFocus_Call) Run(run func()) *MockWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_HasFocus_Call) Return(b bool) *MockWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockWidget
func (_mock *MockWidget) Hide() {
	_mock.Called()
	return
}

// MockWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockWidget_Expecter) Hide() *MockWidget_Hide_Call {
	return &MockWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockWidget_Hide_Call) Run(run func()) *MockWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_Hide_Call) Return() *MockWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_Hide_Call) RunAndReturn(run func()) *MockWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockWidget
func (_mock *MockWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockWidget_Expecter) IsVisible() *MockWidget_IsVisible_Call {
	return &MockWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockWidget_IsVisible_Call) Run(run func()) *MockWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_IsVisible_Call) Return(b bool) *MockWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockWidget
func (_mock *MockWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockWidget_RemoveCssClass_Call {
	return &MockWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_RemoveCssClass_Call) Return() *MockWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockWidget
func (_mock *MockWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockWidget_Expecter) SetCanFocus(canFocus interface{}) *MockWidget_SetCanFocus_Call {
	return &MockWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetCanFocus_Call) Return() *MockWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockWidget
func (_mock *MockWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockWidget_Expecter) SetCanTarget(canTarget interface{}) *MockWidget_SetCanTarget_Call {
	return &MockWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetCanTarget_Call) Return() *MockWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockWidget
func (_mock *MockWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockWidget_SetFocusOnClick_Call {
	return &MockWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetFocusOnClick_Call) Return() *MockWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockWidget
func (_mock *MockWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockWidget_Expecter) SetHalign(align interface{}) *MockWidget_SetHalign_Call {
	return &MockWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetHalign_Call) Return() *MockWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockWidget
func (_mock *MockWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockWidget_Expecter) SetHexpand(expand interface{}) *MockWidget_SetHexpand_Call {
	return &MockWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockWidget_SetHexpand_Call) Run(run func(expand bool)) *MockWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetHexpand_Call) Return() *MockWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockWidget
func (_mock *MockWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockWidget_SetSizeRequest_Call {
	return &MockWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWidget_SetSizeRequest_Call) Return() *MockWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockWidget
func (_mock *MockWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockWidget_Expecter) SetValign(align interface{}) *MockWidget_SetValign_Call {
	return &MockWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetValign_Call) Return() *MockWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockWidget
func (_mock *MockWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockWidget_Expecter) SetVexpand(expand interface{}) *MockWidget_SetVexpand_Call {
	return &MockWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockWidget_SetVexpand_Call) Run(run func(expand bool)) *MockWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetVexpand_Call) Return() *MockWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockWidget
func (_mock *MockWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockWidget_Expecter) SetVisible(visible interface{}) *MockWidget_SetVisible_Call {
	return &MockWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockWidget_SetVisible_Call) Run(run func(visible bool)) *MockWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidget_SetVisible_Call) Return() *MockWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockWidget
func (_mock *MockWidget) Show() {
	_mock.Called()
	return
}

// MockWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockWidget_Expecter) Show() *MockWidget_Show_Call {
	return &MockWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockWidget_Show_Call) Run(run func()) *MockWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_Show_Call) Return() *MockWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_Show_Call) RunAndReturn(run func()) *MockWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockWidget
func (_mock *MockWidget) Unparent() {
	_mock.Called()
	return
}

// MockWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockWidget_Expecter) Unparent() *MockWidget_Unparent_Call {
	return &MockWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockWidget_Unparent_Call) Run(run func()) *MockWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidget_Unparent_Call) Return() *MockWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockWidget_Unparent_Call) RunAndReturn(run func()) *MockWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockPanedWidget creates a new instance of MockPanedWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockPanedWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPanedWidget {
	mock := &MockPanedWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockPanedWidget is an autogenerated mock type for the PanedWidget type
type MockPanedWidget struct {
	mock.Mock
}

type MockPanedWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPanedWidget) EXPECT() *MockPanedWidget_Expecter {
	return &MockPanedWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockPanedWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockPanedWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockPanedWidget_Expecter) AddController(controller interface{}) *MockPanedWidget_AddController_Call {
	return &MockPanedWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockPanedWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockPanedWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_AddController_Call) Return() *MockPanedWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockPanedWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockPanedWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockPanedWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockPanedWidget_Expecter) AddCssClass(cssClass interface{}) *MockPanedWidget_AddCssClass_Call {
	return &MockPanedWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockPanedWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_AddCssClass_Call) Return() *MockPanedWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockPanedWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// AddTickCallback provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) AddTickCallback(callback func() bool) uint {
	ret := _mock.Called(callback)

	if len(ret) == 0 {
		panic("no return value specified for AddTickCallback")
	}

	var r0 uint
	if returnFunc, ok := ret.Get(0).(func(func() bool) uint); ok {
		r0 = returnFunc(callback)
	} else {
		r0 = ret.Get(0).(uint)
	}
	return r0
}

// MockPanedWidget_AddTickCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTickCallback'
type MockPanedWidget_AddTickCallback_Call struct {
	*mock.Call
}

// AddTickCallback is a helper method to define mock.On call
//   - callback func() bool
func (_e *MockPanedWidget_Expecter) AddTickCallback(callback interface{}) *MockPanedWidget_AddTickCallback_Call {
	return &MockPanedWidget_AddTickCallback_Call{Call: _e.mock.On("AddTickCallback", callback)}
}

func (_c *MockPanedWidget_AddTickCallback_Call) Run(run func(callback func() bool)) *MockPanedWidget_AddTickCallback_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func() bool
		if args[0] != nil {
			arg0 = args[0].(func() bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_AddTickCallback_Call) Return(v uint) *MockPanedWidget_AddTickCallback_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockPanedWidget_AddTickCallback_Call) RunAndReturn(run func(callback func() bool) uint) *MockPanedWidget_AddTickCallback_Call {
	_c.Call.Return(run)
	return _c
}

// ComputePoint provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockPanedWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockPanedWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockPanedWidget_Expecter) ComputePoint(target interface{}) *MockPanedWidget_ComputePoint_Call {
	return &MockPanedWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockPanedWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockPanedWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockPanedWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockPanedWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockPanedWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectMap provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) ConnectMap(callback func()) uint32 {
	ret := _mock.Called(callback)

	if len(ret) == 0 {
		panic("no return value specified for ConnectMap")
	}

	var r0 uint32
	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
		r0 = returnFunc(callback)
	} else {
		r0 = ret.Get(0).(uint32)
	}
	return r0
}

// MockPanedWidget_ConnectMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectMap'
type MockPanedWidget_ConnectMap_Call struct {
	*mock.Call
}

// ConnectMap is a helper method to define mock.On call
//   - callback func()
func (_e *MockPanedWidget_Expecter) ConnectMap(callback interface{}) *MockPanedWidget_ConnectMap_Call {
	return &MockPanedWidget_ConnectMap_Call{Call: _e.mock.On("ConnectMap", callback)}
}

func (_c *MockPanedWidget_ConnectMap_Call) Run(run func(callback func())) *MockPanedWidget_ConnectMap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func()
		if args[0] != nil {
			arg0 = args[0].(func())
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_ConnectMap_Call) Return(v uint32) *MockPanedWidget_ConnectMap_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockPanedWidget_ConnectMap_Call) RunAndReturn(run func(callback func()) uint32) *MockPanedWidget_ConnectMap_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectNotifyPosition provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) ConnectNotifyPosition(callback func()) uint32 {
	ret := _mock.Called(callback)

	if len(ret) == 0 {
		panic("no return value specified for ConnectNotifyPosition")
	}

	var r0 uint32
	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
		r0 = returnFunc(callback)
	} else {
		r0 = ret.Get(0).(uint32)
	}
	return r0
}

// MockPanedWidget_ConnectNotifyPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectNotifyPosition'
type MockPanedWidget_ConnectNotifyPosition_Call struct {
	*mock.Call
}

// ConnectNotifyPosition is a helper method to define mock.On call
//   - callback func()
func (_e *MockPanedWidget_Expecter) ConnectNotifyPosition(callback interface{}) *MockPanedWidget_ConnectNotifyPosition_Call {
	return &MockPanedWidget_ConnectNotifyPosition_Call{Call: _e.mock.On("ConnectNotifyPosition", callback)}
}

func (_c *MockPanedWidget_ConnectNotifyPosition_Call) Run(run func(callback func())) *MockPanedWidget_ConnectNotifyPosition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func()
		if args[0] != nil {
			arg0 = args[0].(func())
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_ConnectNotifyPosition_Call) Return(v uint32) *MockPanedWidget_ConnectNotifyPosition_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockPanedWidget_ConnectNotifyPosition_Call) RunAndReturn(run func(callback func()) uint32) *MockPanedWidget_ConnectNotifyPosition_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockPanedWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockPanedWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetAllocatedHeight() *MockPanedWidget_GetAllocatedHeight_Call {
	return &MockPanedWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockPanedWidget_GetAllocatedHeight_Call) Run(run func()) *MockPanedWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetAllocatedHeight_Call) Return(n int) *MockPanedWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockPanedWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockPanedWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockPanedWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockPanedWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetAllocatedWidth() *MockPanedWidget_GetAllocatedWidth_Call {
	return &MockPanedWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockPanedWidget_GetAllocatedWidth_Call) Run(run func()) *MockPanedWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetAllocatedWidth_Call) Return(n int) *MockPanedWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockPanedWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockPanedWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetEndChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetEndChild() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetEndChild")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockPanedWidget_GetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEndChild'
type MockPanedWidget_GetEndChild_Call struct {
	*mock.Call
}

// GetEndChild is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetEndChild() *MockPanedWidget_GetEndChild_Call {
	return &MockPanedWidget_GetEndChild_Call{Call: _e.mock.On("GetEndChild")}
}

func (_c *MockPanedWidget_GetEndChild_Call) Run(run func()) *MockPanedWidget_GetEndChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetEndChild_Call) Return(widget layout.Widget) *MockPanedWidget_GetEndChild_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockPanedWidget_GetEndChild_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetEndChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockPanedWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetHexpand() *MockPanedWidget_GetHexpand_Call {
	return &MockPanedWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockPanedWidget_GetHexpand_Call) Run(run func()) *MockPanedWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetHexpand_Call) Return(b bool) *MockPanedWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockPanedWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockPanedWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetParent() *MockPanedWidget_GetParent_Call {
	return &MockPanedWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockPanedWidget_GetParent_Call) Run(run func()) *MockPanedWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetParent_Call) Return(widget layout.Widget) *MockPanedWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockPanedWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetPosition provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetPosition() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetPosition")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockPanedWidget_GetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPosition'
type MockPanedWidget_GetPosition_Call struct {
	*mock.Call
}

// GetPosition is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetPosition() *MockPanedWidget_GetPosition_Call {
	return &MockPanedWidget_GetPosition_Call{Call: _e.mock.On("GetPosition")}
}

func (_c *MockPanedWidget_GetPosition_Call) Run(run func()) *MockPanedWidget_GetPosition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetPosition_Call) Return(n int) *MockPanedWidget_GetPosition_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockPanedWidget_GetPosition_Call) RunAndReturn(run func() int) *MockPanedWidget_GetPosition_Call {
	_c.Call.Return(run)
	return _c
}

// GetResizeEndChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetResizeEndChild() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetResizeEndChild")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeEndChild'
type MockPanedWidget_GetResizeEndChild_Call struct {
	*mock.Call
}

// GetResizeEndChild is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetResizeEndChild() *MockPanedWidget_GetResizeEndChild_Call {
	return &MockPanedWidget_GetResizeEndChild_Call{Call: _e.mock.On("GetResizeEndChild")}
}

func (_c *MockPanedWidget_GetResizeEndChild_Call) Run(run func()) *MockPanedWidget_GetResizeEndChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetResizeEndChild_Call) Return(b bool) *MockPanedWidget_GetResizeEndChild_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetResizeEndChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetResizeEndChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetResizeStartChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetResizeStartChild() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetResizeStartChild")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeStartChild'
type MockPanedWidget_GetResizeStartChild_Call struct {
	*mock.Call
}

// GetResizeStartChild is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetResizeStartChild() *MockPanedWidget_GetResizeStartChild_Call {
	return &MockPanedWidget_GetResizeStartChild_Call{Call: _e.mock.On("GetResizeStartChild")}
}

func (_c *MockPanedWidget_GetResizeStartChild_Call) Run(run func()) *MockPanedWidget_GetResizeStartChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetResizeStartChild_Call) Return(b bool) *MockPanedWidget_GetResizeStartChild_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetResizeStartChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetResizeStartChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetShrinkEndChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetShrinkEndChild() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetShrinkEndChild")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkEndChild'
type MockPanedWidget_GetShrinkEndChild_Call struct {
	*mock.Call
}

// GetShrinkEndChild is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetShrinkEndChild() *MockPanedWidget_GetShrinkEndChild_Call {
	return &MockPanedWidget_GetShrinkEndChild_Call{Call: _e.mock.On("GetShrinkEndChild")}
}

func (_c *MockPanedWidget_GetShrinkEndChild_Call) Run(run func()) *MockPanedWidget_GetShrinkEndChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetShrinkEndChild_Call) Return(b bool) *MockPanedWidget_GetShrinkEndChild_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetShrinkEndChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetShrinkEndChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetShrinkStartChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetShrinkStartChild() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetShrinkStartChild")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkStartChild'
type MockPanedWidget_GetShrinkStartChild_Call struct {
	*mock.Call
}

// GetShrinkStartChild is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetShrinkStartChild() *MockPanedWidget_GetShrinkStartChild_Call {
	return &MockPanedWidget_GetShrinkStartChild_Call{Call: _e.mock.On("GetShrinkStartChild")}
}

func (_c *MockPanedWidget_GetShrinkStartChild_Call) Run(run func()) *MockPanedWidget_GetShrinkStartChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetShrinkStartChild_Call) Return(b bool) *MockPanedWidget_GetShrinkStartChild_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetShrinkStartChild_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetShrinkStartChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetStartChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetStartChild() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetStartChild")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockPanedWidget_GetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStartChild'
type MockPanedWidget_GetStartChild_Call struct {
	*mock.Call
}

// GetStartChild is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetStartChild() *MockPanedWidget_GetStartChild_Call {
	return &MockPanedWidget_GetStartChild_Call{Call: _e.mock.On("GetStartChild")}
}

func (_c *MockPanedWidget_GetStartChild_Call) Run(run func()) *MockPanedWidget_GetStartChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetStartChild_Call) Return(widget layout.Widget) *MockPanedWidget_GetStartChild_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockPanedWidget_GetStartChild_Call) RunAndReturn(run func() layout.Widget) *MockPanedWidget_GetStartChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockPanedWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetVexpand() *MockPanedWidget_GetVexpand_Call {
	return &MockPanedWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockPanedWidget_GetVexpand_Call) Run(run func()) *MockPanedWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetVexpand_Call) Return(b bool) *MockPanedWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetWideHandle provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GetWideHandle() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetWideHandle")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWideHandle'
type MockPanedWidget_GetWideHandle_Call struct {
	*mock.Call
}

// GetWideHandle is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GetWideHandle() *MockPanedWidget_GetWideHandle_Call {
	return &MockPanedWidget_GetWideHandle_Call{Call: _e.mock.On("GetWideHandle")}
}

func (_c *MockPanedWidget_GetWideHandle_Call) Run(run func()) *MockPanedWidget_GetWideHandle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GetWideHandle_Call) Return(b bool) *MockPanedWidget_GetWideHandle_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GetWideHandle_Call) RunAndReturn(run func() bool) *MockPanedWidget_GetWideHandle_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockPanedWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GrabFocus() *MockPanedWidget_GrabFocus_Call {
	return &MockPanedWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockPanedWidget_GrabFocus_Call) Run(run func()) *MockPanedWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GrabFocus_Call) Return(b bool) *MockPanedWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockPanedWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockPanedWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockPanedWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) GtkWidget() *MockPanedWidget_GtkWidget_Call {
	return &MockPanedWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockPanedWidget_GtkWidget_Call) Run(run func()) *MockPanedWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockPanedWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockPanedWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockPanedWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockPanedWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockPanedWidget_Expecter) HasCssClass(cssClass interface{}) *MockPanedWidget_HasCssClass_Call {
	return &MockPanedWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockPanedWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_HasCssClass_Call) Return(b bool) *MockPanedWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockPanedWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockPanedWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) HasFocus() *MockPanedWidget_HasFocus_Call {
	return &MockPanedWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockPanedWidget_HasFocus_Call) Run(run func()) *MockPanedWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_HasFocus_Call) Return(b bool) *MockPanedWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockPanedWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) Hide() {
	_mock.Called()
	return
}

// MockPanedWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockPanedWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) Hide() *MockPanedWidget_Hide_Call {
	return &MockPanedWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockPanedWidget_Hide_Call) Run(run func()) *MockPanedWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_Hide_Call) Return() *MockPanedWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_Hide_Call) RunAndReturn(run func()) *MockPanedWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockPanedWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockPanedWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) IsVisible() *MockPanedWidget_IsVisible_Call {
	return &MockPanedWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockPanedWidget_IsVisible_Call) Run(run func()) *MockPanedWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_IsVisible_Call) Return(b bool) *MockPanedWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockPanedWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockPanedWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockPanedWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockPanedWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockPanedWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockPanedWidget_RemoveCssClass_Call {
	return &MockPanedWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockPanedWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockPanedWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_RemoveCssClass_Call) Return() *MockPanedWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockPanedWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockPanedWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockPanedWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockPanedWidget_Expecter) SetCanFocus(canFocus interface{}) *MockPanedWidget_SetCanFocus_Call {
	return &MockPanedWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockPanedWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockPanedWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetCanFocus_Call) Return() *MockPanedWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockPanedWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockPanedWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockPanedWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockPanedWidget_Expecter) SetCanTarget(canTarget interface{}) *MockPanedWidget_SetCanTarget_Call {
	return &MockPanedWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockPanedWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockPanedWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetCanTarget_Call) Return() *MockPanedWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockPanedWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetEndChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetEndChild(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockPanedWidget_SetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEndChild'
type MockPanedWidget_SetEndChild_Call struct {
	*mock.Call
}

// SetEndChild is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockPanedWidget_Expecter) SetEndChild(child interface{}) *MockPanedWidget_SetEndChild_Call {
	return &MockPanedWidget_SetEndChild_Call{Call: _e.mock.On("SetEndChild", child)}
}

func (_c *MockPanedWidget_SetEndChild_Call) Run(run func(child layout.Widget)) *MockPanedWidget_SetEndChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetEndChild_Call) Return() *MockPanedWidget_SetEndChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetEndChild_Call) RunAndReturn(run func(child layout.Widget)) *MockPanedWidget_SetEndChild_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockPanedWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockPanedWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockPanedWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockPanedWidget_SetFocusOnClick_Call {
	return &MockPanedWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockPanedWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockPanedWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetFocusOnClick_Call) Return() *MockPanedWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockPanedWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockPanedWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockPanedWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockPanedWidget_Expecter) SetHalign(align interface{}) *MockPanedWidget_SetHalign_Call {
	return &MockPanedWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockPanedWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockPanedWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetHalign_Call) Return() *MockPanedWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockPanedWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockPanedWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockPanedWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockPanedWidget_Expecter) SetHexpand(expand interface{}) *MockPanedWidget_SetHexpand_Call {
	return &MockPanedWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockPanedWidget_SetHexpand_Call) Run(run func(expand bool)) *MockPanedWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetHexpand_Call) Return() *MockPanedWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockPanedWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetPosition provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetPosition(position int) {
	_mock.Called(position)
	return
}

// MockPanedWidget_SetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPosition'
type MockPanedWidget_SetPosition_Call struct {
	*mock.Call
}

// SetPosition is a helper method to define mock.On call
//   - position int
func (_e *MockPanedWidget_Expecter) SetPosition(position interface{}) *MockPanedWidget_SetPosition_Call {
	return &MockPanedWidget_SetPosition_Call{Call: _e.mock.On("SetPosition", position)}
}

func (_c *MockPanedWidget_SetPosition_Call) Run(run func(position int)) *MockPanedWidget_SetPosition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetPosition_Call) Return() *MockPanedWidget_SetPosition_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetPosition_Call) RunAndReturn(run func(position int)) *MockPanedWidget_SetPosition_Call {
	_c.Run(run)
	return _c
}

// SetResizeEndChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetResizeEndChild(resize bool) {
	_mock.Called(resize)
	return
}

// MockPanedWidget_SetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeEndChild'
type MockPanedWidget_SetResizeEndChild_Call struct {
	*mock.Call
}

// SetResizeEndChild is a helper method to define mock.On call
//   - resize bool
func (_e *MockPanedWidget_Expecter) SetResizeEndChild(resize interface{}) *MockPanedWidget_SetResizeEndChild_Call {
	return &MockPanedWidget_SetResizeEndChild_Call{Call: _e.mock.On("SetResizeEndChild", resize)}
}

func (_c *MockPanedWidget_SetResizeEndChild_Call) Run(run func(resize bool)) *MockPanedWidget_SetResizeEndChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetResizeEndChild_Call) Return() *MockPanedWidget_SetResizeEndChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetResizeEndChild_Call) RunAndReturn(run func(resize bool)) *MockPanedWidget_SetResizeEndChild_Call {
	_c.Run(run)
	return _c
}

// SetResizeStartChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetResizeStartChild(resize bool) {
	_mock.Called(resize)
	return
}

// MockPanedWidget_SetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeStartChild'
type MockPanedWidget_SetResizeStartChild_Call struct {
	*mock.Call
}

// SetResizeStartChild is a helper method to define mock.On call
//   - resize bool
func (_e *MockPanedWidget_Expecter) SetResizeStartChild(resize interface{}) *MockPanedWidget_SetResizeStartChild_Call {
	return &MockPanedWidget_SetResizeStartChild_Call{Call: _e.mock.On("SetResizeStartChild", resize)}
}

func (_c *MockPanedWidget_SetResizeStartChild_Call) Run(run func(resize bool)) *MockPanedWidget_SetResizeStartChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetResizeStartChild_Call) Return() *MockPanedWidget_SetResizeStartChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetResizeStartChild_Call) RunAndReturn(run func(resize bool)) *MockPanedWidget_SetResizeStartChild_Call {
	_c.Run(run)
	return _c
}

// SetShrinkEndChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetShrinkEndChild(shrink bool) {
	_mock.Called(shrink)
	return
}

// MockPanedWidget_SetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkEndChild'
type MockPanedWidget_SetShrinkEndChild_Call struct {
	*mock.Call
}

// SetShrinkEndChild is a helper method to define mock.On call
//   - shrink bool
func (_e *MockPanedWidget_Expecter) SetShrinkEndChild(shrink interface{}) *MockPanedWidget_SetShrinkEndChild_Call {
	return &MockPanedWidget_SetShrinkEndChild_Call{Call: _e.mock.On("SetShrinkEndChild", shrink)}
}

func (_c *MockPanedWidget_SetShrinkEndChild_Call) Run(run func(shrink bool)) *MockPanedWidget_SetShrinkEndChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetShrinkEndChild_Call) Return() *MockPanedWidget_SetShrinkEndChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetShrinkEndChild_Call) RunAndReturn(run func(shrink bool)) *MockPanedWidget_SetShrinkEndChild_Call {
	_c.Run(run)
	return _c
}

// SetShrinkStartChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetShrinkStartChild(shrink bool) {
	_mock.Called(shrink)
	return
}

// MockPanedWidget_SetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkStartChild'
type MockPanedWidget_SetShrinkStartChild_Call struct {
	*mock.Call
}

// SetShrinkStartChild is a helper method to define mock.On call
//   - shrink bool
func (_e *MockPanedWidget_Expecter) SetShrinkStartChild(shrink interface{}) *MockPanedWidget_SetShrinkStartChild_Call {
	return &MockPanedWidget_SetShrinkStartChild_Call{Call: _e.mock.On("SetShrinkStartChild", shrink)}
}

func (_c *MockPanedWidget_SetShrinkStartChild_Call) Run(run func(shrink bool)) *MockPanedWidget_SetShrinkStartChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetShrinkStartChild_Call) Return() *MockPanedWidget_SetShrinkStartChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetShrinkStartChild_Call) RunAndReturn(run func(shrink bool)) *MockPanedWidget_SetShrinkStartChild_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockPanedWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockPanedWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockPanedWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockPanedWidget_SetSizeRequest_Call {
	return &MockPanedWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockPanedWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockPanedWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetSizeRequest_Call) Return() *MockPanedWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockPanedWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetStartChild provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetStartChild(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockPanedWidget_SetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStartChild'
type MockPanedWidget_SetStartChild_Call struct {
	*mock.Call
}

// SetStartChild is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockPanedWidget_Expecter) SetStartChild(child interface{}) *MockPanedWidget_SetStartChild_Call {
	return &MockPanedWidget_SetStartChild_Call{Call: _e.mock.On("SetStartChild", child)}
}

func (_c *MockPanedWidget_SetStartChild_Call) Run(run func(child layout.Widget)) *MockPanedWidget_SetStartChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetStartChild_Call) Return() *MockPanedWidget_SetStartChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetStartChild_Call) RunAndReturn(run func(child layout.Widget)) *MockPanedWidget_SetStartChild_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockPanedWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockPanedWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockPanedWidget_Expecter) SetValign(align interface{}) *MockPanedWidget_SetValign_Call {
	return &MockPanedWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockPanedWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockPanedWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetValign_Call) Return() *MockPanedWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockPanedWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockPanedWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockPanedWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockPanedWidget_Expecter) SetVexpand(expand interface{}) *MockPanedWidget_SetVexpand_Call {
	return &MockPanedWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockPanedWidget_SetVexpand_Call) Run(run func(expand bool)) *MockPanedWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetVexpand_Call) Return() *MockPanedWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockPanedWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockPanedWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockPanedWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockPanedWidget_Expecter) SetVisible(visible interface{}) *MockPanedWidget_SetVisible_Call {
	return &MockPanedWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockPanedWidget_SetVisible_Call) Run(run func(visible bool)) *MockPanedWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetVisible_Call) Return() *MockPanedWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockPanedWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// SetWideHandle provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) SetWideHandle(wide bool) {
	_mock.Called(wide)
	return
}

// MockPanedWidget_SetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWideHandle'
type MockPanedWidget_SetWideHandle_Call struct {
	*mock.Call
}

// SetWideHandle is a helper method to define mock.On call
//   - wide bool
func (_e *MockPanedWidget_Expecter) SetWideHandle(wide interface{}) *MockPanedWidget_SetWideHandle_Call {
	return &MockPanedWidget_SetWideHandle_Call{Call: _e.mock.On("SetWideHandle", wide)}
}

func (_c *MockPanedWidget_SetWideHandle_Call) Run(run func(wide bool)) *MockPanedWidget_SetWideHandle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockPanedWidget_SetWideHandle_Call) Return() *MockPanedWidget_SetWideHandle_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_SetWideHandle_Call) RunAndReturn(run func(wide bool)) *MockPanedWidget_SetWideHandle_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) Show() {
	_mock.Called()
	return
}

// MockPanedWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockPanedWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) Show() *MockPanedWidget_Show_Call {
	return &MockPanedWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockPanedWidget_Show_Call) Run(run func()) *MockPanedWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_Show_Call) Return() *MockPanedWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_Show_Call) RunAndReturn(run func()) *MockPanedWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockPanedWidget
func (_mock *MockPanedWidget) Unparent() {
	_mock.Called()
	return
}

// MockPanedWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockPanedWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockPanedWidget_Expecter) Unparent() *MockPanedWidget_Unparent_Call {
	return &MockPanedWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockPanedWidget_Unparent_Call) Run(run func()) *MockPanedWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockPanedWidget_Unparent_Call) Return() *MockPanedWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockPanedWidget_Unparent_Call) RunAndReturn(run func()) *MockPanedWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockBoxWidget creates a new instance of MockBoxWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockBoxWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBoxWidget {
	mock := &MockBoxWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockBoxWidget is an autogenerated mock type for the BoxWidget type
type MockBoxWidget struct {
	mock.Mock
}

type MockBoxWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBoxWidget) EXPECT() *MockBoxWidget_Expecter {
	return &MockBoxWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockBoxWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockBoxWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockBoxWidget_Expecter) AddController(controller interface{}) *MockBoxWidget_AddController_Call {
	return &MockBoxWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockBoxWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockBoxWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_AddController_Call) Return() *MockBoxWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockBoxWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockBoxWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockBoxWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockBoxWidget_Expecter) AddCssClass(cssClass interface{}) *MockBoxWidget_AddCssClass_Call {
	return &MockBoxWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockBoxWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_AddCssClass_Call) Return() *MockBoxWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockBoxWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// Append provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) Append(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockBoxWidget_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append'
type MockBoxWidget_Append_Call struct {
	*mock.Call
}

// Append is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockBoxWidget_Expecter) Append(child interface{}) *MockBoxWidget_Append_Call {
	return &MockBoxWidget_Append_Call{Call: _e.mock.On("Append", child)}
}

func (_c *MockBoxWidget_Append_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Append_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_Append_Call) Return() *MockBoxWidget_Append_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_Append_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Append_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockBoxWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockBoxWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockBoxWidget_Expecter) ComputePoint(target interface{}) *MockBoxWidget_ComputePoint_Call {
	return &MockBoxWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockBoxWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockBoxWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockBoxWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockBoxWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockBoxWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockBoxWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockBoxWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetAllocatedHeight() *MockBoxWidget_GetAllocatedHeight_Call {
	return &MockBoxWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockBoxWidget_GetAllocatedHeight_Call) Run(run func()) *MockBoxWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetAllocatedHeight_Call) Return(n int) *MockBoxWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockBoxWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockBoxWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockBoxWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockBoxWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetAllocatedWidth() *MockBoxWidget_GetAllocatedWidth_Call {
	return &MockBoxWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockBoxWidget_GetAllocatedWidth_Call) Run(run func()) *MockBoxWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetAllocatedWidth_Call) Return(n int) *MockBoxWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockBoxWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockBoxWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockBoxWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetHexpand() *MockBoxWidget_GetHexpand_Call {
	return &MockBoxWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockBoxWidget_GetHexpand_Call) Run(run func()) *MockBoxWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetHexpand_Call) Return(b bool) *MockBoxWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetHomogeneous provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetHomogeneous() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHomogeneous")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_GetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomogeneous'
type MockBoxWidget_GetHomogeneous_Call struct {
	*mock.Call
}

// GetHomogeneous is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetHomogeneous() *MockBoxWidget_GetHomogeneous_Call {
	return &MockBoxWidget_GetHomogeneous_Call{Call: _e.mock.On("GetHomogeneous")}
}

func (_c *MockBoxWidget_GetHomogeneous_Call) Run(run func()) *MockBoxWidget_GetHomogeneous_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetHomogeneous_Call) Return(b bool) *MockBoxWidget_GetHomogeneous_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_GetHomogeneous_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetHomogeneous_Call {
	_c.Call.Return(run)
	return _c
}

// GetOrientation provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetOrientation() layout.Orientation {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetOrientation")
	}

	var r0 layout.Orientation
	if returnFunc, ok := ret.Get(0).(func() layout.Orientation); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(layout.Orientation)
	}
	return r0
}

// MockBoxWidget_GetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrientation'
type MockBoxWidget_GetOrientation_Call struct {
	*mock.Call
}

// GetOrientation is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetOrientation() *MockBoxWidget_GetOrientation_Call {
	return &MockBoxWidget_GetOrientation_Call{Call: _e.mock.On("GetOrientation")}
}

func (_c *MockBoxWidget_GetOrientation_Call) Run(run func()) *MockBoxWidget_GetOrientation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetOrientation_Call) Return(v layout.Orientation) *MockBoxWidget_GetOrientation_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockBoxWidget_GetOrientation_Call) RunAndReturn(run func() layout.Orientation) *MockBoxWidget_GetOrientation_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockBoxWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockBoxWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetParent() *MockBoxWidget_GetParent_Call {
	return &MockBoxWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockBoxWidget_GetParent_Call) Run(run func()) *MockBoxWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetParent_Call) Return(widget layout.Widget) *MockBoxWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockBoxWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockBoxWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetSpacing provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetSpacing() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetSpacing")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockBoxWidget_GetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpacing'
type MockBoxWidget_GetSpacing_Call struct {
	*mock.Call
}

// GetSpacing is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetSpacing() *MockBoxWidget_GetSpacing_Call {
	return &MockBoxWidget_GetSpacing_Call{Call: _e.mock.On("GetSpacing")}
}

func (_c *MockBoxWidget_GetSpacing_Call) Run(run func()) *MockBoxWidget_GetSpacing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetSpacing_Call) Return(n int) *MockBoxWidget_GetSpacing_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockBoxWidget_GetSpacing_Call) RunAndReturn(run func() int) *MockBoxWidget_GetSpacing_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockBoxWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GetVexpand() *MockBoxWidget_GetVexpand_Call {
	return &MockBoxWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockBoxWidget_GetVexpand_Call) Run(run func()) *MockBoxWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GetVexpand_Call) Return(b bool) *MockBoxWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockBoxWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockBoxWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GrabFocus() *MockBoxWidget_GrabFocus_Call {
	return &MockBoxWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockBoxWidget_GrabFocus_Call) Run(run func()) *MockBoxWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GrabFocus_Call) Return(b bool) *MockBoxWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockBoxWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockBoxWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockBoxWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) GtkWidget() *MockBoxWidget_GtkWidget_Call {
	return &MockBoxWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockBoxWidget_GtkWidget_Call) Run(run func()) *MockBoxWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockBoxWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockBoxWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockBoxWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockBoxWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockBoxWidget_Expecter) HasCssClass(cssClass interface{}) *MockBoxWidget_HasCssClass_Call {
	return &MockBoxWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockBoxWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_HasCssClass_Call) Return(b bool) *MockBoxWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockBoxWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockBoxWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) HasFocus() *MockBoxWidget_HasFocus_Call {
	return &MockBoxWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockBoxWidget_HasFocus_Call) Run(run func()) *MockBoxWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_HasFocus_Call) Return(b bool) *MockBoxWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockBoxWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) Hide() {
	_mock.Called()
	return
}

// MockBoxWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockBoxWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) Hide() *MockBoxWidget_Hide_Call {
	return &MockBoxWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockBoxWidget_Hide_Call) Run(run func()) *MockBoxWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_Hide_Call) Return() *MockBoxWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_Hide_Call) RunAndReturn(run func()) *MockBoxWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// InsertChildAfter provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) InsertChildAfter(child layout.Widget, sibling layout.Widget) {
	_mock.Called(child, sibling)
	return
}

// MockBoxWidget_InsertChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertChildAfter'
type MockBoxWidget_InsertChildAfter_Call struct {
	*mock.Call
}

// InsertChildAfter is a helper method to define mock.On call
//   - child layout.Widget
//   - sibling layout.Widget
func (_e *MockBoxWidget_Expecter) InsertChildAfter(child interface{}, sibling interface{}) *MockBoxWidget_InsertChildAfter_Call {
	return &MockBoxWidget_InsertChildAfter_Call{Call: _e.mock.On("InsertChildAfter", child, sibling)}
}

func (_c *MockBoxWidget_InsertChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_InsertChildAfter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		var arg1 layout.Widget
		if args[1] != nil {
			arg1 = args[1].(layout.Widget)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBoxWidget_InsertChildAfter_Call) Return() *MockBoxWidget_InsertChildAfter_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_InsertChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_InsertChildAfter_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockBoxWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockBoxWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) IsVisible() *MockBoxWidget_IsVisible_Call {
	return &MockBoxWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockBoxWidget_IsVisible_Call) Run(run func()) *MockBoxWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_IsVisible_Call) Return(b bool) *MockBoxWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockBoxWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockBoxWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// Prepend provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) Prepend(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockBoxWidget_Prepend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prepend'
type MockBoxWidget_Prepend_Call struct {
	*mock.Call
}

// Prepend is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockBoxWidget_Expecter) Prepend(child interface{}) *MockBoxWidget_Prepend_Call {
	return &MockBoxWidget_Prepend_Call{Call: _e.mock.On("Prepend", child)}
}

func (_c *MockBoxWidget_Prepend_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Prepend_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_Prepend_Call) Return() *MockBoxWidget_Prepend_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_Prepend_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Prepend_Call {
	_c.Run(run)
	return _c
}

// Remove provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) Remove(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockBoxWidget_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
type MockBoxWidget_Remove_Call struct {
	*mock.Call
}

// Remove is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockBoxWidget_Expecter) Remove(child interface{}) *MockBoxWidget_Remove_Call {
	return &MockBoxWidget_Remove_Call{Call: _e.mock.On("Remove", child)}
}

func (_c *MockBoxWidget_Remove_Call) Run(run func(child layout.Widget)) *MockBoxWidget_Remove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_Remove_Call) Return() *MockBoxWidget_Remove_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_Remove_Call) RunAndReturn(run func(child layout.Widget)) *MockBoxWidget_Remove_Call {
	_c.Run(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockBoxWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockBoxWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockBoxWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockBoxWidget_RemoveCssClass_Call {
	return &MockBoxWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockBoxWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockBoxWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_RemoveCssClass_Call) Return() *MockBoxWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockBoxWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// ReorderChildAfter provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) ReorderChildAfter(child layout.Widget, sibling layout.Widget) {
	_mock.Called(child, sibling)
	return
}

// MockBoxWidget_ReorderChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReorderChildAfter'
type MockBoxWidget_ReorderChildAfter_Call struct {
	*mock.Call
}

// ReorderChildAfter is a helper method to define mock.On call
//   - child layout.Widget
//   - sibling layout.Widget
func (_e *MockBoxWidget_Expecter) ReorderChildAfter(child interface{}, sibling interface{}) *MockBoxWidget_ReorderChildAfter_Call {
	return &MockBoxWidget_ReorderChildAfter_Call{Call: _e.mock.On("ReorderChildAfter", child, sibling)}
}

func (_c *MockBoxWidget_ReorderChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_ReorderChildAfter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		var arg1 layout.Widget
		if args[1] != nil {
			arg1 = args[1].(layout.Widget)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBoxWidget_ReorderChildAfter_Call) Return() *MockBoxWidget_ReorderChildAfter_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_ReorderChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) *MockBoxWidget_ReorderChildAfter_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockBoxWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockBoxWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockBoxWidget_Expecter) SetCanFocus(canFocus interface{}) *MockBoxWidget_SetCanFocus_Call {
	return &MockBoxWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockBoxWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockBoxWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetCanFocus_Call) Return() *MockBoxWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockBoxWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockBoxWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockBoxWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockBoxWidget_Expecter) SetCanTarget(canTarget interface{}) *MockBoxWidget_SetCanTarget_Call {
	return &MockBoxWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockBoxWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockBoxWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetCanTarget_Call) Return() *MockBoxWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockBoxWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockBoxWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockBoxWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockBoxWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockBoxWidget_SetFocusOnClick_Call {
	return &MockBoxWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockBoxWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockBoxWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetFocusOnClick_Call) Return() *MockBoxWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockBoxWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockBoxWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockBoxWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockBoxWidget_Expecter) SetHalign(align interface{}) *MockBoxWidget_SetHalign_Call {
	return &MockBoxWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockBoxWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockBoxWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetHalign_Call) Return() *MockBoxWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockBoxWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockBoxWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockBoxWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockBoxWidget_Expecter) SetHexpand(expand interface{}) *MockBoxWidget_SetHexpand_Call {
	return &MockBoxWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockBoxWidget_SetHexpand_Call) Run(run func(expand bool)) *MockBoxWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetHexpand_Call) Return() *MockBoxWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockBoxWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetHomogeneous provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetHomogeneous(homogeneous bool) {
	_mock.Called(homogeneous)
	return
}

// MockBoxWidget_SetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHomogeneous'
type MockBoxWidget_SetHomogeneous_Call struct {
	*mock.Call
}

// SetHomogeneous is a helper method to define mock.On call
//   - homogeneous bool
func (_e *MockBoxWidget_Expecter) SetHomogeneous(homogeneous interface{}) *MockBoxWidget_SetHomogeneous_Call {
	return &MockBoxWidget_SetHomogeneous_Call{Call: _e.mock.On("SetHomogeneous", homogeneous)}
}

func (_c *MockBoxWidget_SetHomogeneous_Call) Run(run func(homogeneous bool)) *MockBoxWidget_SetHomogeneous_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetHomogeneous_Call) Return() *MockBoxWidget_SetHomogeneous_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetHomogeneous_Call) RunAndReturn(run func(homogeneous bool)) *MockBoxWidget_SetHomogeneous_Call {
	_c.Run(run)
	return _c
}

// SetOrientation provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetOrientation(orientation layout.Orientation) {
	_mock.Called(orientation)
	return
}

// MockBoxWidget_SetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOrientation'
type MockBoxWidget_SetOrientation_Call struct {
	*mock.Call
}

// SetOrientation is a helper method to define mock.On call
//   - orientation layout.Orientation
func (_e *MockBoxWidget_Expecter) SetOrientation(orientation interface{}) *MockBoxWidget_SetOrientation_Call {
	return &MockBoxWidget_SetOrientation_Call{Call: _e.mock.On("SetOrientation", orientation)}
}

func (_c *MockBoxWidget_SetOrientation_Call) Run(run func(orientation layout.Orientation)) *MockBoxWidget_SetOrientation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Orientation
		if args[0] != nil {
			arg0 = args[0].(layout.Orientation)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetOrientation_Call) Return() *MockBoxWidget_SetOrientation_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetOrientation_Call) RunAndReturn(run func(orientation layout.Orientation)) *MockBoxWidget_SetOrientation_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockBoxWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockBoxWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockBoxWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockBoxWidget_SetSizeRequest_Call {
	return &MockBoxWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockBoxWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockBoxWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetSizeRequest_Call) Return() *MockBoxWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockBoxWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetSpacing provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetSpacing(spacing int) {
	_mock.Called(spacing)
	return
}

// MockBoxWidget_SetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpacing'
type MockBoxWidget_SetSpacing_Call struct {
	*mock.Call
}

// SetSpacing is a helper method to define mock.On call
//   - spacing int
func (_e *MockBoxWidget_Expecter) SetSpacing(spacing interface{}) *MockBoxWidget_SetSpacing_Call {
	return &MockBoxWidget_SetSpacing_Call{Call: _e.mock.On("SetSpacing", spacing)}
}

func (_c *MockBoxWidget_SetSpacing_Call) Run(run func(spacing int)) *MockBoxWidget_SetSpacing_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetSpacing_Call) Return() *MockBoxWidget_SetSpacing_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetSpacing_Call) RunAndReturn(run func(spacing int)) *MockBoxWidget_SetSpacing_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockBoxWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockBoxWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockBoxWidget_Expecter) SetValign(align interface{}) *MockBoxWidget_SetValign_Call {
	return &MockBoxWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockBoxWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockBoxWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetValign_Call) Return() *MockBoxWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockBoxWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockBoxWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockBoxWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockBoxWidget_Expecter) SetVexpand(expand interface{}) *MockBoxWidget_SetVexpand_Call {
	return &MockBoxWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockBoxWidget_SetVexpand_Call) Run(run func(expand bool)) *MockBoxWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetVexpand_Call) Return() *MockBoxWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockBoxWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockBoxWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockBoxWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockBoxWidget_Expecter) SetVisible(visible interface{}) *MockBoxWidget_SetVisible_Call {
	return &MockBoxWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockBoxWidget_SetVisible_Call) Run(run func(visible bool)) *MockBoxWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockBoxWidget_SetVisible_Call) Return() *MockBoxWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockBoxWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) Show() {
	_mock.Called()
	return
}

// MockBoxWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockBoxWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) Show() *MockBoxWidget_Show_Call {
	return &MockBoxWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockBoxWidget_Show_Call) Run(run func()) *MockBoxWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_Show_Call) Return() *MockBoxWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_Show_Call) RunAndReturn(run func()) *MockBoxWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockBoxWidget
func (_mock *MockBoxWidget) Unparent() {
	_mock.Called()
	return
}

// MockBoxWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockBoxWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockBoxWidget_Expecter) Unparent() *MockBoxWidget_Unparent_Call {
	return &MockBoxWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockBoxWidget_Unparent_Call) Run(run func()) *MockBoxWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockBoxWidget_Unparent_Call) Return() *MockBoxWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockBoxWidget_Unparent_Call) RunAndReturn(run func()) *MockBoxWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockOverlayWidget creates a new instance of MockOverlayWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockOverlayWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockOverlayWidget {
	mock := &MockOverlayWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockOverlayWidget is an autogenerated mock type for the OverlayWidget type
type MockOverlayWidget struct {
	mock.Mock
}

type MockOverlayWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockOverlayWidget) EXPECT() *MockOverlayWidget_Expecter {
	return &MockOverlayWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockOverlayWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockOverlayWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockOverlayWidget_Expecter) AddController(controller interface{}) *MockOverlayWidget_AddController_Call {
	return &MockOverlayWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockOverlayWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockOverlayWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_AddController_Call) Return() *MockOverlayWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockOverlayWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockOverlayWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockOverlayWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockOverlayWidget_Expecter) AddCssClass(cssClass interface{}) *MockOverlayWidget_AddCssClass_Call {
	return &MockOverlayWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockOverlayWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_AddCssClass_Call) Return() *MockOverlayWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockOverlayWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// AddOverlay provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) AddOverlay(overlay layout.Widget) {
	_mock.Called(overlay)
	return
}

// MockOverlayWidget_AddOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOverlay'
type MockOverlayWidget_AddOverlay_Call struct {
	*mock.Call
}

// AddOverlay is a helper method to define mock.On call
//   - overlay layout.Widget
func (_e *MockOverlayWidget_Expecter) AddOverlay(overlay interface{}) *MockOverlayWidget_AddOverlay_Call {
	return &MockOverlayWidget_AddOverlay_Call{Call: _e.mock.On("AddOverlay", overlay)}
}

func (_c *MockOverlayWidget_AddOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_AddOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_AddOverlay_Call) Return() *MockOverlayWidget_AddOverlay_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_AddOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) *MockOverlayWidget_AddOverlay_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockOverlayWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockOverlayWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockOverlayWidget_Expecter) ComputePoint(target interface{}) *MockOverlayWidget_ComputePoint_Call {
	return &MockOverlayWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockOverlayWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockOverlayWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockOverlayWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockOverlayWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockOverlayWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockOverlayWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockOverlayWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GetAllocatedHeight() *MockOverlayWidget_GetAllocatedHeight_Call {
	return &MockOverlayWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockOverlayWidget_GetAllocatedHeight_Call) Run(run func()) *MockOverlayWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GetAllocatedHeight_Call) Return(n int) *MockOverlayWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockOverlayWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockOverlayWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockOverlayWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockOverlayWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GetAllocatedWidth() *MockOverlayWidget_GetAllocatedWidth_Call {
	return &MockOverlayWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockOverlayWidget_GetAllocatedWidth_Call) Run(run func()) *MockOverlayWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GetAllocatedWidth_Call) Return(n int) *MockOverlayWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockOverlayWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockOverlayWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetChild provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetChild() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetChild")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockOverlayWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
type MockOverlayWidget_GetChild_Call struct {
	*mock.Call
}

// GetChild is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GetChild() *MockOverlayWidget_GetChild_Call {
	return &MockOverlayWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
}

func (_c *MockOverlayWidget_GetChild_Call) Run(run func()) *MockOverlayWidget_GetChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GetChild_Call) Return(widget layout.Widget) *MockOverlayWidget_GetChild_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockOverlayWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) *MockOverlayWidget_GetChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetClipOverlay provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetClipOverlay(overlay layout.Widget) bool {
	ret := _mock.Called(overlay)

	if len(ret) == 0 {
		panic("no return value specified for GetClipOverlay")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
		r0 = returnFunc(overlay)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_GetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClipOverlay'
type MockOverlayWidget_GetClipOverlay_Call struct {
	*mock.Call
}

// GetClipOverlay is a helper method to define mock.On call
//   - overlay layout.Widget
func (_e *MockOverlayWidget_Expecter) GetClipOverlay(overlay interface{}) *MockOverlayWidget_GetClipOverlay_Call {
	return &MockOverlayWidget_GetClipOverlay_Call{Call: _e.mock.On("GetClipOverlay", overlay)}
}

func (_c *MockOverlayWidget_GetClipOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_GetClipOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_GetClipOverlay_Call) Return(b bool) *MockOverlayWidget_GetClipOverlay_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_GetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) *MockOverlayWidget_GetClipOverlay_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockOverlayWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GetHexpand() *MockOverlayWidget_GetHexpand_Call {
	return &MockOverlayWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockOverlayWidget_GetHexpand_Call) Run(run func()) *MockOverlayWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GetHexpand_Call) Return(b bool) *MockOverlayWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetMeasureOverlay provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetMeasureOverlay(overlay layout.Widget) bool {
	ret := _mock.Called(overlay)

	if len(ret) == 0 {
		panic("no return value specified for GetMeasureOverlay")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
		r0 = returnFunc(overlay)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_GetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasureOverlay'
type MockOverlayWidget_GetMeasureOverlay_Call struct {
	*mock.Call
}

// GetMeasureOverlay is a helper method to define mock.On call
//   - overlay layout.Widget
func (_e *MockOverlayWidget_Expecter) GetMeasureOverlay(overlay interface{}) *MockOverlayWidget_GetMeasureOverlay_Call {
	return &MockOverlayWidget_GetMeasureOverlay_Call{Call: _e.mock.On("GetMeasureOverlay", overlay)}
}

func (_c *MockOverlayWidget_GetMeasureOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_GetMeasureOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_GetMeasureOverlay_Call) Return(b bool) *MockOverlayWidget_GetMeasureOverlay_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_GetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) *MockOverlayWidget_GetMeasureOverlay_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockOverlayWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockOverlayWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GetParent() *MockOverlayWidget_GetParent_Call {
	return &MockOverlayWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockOverlayWidget_GetParent_Call) Run(run func()) *MockOverlayWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GetParent_Call) Return(widget layout.Widget) *MockOverlayWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockOverlayWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockOverlayWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockOverlayWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GetVexpand() *MockOverlayWidget_GetVexpand_Call {
	return &MockOverlayWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockOverlayWidget_GetVexpand_Call) Run(run func()) *MockOverlayWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GetVexpand_Call) Return(b bool) *MockOverlayWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockOverlayWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GrabFocus() *MockOverlayWidget_GrabFocus_Call {
	return &MockOverlayWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockOverlayWidget_GrabFocus_Call) Run(run func()) *MockOverlayWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GrabFocus_Call) Return(b bool) *MockOverlayWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockOverlayWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockOverlayWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockOverlayWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) GtkWidget() *MockOverlayWidget_GtkWidget_Call {
	return &MockOverlayWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockOverlayWidget_GtkWidget_Call) Run(run func()) *MockOverlayWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockOverlayWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockOverlayWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockOverlayWidget_Expecter) HasCssClass(cssClass interface{}) *MockOverlayWidget_HasCssClass_Call {
	return &MockOverlayWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockOverlayWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_HasCssClass_Call) Return(b bool) *MockOverlayWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockOverlayWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockOverlayWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) HasFocus() *MockOverlayWidget_HasFocus_Call {
	return &MockOverlayWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockOverlayWidget_HasFocus_Call) Run(run func()) *MockOverlayWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_HasFocus_Call) Return(b bool) *MockOverlayWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockOverlayWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) Hide() {
	_mock.Called()
	return
}

// MockOverlayWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockOverlayWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) Hide() *MockOverlayWidget_Hide_Call {
	return &MockOverlayWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockOverlayWidget_Hide_Call) Run(run func()) *MockOverlayWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_Hide_Call) Return() *MockOverlayWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_Hide_Call) RunAndReturn(run func()) *MockOverlayWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockOverlayWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockOverlayWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) IsVisible() *MockOverlayWidget_IsVisible_Call {
	return &MockOverlayWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockOverlayWidget_IsVisible_Call) Run(run func()) *MockOverlayWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_IsVisible_Call) Return(b bool) *MockOverlayWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockOverlayWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockOverlayWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockOverlayWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockOverlayWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockOverlayWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockOverlayWidget_RemoveCssClass_Call {
	return &MockOverlayWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockOverlayWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockOverlayWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_RemoveCssClass_Call) Return() *MockOverlayWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockOverlayWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// RemoveOverlay provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) RemoveOverlay(overlay layout.Widget) {
	_mock.Called(overlay)
	return
}

// MockOverlayWidget_RemoveOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOverlay'
type MockOverlayWidget_RemoveOverlay_Call struct {
	*mock.Call
}

// RemoveOverlay is a helper method to define mock.On call
//   - overlay layout.Widget
func (_e *MockOverlayWidget_Expecter) RemoveOverlay(overlay interface{}) *MockOverlayWidget_RemoveOverlay_Call {
	return &MockOverlayWidget_RemoveOverlay_Call{Call: _e.mock.On("RemoveOverlay", overlay)}
}

func (_c *MockOverlayWidget_RemoveOverlay_Call) Run(run func(overlay layout.Widget)) *MockOverlayWidget_RemoveOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_RemoveOverlay_Call) Return() *MockOverlayWidget_RemoveOverlay_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_RemoveOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) *MockOverlayWidget_RemoveOverlay_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockOverlayWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockOverlayWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockOverlayWidget_Expecter) SetCanFocus(canFocus interface{}) *MockOverlayWidget_SetCanFocus_Call {
	return &MockOverlayWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockOverlayWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockOverlayWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetCanFocus_Call) Return() *MockOverlayWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockOverlayWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockOverlayWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockOverlayWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockOverlayWidget_Expecter) SetCanTarget(canTarget interface{}) *MockOverlayWidget_SetCanTarget_Call {
	return &MockOverlayWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockOverlayWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockOverlayWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetCanTarget_Call) Return() *MockOverlayWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockOverlayWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetChild provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetChild(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockOverlayWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
type MockOverlayWidget_SetChild_Call struct {
	*mock.Call
}

// SetChild is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockOverlayWidget_Expecter) SetChild(child interface{}) *MockOverlayWidget_SetChild_Call {
	return &MockOverlayWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
}

func (_c *MockOverlayWidget_SetChild_Call) Run(run func(child layout.Widget)) *MockOverlayWidget_SetChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetChild_Call) Return() *MockOverlayWidget_SetChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) *MockOverlayWidget_SetChild_Call {
	_c.Run(run)
	return _c
}

// SetClipOverlay provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetClipOverlay(overlay layout.Widget, clip bool) {
	_mock.Called(overlay, clip)
	return
}

// MockOverlayWidget_SetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetClipOverlay'
type MockOverlayWidget_SetClipOverlay_Call struct {
	*mock.Call
}

// SetClipOverlay is a helper method to define mock.On call
//   - overlay layout.Widget
//   - clip bool
func (_e *MockOverlayWidget_Expecter) SetClipOverlay(overlay interface{}, clip interface{}) *MockOverlayWidget_SetClipOverlay_Call {
	return &MockOverlayWidget_SetClipOverlay_Call{Call: _e.mock.On("SetClipOverlay", overlay, clip)}
}

func (_c *MockOverlayWidget_SetClipOverlay_Call) Run(run func(overlay layout.Widget, clip bool)) *MockOverlayWidget_SetClipOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetClipOverlay_Call) Return() *MockOverlayWidget_SetClipOverlay_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget, clip bool)) *MockOverlayWidget_SetClipOverlay_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockOverlayWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockOverlayWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockOverlayWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockOverlayWidget_SetFocusOnClick_Call {
	return &MockOverlayWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockOverlayWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockOverlayWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetFocusOnClick_Call) Return() *MockOverlayWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockOverlayWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockOverlayWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockOverlayWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockOverlayWidget_Expecter) SetHalign(align interface{}) *MockOverlayWidget_SetHalign_Call {
	return &MockOverlayWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockOverlayWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockOverlayWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetHalign_Call) Return() *MockOverlayWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockOverlayWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockOverlayWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockOverlayWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockOverlayWidget_Expecter) SetHexpand(expand interface{}) *MockOverlayWidget_SetHexpand_Call {
	return &MockOverlayWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockOverlayWidget_SetHexpand_Call) Run(run func(expand bool)) *MockOverlayWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetHexpand_Call) Return() *MockOverlayWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockOverlayWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetMeasureOverlay provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetMeasureOverlay(overlay layout.Widget, measure bool) {
	_mock.Called(overlay, measure)
	return
}

// MockOverlayWidget_SetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMeasureOverlay'
type MockOverlayWidget_SetMeasureOverlay_Call struct {
	*mock.Call
}

// SetMeasureOverlay is a helper method to define mock.On call
//   - overlay layout.Widget
//   - measure bool
func (_e *MockOverlayWidget_Expecter) SetMeasureOverlay(overlay interface{}, measure interface{}) *MockOverlayWidget_SetMeasureOverlay_Call {
	return &MockOverlayWidget_SetMeasureOverlay_Call{Call: _e.mock.On("SetMeasureOverlay", overlay, measure)}
}

func (_c *MockOverlayWidget_SetMeasureOverlay_Call) Run(run func(overlay layout.Widget, measure bool)) *MockOverlayWidget_SetMeasureOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetMeasureOverlay_Call) Return() *MockOverlayWidget_SetMeasureOverlay_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget, measure bool)) *MockOverlayWidget_SetMeasureOverlay_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockOverlayWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockOverlayWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockOverlayWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockOverlayWidget_SetSizeRequest_Call {
	return &MockOverlayWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockOverlayWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockOverlayWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetSizeRequest_Call) Return() *MockOverlayWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockOverlayWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockOverlayWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockOverlayWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockOverlayWidget_Expecter) SetValign(align interface{}) *MockOverlayWidget_SetValign_Call {
	return &MockOverlayWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockOverlayWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockOverlayWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetValign_Call) Return() *MockOverlayWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockOverlayWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockOverlayWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockOverlayWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockOverlayWidget_Expecter) SetVexpand(expand interface{}) *MockOverlayWidget_SetVexpand_Call {
	return &MockOverlayWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockOverlayWidget_SetVexpand_Call) Run(run func(expand bool)) *MockOverlayWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetVexpand_Call) Return() *MockOverlayWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockOverlayWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockOverlayWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockOverlayWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockOverlayWidget_Expecter) SetVisible(visible interface{}) *MockOverlayWidget_SetVisible_Call {
	return &MockOverlayWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockOverlayWidget_SetVisible_Call) Run(run func(visible bool)) *MockOverlayWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockOverlayWidget_SetVisible_Call) Return() *MockOverlayWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockOverlayWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) Show() {
	_mock.Called()
	return
}

// MockOverlayWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockOverlayWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) Show() *MockOverlayWidget_Show_Call {
	return &MockOverlayWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockOverlayWidget_Show_Call) Run(run func()) *MockOverlayWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_Show_Call) Return() *MockOverlayWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_Show_Call) RunAndReturn(run func()) *MockOverlayWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockOverlayWidget
func (_mock *MockOverlayWidget) Unparent() {
	_mock.Called()
	return
}

// MockOverlayWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockOverlayWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockOverlayWidget_Expecter) Unparent() *MockOverlayWidget_Unparent_Call {
	return &MockOverlayWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockOverlayWidget_Unparent_Call) Run(run func()) *MockOverlayWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockOverlayWidget_Unparent_Call) Return() *MockOverlayWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockOverlayWidget_Unparent_Call) RunAndReturn(run func()) *MockOverlayWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockLabelWidget creates a new instance of MockLabelWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockLabelWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockLabelWidget {
	mock := &MockLabelWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockLabelWidget is an autogenerated mock type for the LabelWidget type
type MockLabelWidget struct {
	mock.Mock
}

type MockLabelWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockLabelWidget) EXPECT() *MockLabelWidget_Expecter {
	return &MockLabelWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockLabelWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockLabelWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockLabelWidget_Expecter) AddController(controller interface{}) *MockLabelWidget_AddController_Call {
	return &MockLabelWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockLabelWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockLabelWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_AddController_Call) Return() *MockLabelWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockLabelWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockLabelWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockLabelWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockLabelWidget_Expecter) AddCssClass(cssClass interface{}) *MockLabelWidget_AddCssClass_Call {
	return &MockLabelWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockLabelWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_AddCssClass_Call) Return() *MockLabelWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockLabelWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockLabelWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockLabelWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockLabelWidget_Expecter) ComputePoint(target interface{}) *MockLabelWidget_ComputePoint_Call {
	return &MockLabelWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockLabelWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockLabelWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockLabelWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockLabelWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockLabelWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockLabelWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockLabelWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GetAllocatedHeight() *MockLabelWidget_GetAllocatedHeight_Call {
	return &MockLabelWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockLabelWidget_GetAllocatedHeight_Call) Run(run func()) *MockLabelWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GetAllocatedHeight_Call) Return(n int) *MockLabelWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockLabelWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockLabelWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockLabelWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockLabelWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GetAllocatedWidth() *MockLabelWidget_GetAllocatedWidth_Call {
	return &MockLabelWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockLabelWidget_GetAllocatedWidth_Call) Run(run func()) *MockLabelWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GetAllocatedWidth_Call) Return(n int) *MockLabelWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockLabelWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockLabelWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockLabelWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockLabelWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GetHexpand() *MockLabelWidget_GetHexpand_Call {
	return &MockLabelWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockLabelWidget_GetHexpand_Call) Run(run func()) *MockLabelWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GetHexpand_Call) Return(b bool) *MockLabelWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockLabelWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockLabelWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockLabelWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockLabelWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GetParent() *MockLabelWidget_GetParent_Call {
	return &MockLabelWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockLabelWidget_GetParent_Call) Run(run func()) *MockLabelWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GetParent_Call) Return(widget layout.Widget) *MockLabelWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockLabelWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockLabelWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetText provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GetText() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetText")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockLabelWidget_GetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetText'
type MockLabelWidget_GetText_Call struct {
	*mock.Call
}

// GetText is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GetText() *MockLabelWidget_GetText_Call {
	return &MockLabelWidget_GetText_Call{Call: _e.mock.On("GetText")}
}

func (_c *MockLabelWidget_GetText_Call) Run(run func()) *MockLabelWidget_GetText_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GetText_Call) Return(s string) *MockLabelWidget_GetText_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockLabelWidget_GetText_Call) RunAndReturn(run func() string) *MockLabelWidget_GetText_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockLabelWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockLabelWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GetVexpand() *MockLabelWidget_GetVexpand_Call {
	return &MockLabelWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockLabelWidget_GetVexpand_Call) Run(run func()) *MockLabelWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GetVexpand_Call) Return(b bool) *MockLabelWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockLabelWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockLabelWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockLabelWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockLabelWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GrabFocus() *MockLabelWidget_GrabFocus_Call {
	return &MockLabelWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockLabelWidget_GrabFocus_Call) Run(run func()) *MockLabelWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GrabFocus_Call) Return(b bool) *MockLabelWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockLabelWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockLabelWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockLabelWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockLabelWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) GtkWidget() *MockLabelWidget_GtkWidget_Call {
	return &MockLabelWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockLabelWidget_GtkWidget_Call) Run(run func()) *MockLabelWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockLabelWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockLabelWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockLabelWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockLabelWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockLabelWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockLabelWidget_Expecter) HasCssClass(cssClass interface{}) *MockLabelWidget_HasCssClass_Call {
	return &MockLabelWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockLabelWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_HasCssClass_Call) Return(b bool) *MockLabelWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockLabelWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockLabelWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockLabelWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockLabelWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) HasFocus() *MockLabelWidget_HasFocus_Call {
	return &MockLabelWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockLabelWidget_HasFocus_Call) Run(run func()) *MockLabelWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_HasFocus_Call) Return(b bool) *MockLabelWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockLabelWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockLabelWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) Hide() {
	_mock.Called()
	return
}

// MockLabelWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockLabelWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) Hide() *MockLabelWidget_Hide_Call {
	return &MockLabelWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockLabelWidget_Hide_Call) Run(run func()) *MockLabelWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_Hide_Call) Return() *MockLabelWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_Hide_Call) RunAndReturn(run func()) *MockLabelWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockLabelWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockLabelWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) IsVisible() *MockLabelWidget_IsVisible_Call {
	return &MockLabelWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockLabelWidget_IsVisible_Call) Run(run func()) *MockLabelWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_IsVisible_Call) Return(b bool) *MockLabelWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockLabelWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockLabelWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockLabelWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockLabelWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockLabelWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockLabelWidget_RemoveCssClass_Call {
	return &MockLabelWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockLabelWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockLabelWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_RemoveCssClass_Call) Return() *MockLabelWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockLabelWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockLabelWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockLabelWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockLabelWidget_Expecter) SetCanFocus(canFocus interface{}) *MockLabelWidget_SetCanFocus_Call {
	return &MockLabelWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockLabelWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockLabelWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetCanFocus_Call) Return() *MockLabelWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockLabelWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockLabelWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockLabelWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockLabelWidget_Expecter) SetCanTarget(canTarget interface{}) *MockLabelWidget_SetCanTarget_Call {
	return &MockLabelWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockLabelWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockLabelWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetCanTarget_Call) Return() *MockLabelWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockLabelWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetEllipsize provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetEllipsize(mode layout.EllipsizeMode) {
	_mock.Called(mode)
	return
}

// MockLabelWidget_SetEllipsize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEllipsize'
type MockLabelWidget_SetEllipsize_Call struct {
	*mock.Call
}

// SetEllipsize is a helper method to define mock.On call
//   - mode layout.EllipsizeMode
func (_e *MockLabelWidget_Expecter) SetEllipsize(mode interface{}) *MockLabelWidget_SetEllipsize_Call {
	return &MockLabelWidget_SetEllipsize_Call{Call: _e.mock.On("SetEllipsize", mode)}
}

func (_c *MockLabelWidget_SetEllipsize_Call) Run(run func(mode layout.EllipsizeMode)) *MockLabelWidget_SetEllipsize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.EllipsizeMode
		if args[0] != nil {
			arg0 = args[0].(layout.EllipsizeMode)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetEllipsize_Call) Return() *MockLabelWidget_SetEllipsize_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetEllipsize_Call) RunAndReturn(run func(mode layout.EllipsizeMode)) *MockLabelWidget_SetEllipsize_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockLabelWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockLabelWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockLabelWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockLabelWidget_SetFocusOnClick_Call {
	return &MockLabelWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockLabelWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockLabelWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetFocusOnClick_Call) Return() *MockLabelWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockLabelWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockLabelWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockLabelWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockLabelWidget_Expecter) SetHalign(align interface{}) *MockLabelWidget_SetHalign_Call {
	return &MockLabelWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockLabelWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockLabelWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetHalign_Call) Return() *MockLabelWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockLabelWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockLabelWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockLabelWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockLabelWidget_Expecter) SetHexpand(expand interface{}) *MockLabelWidget_SetHexpand_Call {
	return &MockLabelWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockLabelWidget_SetHexpand_Call) Run(run func(expand bool)) *MockLabelWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetHexpand_Call) Return() *MockLabelWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockLabelWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetMarkup provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetMarkup(markup string) {
	_mock.Called(markup)
	return
}

// MockLabelWidget_SetMarkup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMarkup'
type MockLabelWidget_SetMarkup_Call struct {
	*mock.Call
}

// SetMarkup is a helper method to define mock.On call
//   - markup string
func (_e *MockLabelWidget_Expecter) SetMarkup(markup interface{}) *MockLabelWidget_SetMarkup_Call {
	return &MockLabelWidget_SetMarkup_Call{Call: _e.mock.On("SetMarkup", markup)}
}

func (_c *MockLabelWidget_SetMarkup_Call) Run(run func(markup string)) *MockLabelWidget_SetMarkup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetMarkup_Call) Return() *MockLabelWidget_SetMarkup_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetMarkup_Call) RunAndReturn(run func(markup string)) *MockLabelWidget_SetMarkup_Call {
	_c.Run(run)
	return _c
}

// SetMaxWidthChars provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetMaxWidthChars(nChars int) {
	_mock.Called(nChars)
	return
}

// MockLabelWidget_SetMaxWidthChars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMaxWidthChars'
type MockLabelWidget_SetMaxWidthChars_Call struct {
	*mock.Call
}

// SetMaxWidthChars is a helper method to define mock.On call
//   - nChars int
func (_e *MockLabelWidget_Expecter) SetMaxWidthChars(nChars interface{}) *MockLabelWidget_SetMaxWidthChars_Call {
	return &MockLabelWidget_SetMaxWidthChars_Call{Call: _e.mock.On("SetMaxWidthChars", nChars)}
}

func (_c *MockLabelWidget_SetMaxWidthChars_Call) Run(run func(nChars int)) *MockLabelWidget_SetMaxWidthChars_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetMaxWidthChars_Call) Return() *MockLabelWidget_SetMaxWidthChars_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetMaxWidthChars_Call) RunAndReturn(run func(nChars int)) *MockLabelWidget_SetMaxWidthChars_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockLabelWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockLabelWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockLabelWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockLabelWidget_SetSizeRequest_Call {
	return &MockLabelWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockLabelWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockLabelWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetSizeRequest_Call) Return() *MockLabelWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockLabelWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetText provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetText(text string) {
	_mock.Called(text)
	return
}

// MockLabelWidget_SetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetText'
type MockLabelWidget_SetText_Call struct {
	*mock.Call
}

// SetText is a helper method to define mock.On call
//   - text string
func (_e *MockLabelWidget_Expecter) SetText(text interface{}) *MockLabelWidget_SetText_Call {
	return &MockLabelWidget_SetText_Call{Call: _e.mock.On("SetText", text)}
}

func (_c *MockLabelWidget_SetText_Call) Run(run func(text string)) *MockLabelWidget_SetText_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetText_Call) Return() *MockLabelWidget_SetText_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetText_Call) RunAndReturn(run func(text string)) *MockLabelWidget_SetText_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockLabelWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockLabelWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockLabelWidget_Expecter) SetValign(align interface{}) *MockLabelWidget_SetValign_Call {
	return &MockLabelWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockLabelWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockLabelWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetValign_Call) Return() *MockLabelWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockLabelWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockLabelWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockLabelWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockLabelWidget_Expecter) SetVexpand(expand interface{}) *MockLabelWidget_SetVexpand_Call {
	return &MockLabelWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockLabelWidget_SetVexpand_Call) Run(run func(expand bool)) *MockLabelWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetVexpand_Call) Return() *MockLabelWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockLabelWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockLabelWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockLabelWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockLabelWidget_Expecter) SetVisible(visible interface{}) *MockLabelWidget_SetVisible_Call {
	return &MockLabelWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockLabelWidget_SetVisible_Call) Run(run func(visible bool)) *MockLabelWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetVisible_Call) Return() *MockLabelWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockLabelWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// SetXalign provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) SetXalign(xalign float32) {
	_mock.Called(xalign)
	return
}

// MockLabelWidget_SetXalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXalign'
type MockLabelWidget_SetXalign_Call struct {
	*mock.Call
}

// SetXalign is a helper method to define mock.On call
//   - xalign float32
func (_e *MockLabelWidget_Expecter) SetXalign(xalign interface{}) *MockLabelWidget_SetXalign_Call {
	return &MockLabelWidget_SetXalign_Call{Call: _e.mock.On("SetXalign", xalign)}
}

func (_c *MockLabelWidget_SetXalign_Call) Run(run func(xalign float32)) *MockLabelWidget_SetXalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 float32
		if args[0] != nil {
			arg0 = args[0].(float32)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockLabelWidget_SetXalign_Call) Return() *MockLabelWidget_SetXalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_SetXalign_Call) RunAndReturn(run func(xalign float32)) *MockLabelWidget_SetXalign_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) Show() {
	_mock.Called()
	return
}

// MockLabelWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockLabelWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) Show() *MockLabelWidget_Show_Call {
	return &MockLabelWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockLabelWidget_Show_Call) Run(run func()) *MockLabelWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_Show_Call) Return() *MockLabelWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_Show_Call) RunAndReturn(run func()) *MockLabelWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockLabelWidget
func (_mock *MockLabelWidget) Unparent() {
	_mock.Called()
	return
}

// MockLabelWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockLabelWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockLabelWidget_Expecter) Unparent() *MockLabelWidget_Unparent_Call {
	return &MockLabelWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockLabelWidget_Unparent_Call) Run(run func()) *MockLabelWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockLabelWidget_Unparent_Call) Return() *MockLabelWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockLabelWidget_Unparent_Call) RunAndReturn(run func()) *MockLabelWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockButtonWidget creates a new instance of MockButtonWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockButtonWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockButtonWidget {
	mock := &MockButtonWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockButtonWidget is an autogenerated mock type for the ButtonWidget type
type MockButtonWidget struct {
	mock.Mock
}

type MockButtonWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockButtonWidget) EXPECT() *MockButtonWidget_Expecter {
	return &MockButtonWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockButtonWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockButtonWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockButtonWidget_Expecter) AddController(controller interface{}) *MockButtonWidget_AddController_Call {
	return &MockButtonWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockButtonWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockButtonWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_AddController_Call) Return() *MockButtonWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockButtonWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockButtonWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockButtonWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockButtonWidget_Expecter) AddCssClass(cssClass interface{}) *MockButtonWidget_AddCssClass_Call {
	return &MockButtonWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockButtonWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_AddCssClass_Call) Return() *MockButtonWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockButtonWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockButtonWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockButtonWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockButtonWidget_Expecter) ComputePoint(target interface{}) *MockButtonWidget_ComputePoint_Call {
	return &MockButtonWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockButtonWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockButtonWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockButtonWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockButtonWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockButtonWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectClicked provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) ConnectClicked(callback func()) uint32 {
	ret := _mock.Called(callback)

	if len(ret) == 0 {
		panic("no return value specified for ConnectClicked")
	}

	var r0 uint32
	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
		r0 = returnFunc(callback)
	} else {
		r0 = ret.Get(0).(uint32)
	}
	return r0
}

// MockButtonWidget_ConnectClicked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectClicked'
type MockButtonWidget_ConnectClicked_Call struct {
	*mock.Call
}

// ConnectClicked is a helper method to define mock.On call
//   - callback func()
func (_e *MockButtonWidget_Expecter) ConnectClicked(callback interface{}) *MockButtonWidget_ConnectClicked_Call {
	return &MockButtonWidget_ConnectClicked_Call{Call: _e.mock.On("ConnectClicked", callback)}
}

func (_c *MockButtonWidget_ConnectClicked_Call) Run(run func(callback func())) *MockButtonWidget_ConnectClicked_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 func()
		if args[0] != nil {
			arg0 = args[0].(func())
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_ConnectClicked_Call) Return(v uint32) *MockButtonWidget_ConnectClicked_Call {
	_c.Call.Return(v)
	return _c
}

func (_c *MockButtonWidget_ConnectClicked_Call) RunAndReturn(run func(callback func()) uint32) *MockButtonWidget_ConnectClicked_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockButtonWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockButtonWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetAllocatedHeight() *MockButtonWidget_GetAllocatedHeight_Call {
	return &MockButtonWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockButtonWidget_GetAllocatedHeight_Call) Run(run func()) *MockButtonWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetAllocatedHeight_Call) Return(n int) *MockButtonWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockButtonWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockButtonWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockButtonWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockButtonWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetAllocatedWidth() *MockButtonWidget_GetAllocatedWidth_Call {
	return &MockButtonWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockButtonWidget_GetAllocatedWidth_Call) Run(run func()) *MockButtonWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetAllocatedWidth_Call) Return(n int) *MockButtonWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockButtonWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockButtonWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetChild provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetChild() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetChild")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockButtonWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
type MockButtonWidget_GetChild_Call struct {
	*mock.Call
}

// GetChild is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetChild() *MockButtonWidget_GetChild_Call {
	return &MockButtonWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
}

func (_c *MockButtonWidget_GetChild_Call) Run(run func()) *MockButtonWidget_GetChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetChild_Call) Return(widget layout.Widget) *MockButtonWidget_GetChild_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockButtonWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) *MockButtonWidget_GetChild_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockButtonWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockButtonWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetHexpand() *MockButtonWidget_GetHexpand_Call {
	return &MockButtonWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockButtonWidget_GetHexpand_Call) Run(run func()) *MockButtonWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetHexpand_Call) Return(b bool) *MockButtonWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockButtonWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockButtonWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetLabel provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetLabel() string {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetLabel")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func() string); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockButtonWidget_GetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabel'
type MockButtonWidget_GetLabel_Call struct {
	*mock.Call
}

// GetLabel is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetLabel() *MockButtonWidget_GetLabel_Call {
	return &MockButtonWidget_GetLabel_Call{Call: _e.mock.On("GetLabel")}
}

func (_c *MockButtonWidget_GetLabel_Call) Run(run func()) *MockButtonWidget_GetLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetLabel_Call) Return(s string) *MockButtonWidget_GetLabel_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockButtonWidget_GetLabel_Call) RunAndReturn(run func() string) *MockButtonWidget_GetLabel_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockButtonWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockButtonWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetParent() *MockButtonWidget_GetParent_Call {
	return &MockButtonWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockButtonWidget_GetParent_Call) Run(run func()) *MockButtonWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetParent_Call) Return(widget layout.Widget) *MockButtonWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockButtonWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockButtonWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockButtonWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockButtonWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GetVexpand() *MockButtonWidget_GetVexpand_Call {
	return &MockButtonWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockButtonWidget_GetVexpand_Call) Run(run func()) *MockButtonWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GetVexpand_Call) Return(b bool) *MockButtonWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockButtonWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockButtonWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockButtonWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockButtonWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GrabFocus() *MockButtonWidget_GrabFocus_Call {
	return &MockButtonWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockButtonWidget_GrabFocus_Call) Run(run func()) *MockButtonWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GrabFocus_Call) Return(b bool) *MockButtonWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockButtonWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockButtonWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockButtonWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockButtonWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) GtkWidget() *MockButtonWidget_GtkWidget_Call {
	return &MockButtonWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockButtonWidget_GtkWidget_Call) Run(run func()) *MockButtonWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockButtonWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockButtonWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockButtonWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockButtonWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockButtonWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockButtonWidget_Expecter) HasCssClass(cssClass interface{}) *MockButtonWidget_HasCssClass_Call {
	return &MockButtonWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockButtonWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_HasCssClass_Call) Return(b bool) *MockButtonWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockButtonWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockButtonWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockButtonWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockButtonWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) HasFocus() *MockButtonWidget_HasFocus_Call {
	return &MockButtonWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockButtonWidget_HasFocus_Call) Run(run func()) *MockButtonWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_HasFocus_Call) Return(b bool) *MockButtonWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockButtonWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockButtonWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) Hide() {
	_mock.Called()
	return
}

// MockButtonWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockButtonWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) Hide() *MockButtonWidget_Hide_Call {
	return &MockButtonWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockButtonWidget_Hide_Call) Run(run func()) *MockButtonWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_Hide_Call) Return() *MockButtonWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_Hide_Call) RunAndReturn(run func()) *MockButtonWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockButtonWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockButtonWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) IsVisible() *MockButtonWidget_IsVisible_Call {
	return &MockButtonWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockButtonWidget_IsVisible_Call) Run(run func()) *MockButtonWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_IsVisible_Call) Return(b bool) *MockButtonWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockButtonWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockButtonWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockButtonWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockButtonWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockButtonWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockButtonWidget_RemoveCssClass_Call {
	return &MockButtonWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockButtonWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockButtonWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_RemoveCssClass_Call) Return() *MockButtonWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockButtonWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockButtonWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockButtonWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockButtonWidget_Expecter) SetCanFocus(canFocus interface{}) *MockButtonWidget_SetCanFocus_Call {
	return &MockButtonWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockButtonWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockButtonWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetCanFocus_Call) Return() *MockButtonWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockButtonWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockButtonWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockButtonWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockButtonWidget_Expecter) SetCanTarget(canTarget interface{}) *MockButtonWidget_SetCanTarget_Call {
	return &MockButtonWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockButtonWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockButtonWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetCanTarget_Call) Return() *MockButtonWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockButtonWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetChild provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetChild(child layout.Widget) {
	_mock.Called(child)
	return
}

// MockButtonWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
type MockButtonWidget_SetChild_Call struct {
	*mock.Call
}

// SetChild is a helper method to define mock.On call
//   - child layout.Widget
func (_e *MockButtonWidget_Expecter) SetChild(child interface{}) *MockButtonWidget_SetChild_Call {
	return &MockButtonWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
}

func (_c *MockButtonWidget_SetChild_Call) Run(run func(child layout.Widget)) *MockButtonWidget_SetChild_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetChild_Call) Return() *MockButtonWidget_SetChild_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) *MockButtonWidget_SetChild_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockButtonWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockButtonWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockButtonWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockButtonWidget_SetFocusOnClick_Call {
	return &MockButtonWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockButtonWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockButtonWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetFocusOnClick_Call) Return() *MockButtonWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockButtonWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockButtonWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockButtonWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockButtonWidget_Expecter) SetHalign(align interface{}) *MockButtonWidget_SetHalign_Call {
	return &MockButtonWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockButtonWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetHalign_Call) Return() *MockButtonWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockButtonWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockButtonWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockButtonWidget_Expecter) SetHexpand(expand interface{}) *MockButtonWidget_SetHexpand_Call {
	return &MockButtonWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockButtonWidget_SetHexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetHexpand_Call) Return() *MockButtonWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetLabel provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetLabel(label string) {
	_mock.Called(label)
	return
}

// MockButtonWidget_SetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabel'
type MockButtonWidget_SetLabel_Call struct {
	*mock.Call
}

// SetLabel is a helper method to define mock.On call
//   - label string
func (_e *MockButtonWidget_Expecter) SetLabel(label interface{}) *MockButtonWidget_SetLabel_Call {
	return &MockButtonWidget_SetLabel_Call{Call: _e.mock.On("SetLabel", label)}
}

func (_c *MockButtonWidget_SetLabel_Call) Run(run func(label string)) *MockButtonWidget_SetLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetLabel_Call) Return() *MockButtonWidget_SetLabel_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetLabel_Call) RunAndReturn(run func(label string)) *MockButtonWidget_SetLabel_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockButtonWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockButtonWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockButtonWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockButtonWidget_SetSizeRequest_Call {
	return &MockButtonWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockButtonWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetSizeRequest_Call) Return() *MockButtonWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockButtonWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockButtonWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockButtonWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockButtonWidget_Expecter) SetValign(align interface{}) *MockButtonWidget_SetValign_Call {
	return &MockButtonWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockButtonWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetValign_Call) Return() *MockButtonWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockButtonWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockButtonWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockButtonWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockButtonWidget_Expecter) SetVexpand(expand interface{}) *MockButtonWidget_SetVexpand_Call {
	return &MockButtonWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockButtonWidget_SetVexpand_Call) Run(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetVexpand_Call) Return() *MockButtonWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockButtonWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockButtonWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockButtonWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockButtonWidget_Expecter) SetVisible(visible interface{}) *MockButtonWidget_SetVisible_Call {
	return &MockButtonWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockButtonWidget_SetVisible_Call) Run(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockButtonWidget_SetVisible_Call) Return() *MockButtonWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockButtonWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) Show() {
	_mock.Called()
	return
}

// MockButtonWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockButtonWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) Show() *MockButtonWidget_Show_Call {
	return &MockButtonWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockButtonWidget_Show_Call) Run(run func()) *MockButtonWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_Show_Call) Return() *MockButtonWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_Show_Call) RunAndReturn(run func()) *MockButtonWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockButtonWidget
func (_mock *MockButtonWidget) Unparent() {
	_mock.Called()
	return
}

// MockButtonWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockButtonWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockButtonWidget_Expecter) Unparent() *MockButtonWidget_Unparent_Call {
	return &MockButtonWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockButtonWidget_Unparent_Call) Run(run func()) *MockButtonWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockButtonWidget_Unparent_Call) Return() *MockButtonWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockButtonWidget_Unparent_Call) RunAndReturn(run func()) *MockButtonWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockImageWidget creates a new instance of MockImageWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockImageWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockImageWidget {
	mock := &MockImageWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockImageWidget is an autogenerated mock type for the ImageWidget type
type MockImageWidget struct {
	mock.Mock
}

type MockImageWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockImageWidget) EXPECT() *MockImageWidget_Expecter {
	return &MockImageWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockImageWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockImageWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockImageWidget_Expecter) AddController(controller interface{}) *MockImageWidget_AddController_Call {
	return &MockImageWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockImageWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_AddController_Call) Return() *MockImageWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockImageWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockImageWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockImageWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockImageWidget_Expecter) AddCssClass(cssClass interface{}) *MockImageWidget_AddCssClass_Call {
	return &MockImageWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockImageWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_AddCssClass_Call) Return() *MockImageWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// Clear provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) Clear() {
	_mock.Called()
	return
}

// MockImageWidget_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
type MockImageWidget_Clear_Call struct {
	*mock.Call
}

// Clear is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) Clear() *MockImageWidget_Clear_Call {
	return &MockImageWidget_Clear_Call{Call: _e.mock.On("Clear")}
}

func (_c *MockImageWidget_Clear_Call) Run(run func()) *MockImageWidget_Clear_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_Clear_Call) Return() *MockImageWidget_Clear_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_Clear_Call) RunAndReturn(run func()) *MockImageWidget_Clear_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockImageWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockImageWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockImageWidget_Expecter) ComputePoint(target interface{}) *MockImageWidget_ComputePoint_Call {
	return &MockImageWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockImageWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockImageWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockImageWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockImageWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockImageWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockImageWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockImageWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GetAllocatedHeight() *MockImageWidget_GetAllocatedHeight_Call {
	return &MockImageWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockImageWidget_GetAllocatedHeight_Call) Run(run func()) *MockImageWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GetAllocatedHeight_Call) Return(n int) *MockImageWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockImageWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockImageWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockImageWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GetAllocatedWidth() *MockImageWidget_GetAllocatedWidth_Call {
	return &MockImageWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockImageWidget_GetAllocatedWidth_Call) Run(run func()) *MockImageWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GetAllocatedWidth_Call) Return(n int) *MockImageWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockImageWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockImageWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockImageWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockImageWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GetHexpand() *MockImageWidget_GetHexpand_Call {
	return &MockImageWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockImageWidget_GetHexpand_Call) Run(run func()) *MockImageWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GetHexpand_Call) Return(b bool) *MockImageWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImageWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockImageWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockImageWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GetParent() *MockImageWidget_GetParent_Call {
	return &MockImageWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockImageWidget_GetParent_Call) Run(run func()) *MockImageWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GetParent_Call) Return(widget layout.Widget) *MockImageWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockImageWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockImageWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockImageWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockImageWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GetVexpand() *MockImageWidget_GetVexpand_Call {
	return &MockImageWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockImageWidget_GetVexpand_Call) Run(run func()) *MockImageWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GetVexpand_Call) Return(b bool) *MockImageWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImageWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockImageWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockImageWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockImageWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GrabFocus() *MockImageWidget_GrabFocus_Call {
	return &MockImageWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockImageWidget_GrabFocus_Call) Run(run func()) *MockImageWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GrabFocus_Call) Return(b bool) *MockImageWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImageWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockImageWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockImageWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) GtkWidget() *MockImageWidget_GtkWidget_Call {
	return &MockImageWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockImageWidget_GtkWidget_Call) Run(run func()) *MockImageWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockImageWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockImageWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockImageWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockImageWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockImageWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockImageWidget_Expecter) HasCssClass(cssClass interface{}) *MockImageWidget_HasCssClass_Call {
	return &MockImageWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockImageWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_HasCssClass_Call) Return(b bool) *MockImageWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImageWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockImageWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockImageWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockImageWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) HasFocus() *MockImageWidget_HasFocus_Call {
	return &MockImageWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockImageWidget_HasFocus_Call) Run(run func()) *MockImageWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_HasFocus_Call) Return(b bool) *MockImageWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImageWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockImageWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) Hide() {
	_mock.Called()
	return
}

// MockImageWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockImageWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) Hide() *MockImageWidget_Hide_Call {
	return &MockImageWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockImageWidget_Hide_Call) Run(run func()) *MockImageWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_Hide_Call) Return() *MockImageWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_Hide_Call) RunAndReturn(run func()) *MockImageWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockImageWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockImageWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) IsVisible() *MockImageWidget_IsVisible_Call {
	return &MockImageWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockImageWidget_IsVisible_Call) Run(run func()) *MockImageWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_IsVisible_Call) Return(b bool) *MockImageWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImageWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockImageWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockImageWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockImageWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockImageWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockImageWidget_RemoveCssClass_Call {
	return &MockImageWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockImageWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_RemoveCssClass_Call) Return() *MockImageWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockImageWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockImageWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockImageWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockImageWidget_Expecter) SetCanFocus(canFocus interface{}) *MockImageWidget_SetCanFocus_Call {
	return &MockImageWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockImageWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetCanFocus_Call) Return() *MockImageWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockImageWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockImageWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockImageWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockImageWidget_Expecter) SetCanTarget(canTarget interface{}) *MockImageWidget_SetCanTarget_Call {
	return &MockImageWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockImageWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockImageWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetCanTarget_Call) Return() *MockImageWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockImageWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockImageWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockImageWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockImageWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockImageWidget_SetFocusOnClick_Call {
	return &MockImageWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockImageWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetFocusOnClick_Call) Return() *MockImageWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockImageWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetFromFile provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetFromFile(filename string) {
	_mock.Called(filename)
	return
}

// MockImageWidget_SetFromFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromFile'
type MockImageWidget_SetFromFile_Call struct {
	*mock.Call
}

// SetFromFile is a helper method to define mock.On call
//   - filename string
func (_e *MockImageWidget_Expecter) SetFromFile(filename interface{}) *MockImageWidget_SetFromFile_Call {
	return &MockImageWidget_SetFromFile_Call{Call: _e.mock.On("SetFromFile", filename)}
}

func (_c *MockImageWidget_SetFromFile_Call) Run(run func(filename string)) *MockImageWidget_SetFromFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetFromFile_Call) Return() *MockImageWidget_SetFromFile_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetFromFile_Call) RunAndReturn(run func(filename string)) *MockImageWidget_SetFromFile_Call {
	_c.Run(run)
	return _c
}

// SetFromIconName provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetFromIconName(iconName string) {
	_mock.Called(iconName)
	return
}

// MockImageWidget_SetFromIconName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromIconName'
type MockImageWidget_SetFromIconName_Call struct {
	*mock.Call
}

// SetFromIconName is a helper method to define mock.On call
//   - iconName string
func (_e *MockImageWidget_Expecter) SetFromIconName(iconName interface{}) *MockImageWidget_SetFromIconName_Call {
	return &MockImageWidget_SetFromIconName_Call{Call: _e.mock.On("SetFromIconName", iconName)}
}

func (_c *MockImageWidget_SetFromIconName_Call) Run(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetFromIconName_Call) Return() *MockImageWidget_SetFromIconName_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetFromIconName_Call) RunAndReturn(run func(iconName string)) *MockImageWidget_SetFromIconName_Call {
	_c.Run(run)
	return _c
}

// SetFromPaintable provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetFromPaintable(paintable layout.Paintable) {
	_mock.Called(paintable)
	return
}

// MockImageWidget_SetFromPaintable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromPaintable'
type MockImageWidget_SetFromPaintable_Call struct {
	*mock.Call
}

// SetFromPaintable is a helper method to define mock.On call
//   - paintable layout.Paintable
func (_e *MockImageWidget_Expecter) SetFromPaintable(paintable interface{}) *MockImageWidget_SetFromPaintable_Call {
	return &MockImageWidget_SetFromPaintable_Call{Call: _e.mock.On("SetFromPaintable", paintable)}
}

func (_c *MockImageWidget_SetFromPaintable_Call) Run(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Paintable
		if args[0] != nil {
			arg0 = args[0].(layout.Paintable)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetFromPaintable_Call) Return() *MockImageWidget_SetFromPaintable_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetFromPaintable_Call) RunAndReturn(run func(paintable layout.Paintable)) *MockImageWidget_SetFromPaintable_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockImageWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockImageWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockImageWidget_Expecter) SetHalign(align interface{}) *MockImageWidget_SetHalign_Call {
	return &MockImageWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockImageWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetHalign_Call) Return() *MockImageWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockImageWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockImageWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockImageWidget_Expecter) SetHexpand(expand interface{}) *MockImageWidget_SetHexpand_Call {
	return &MockImageWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockImageWidget_SetHexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetHexpand_Call) Return() *MockImageWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetPixelSize provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetPixelSize(pixelSize int) {
	_mock.Called(pixelSize)
	return
}

// MockImageWidget_SetPixelSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPixelSize'
type MockImageWidget_SetPixelSize_Call struct {
	*mock.Call
}

// SetPixelSize is a helper method to define mock.On call
//   - pixelSize int
func (_e *MockImageWidget_Expecter) SetPixelSize(pixelSize interface{}) *MockImageWidget_SetPixelSize_Call {
	return &MockImageWidget_SetPixelSize_Call{Call: _e.mock.On("SetPixelSize", pixelSize)}
}

func (_c *MockImageWidget_SetPixelSize_Call) Run(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetPixelSize_Call) Return() *MockImageWidget_SetPixelSize_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetPixelSize_Call) RunAndReturn(run func(pixelSize int)) *MockImageWidget_SetPixelSize_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockImageWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockImageWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockImageWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockImageWidget_SetSizeRequest_Call {
	return &MockImageWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockImageWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetSizeRequest_Call) Return() *MockImageWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockImageWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockImageWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockImageWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockImageWidget_Expecter) SetValign(align interface{}) *MockImageWidget_SetValign_Call {
	return &MockImageWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockImageWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetValign_Call) Return() *MockImageWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockImageWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockImageWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockImageWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockImageWidget_Expecter) SetVexpand(expand interface{}) *MockImageWidget_SetVexpand_Call {
	return &MockImageWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockImageWidget_SetVexpand_Call) Run(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetVexpand_Call) Return() *MockImageWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockImageWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockImageWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockImageWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockImageWidget_Expecter) SetVisible(visible interface{}) *MockImageWidget_SetVisible_Call {
	return &MockImageWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockImageWidget_SetVisible_Call) Run(run func(visible bool)) *MockImageWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockImageWidget_SetVisible_Call) Return() *MockImageWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockImageWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) Show() {
	_mock.Called()
	return
}

// MockImageWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockImageWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) Show() *MockImageWidget_Show_Call {
	return &MockImageWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockImageWidget_Show_Call) Run(run func()) *MockImageWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_Show_Call) Return() *MockImageWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_Show_Call) RunAndReturn(run func()) *MockImageWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockImageWidget
func (_mock *MockImageWidget) Unparent() {
	_mock.Called()
	return
}

// MockImageWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockImageWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockImageWidget_Expecter) Unparent() *MockImageWidget_Unparent_Call {
	return &MockImageWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockImageWidget_Unparent_Call) Run(run func()) *MockImageWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImageWidget_Unparent_Call) Return() *MockImageWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockImageWidget_Unparent_Call) RunAndReturn(run func()) *MockImageWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockProgressBarWidget creates a new instance of MockProgressBarWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockProgressBarWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProgressBarWidget {
	mock := &MockProgressBarWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockProgressBarWidget is an autogenerated mock type for the ProgressBarWidget type
type MockProgressBarWidget struct {
	mock.Mock
}

type MockProgressBarWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockProgressBarWidget) EXPECT() *MockProgressBarWidget_Expecter {
	return &MockProgressBarWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockProgressBarWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockProgressBarWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockProgressBarWidget_Expecter) AddController(controller interface{}) *MockProgressBarWidget_AddController_Call {
	return &MockProgressBarWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockProgressBarWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_AddController_Call) Return() *MockProgressBarWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockProgressBarWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockProgressBarWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockProgressBarWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockProgressBarWidget_Expecter) AddCssClass(cssClass interface{}) *MockProgressBarWidget_AddCssClass_Call {
	return &MockProgressBarWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockProgressBarWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_AddCssClass_Call) Return() *MockProgressBarWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockProgressBarWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockProgressBarWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockProgressBarWidget_Expecter) ComputePoint(target interface{}) *MockProgressBarWidget_ComputePoint_Call {
	return &MockProgressBarWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockProgressBarWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockProgressBarWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockProgressBarWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockProgressBarWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockProgressBarWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockProgressBarWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockProgressBarWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GetAllocatedHeight() *MockProgressBarWidget_GetAllocatedHeight_Call {
	return &MockProgressBarWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) Return(n int) *MockProgressBarWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockProgressBarWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockProgressBarWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockProgressBarWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GetAllocatedWidth() *MockProgressBarWidget_GetAllocatedWidth_Call {
	return &MockProgressBarWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Run(run func()) *MockProgressBarWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) Return(n int) *MockProgressBarWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockProgressBarWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockProgressBarWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetFraction provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GetFraction() float64 {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetFraction")
	}

	var r0 float64
	if returnFunc, ok := ret.Get(0).(func() float64); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(float64)
	}
	return r0
}

// MockProgressBarWidget_GetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFraction'
type MockProgressBarWidget_GetFraction_Call struct {
	*mock.Call
}

// GetFraction is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GetFraction() *MockProgressBarWidget_GetFraction_Call {
	return &MockProgressBarWidget_GetFraction_Call{Call: _e.mock.On("GetFraction")}
}

func (_c *MockProgressBarWidget_GetFraction_Call) Run(run func()) *MockProgressBarWidget_GetFraction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GetFraction_Call) Return(f float64) *MockProgressBarWidget_GetFraction_Call {
	_c.Call.Return(f)
	return _c
}

func (_c *MockProgressBarWidget_GetFraction_Call) RunAndReturn(run func() float64) *MockProgressBarWidget_GetFraction_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockProgressBarWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockProgressBarWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GetHexpand() *MockProgressBarWidget_GetHexpand_Call {
	return &MockProgressBarWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockProgressBarWidget_GetHexpand_Call) Run(run func()) *MockProgressBarWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GetHexpand_Call) Return(b bool) *MockProgressBarWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockProgressBarWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockProgressBarWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockProgressBarWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GetParent() *MockProgressBarWidget_GetParent_Call {
	return &MockProgressBarWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockProgressBarWidget_GetParent_Call) Run(run func()) *MockProgressBarWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GetParent_Call) Return(widget layout.Widget) *MockProgressBarWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockProgressBarWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockProgressBarWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockProgressBarWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockProgressBarWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GetVexpand() *MockProgressBarWidget_GetVexpand_Call {
	return &MockProgressBarWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockProgressBarWidget_GetVexpand_Call) Run(run func()) *MockProgressBarWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GetVexpand_Call) Return(b bool) *MockProgressBarWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockProgressBarWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockProgressBarWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockProgressBarWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GrabFocus() *MockProgressBarWidget_GrabFocus_Call {
	return &MockProgressBarWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockProgressBarWidget_GrabFocus_Call) Run(run func()) *MockProgressBarWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GrabFocus_Call) Return(b bool) *MockProgressBarWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockProgressBarWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockProgressBarWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockProgressBarWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) GtkWidget() *MockProgressBarWidget_GtkWidget_Call {
	return &MockProgressBarWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockProgressBarWidget_GtkWidget_Call) Run(run func()) *MockProgressBarWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockProgressBarWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockProgressBarWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockProgressBarWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockProgressBarWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockProgressBarWidget_Expecter) HasCssClass(cssClass interface{}) *MockProgressBarWidget_HasCssClass_Call {
	return &MockProgressBarWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockProgressBarWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_HasCssClass_Call) Return(b bool) *MockProgressBarWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockProgressBarWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockProgressBarWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockProgressBarWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockProgressBarWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) HasFocus() *MockProgressBarWidget_HasFocus_Call {
	return &MockProgressBarWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockProgressBarWidget_HasFocus_Call) Run(run func()) *MockProgressBarWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_HasFocus_Call) Return(b bool) *MockProgressBarWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockProgressBarWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) Hide() {
	_mock.Called()
	return
}

// MockProgressBarWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockProgressBarWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) Hide() *MockProgressBarWidget_Hide_Call {
	return &MockProgressBarWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockProgressBarWidget_Hide_Call) Run(run func()) *MockProgressBarWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_Hide_Call) Return() *MockProgressBarWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_Hide_Call) RunAndReturn(run func()) *MockProgressBarWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockProgressBarWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockProgressBarWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) IsVisible() *MockProgressBarWidget_IsVisible_Call {
	return &MockProgressBarWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockProgressBarWidget_IsVisible_Call) Run(run func()) *MockProgressBarWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_IsVisible_Call) Return(b bool) *MockProgressBarWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockProgressBarWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockProgressBarWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockProgressBarWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockProgressBarWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockProgressBarWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockProgressBarWidget_RemoveCssClass_Call {
	return &MockProgressBarWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockProgressBarWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_RemoveCssClass_Call) Return() *MockProgressBarWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockProgressBarWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockProgressBarWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockProgressBarWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockProgressBarWidget_Expecter) SetCanFocus(canFocus interface{}) *MockProgressBarWidget_SetCanFocus_Call {
	return &MockProgressBarWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockProgressBarWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetCanFocus_Call) Return() *MockProgressBarWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockProgressBarWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockProgressBarWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockProgressBarWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockProgressBarWidget_Expecter) SetCanTarget(canTarget interface{}) *MockProgressBarWidget_SetCanTarget_Call {
	return &MockProgressBarWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockProgressBarWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetCanTarget_Call) Return() *MockProgressBarWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockProgressBarWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockProgressBarWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockProgressBarWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockProgressBarWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockProgressBarWidget_SetFocusOnClick_Call {
	return &MockProgressBarWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetFocusOnClick_Call) Return() *MockProgressBarWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockProgressBarWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetFraction provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetFraction(fraction float64) {
	_mock.Called(fraction)
	return
}

// MockProgressBarWidget_SetFraction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFraction'
type MockProgressBarWidget_SetFraction_Call struct {
	*mock.Call
}

// SetFraction is a helper method to define mock.On call
//   - fraction float64
func (_e *MockProgressBarWidget_Expecter) SetFraction(fraction interface{}) *MockProgressBarWidget_SetFraction_Call {
	return &MockProgressBarWidget_SetFraction_Call{Call: _e.mock.On("SetFraction", fraction)}
}

func (_c *MockProgressBarWidget_SetFraction_Call) Run(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 float64
		if args[0] != nil {
			arg0 = args[0].(float64)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetFraction_Call) Return() *MockProgressBarWidget_SetFraction_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetFraction_Call) RunAndReturn(run func(fraction float64)) *MockProgressBarWidget_SetFraction_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockProgressBarWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockProgressBarWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockProgressBarWidget_Expecter) SetHalign(align interface{}) *MockProgressBarWidget_SetHalign_Call {
	return &MockProgressBarWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockProgressBarWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetHalign_Call) Return() *MockProgressBarWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockProgressBarWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockProgressBarWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockProgressBarWidget_Expecter) SetHexpand(expand interface{}) *MockProgressBarWidget_SetHexpand_Call {
	return &MockProgressBarWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockProgressBarWidget_SetHexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetHexpand_Call) Return() *MockProgressBarWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockProgressBarWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockProgressBarWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockProgressBarWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockProgressBarWidget_SetSizeRequest_Call {
	return &MockProgressBarWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockProgressBarWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetSizeRequest_Call) Return() *MockProgressBarWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockProgressBarWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockProgressBarWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockProgressBarWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockProgressBarWidget_Expecter) SetValign(align interface{}) *MockProgressBarWidget_SetValign_Call {
	return &MockProgressBarWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockProgressBarWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetValign_Call) Return() *MockProgressBarWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockProgressBarWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockProgressBarWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockProgressBarWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockProgressBarWidget_Expecter) SetVexpand(expand interface{}) *MockProgressBarWidget_SetVexpand_Call {
	return &MockProgressBarWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockProgressBarWidget_SetVexpand_Call) Run(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetVexpand_Call) Return() *MockProgressBarWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockProgressBarWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockProgressBarWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockProgressBarWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockProgressBarWidget_Expecter) SetVisible(visible interface{}) *MockProgressBarWidget_SetVisible_Call {
	return &MockProgressBarWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockProgressBarWidget_SetVisible_Call) Run(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockProgressBarWidget_SetVisible_Call) Return() *MockProgressBarWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockProgressBarWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) Show() {
	_mock.Called()
	return
}

// MockProgressBarWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockProgressBarWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) Show() *MockProgressBarWidget_Show_Call {
	return &MockProgressBarWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockProgressBarWidget_Show_Call) Run(run func()) *MockProgressBarWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_Show_Call) Return() *MockProgressBarWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_Show_Call) RunAndReturn(run func()) *MockProgressBarWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockProgressBarWidget
func (_mock *MockProgressBarWidget) Unparent() {
	_mock.Called()
	return
}

// MockProgressBarWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockProgressBarWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockProgressBarWidget_Expecter) Unparent() *MockProgressBarWidget_Unparent_Call {
	return &MockProgressBarWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockProgressBarWidget_Unparent_Call) Run(run func()) *MockProgressBarWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockProgressBarWidget_Unparent_Call) Return() *MockProgressBarWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockProgressBarWidget_Unparent_Call) RunAndReturn(run func()) *MockProgressBarWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockSpinnerWidget creates a new instance of MockSpinnerWidget. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSpinnerWidget(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSpinnerWidget {
	mock := &MockSpinnerWidget{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockSpinnerWidget is an autogenerated mock type for the SpinnerWidget type
type MockSpinnerWidget struct {
	mock.Mock
}

type MockSpinnerWidget_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSpinnerWidget) EXPECT() *MockSpinnerWidget_Expecter {
	return &MockSpinnerWidget_Expecter{mock: &_m.Mock}
}

// AddController provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) AddController(controller *gtk.EventController) {
	_mock.Called(controller)
	return
}

// MockSpinnerWidget_AddController_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddController'
type MockSpinnerWidget_AddController_Call struct {
	*mock.Call
}

// AddController is a helper method to define mock.On call
//   - controller *gtk.EventController
func (_e *MockSpinnerWidget_Expecter) AddController(controller interface{}) *MockSpinnerWidget_AddController_Call {
	return &MockSpinnerWidget_AddController_Call{Call: _e.mock.On("AddController", controller)}
}

func (_c *MockSpinnerWidget_AddController_Call) Run(run func(controller *gtk.EventController)) *MockSpinnerWidget_AddController_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.EventController
		if args[0] != nil {
			arg0 = args[0].(*gtk.EventController)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_AddController_Call) Return() *MockSpinnerWidget_AddController_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_AddController_Call) RunAndReturn(run func(controller *gtk.EventController)) *MockSpinnerWidget_AddController_Call {
	_c.Run(run)
	return _c
}

// AddCssClass provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) AddCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockSpinnerWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
type MockSpinnerWidget_AddCssClass_Call struct {
	*mock.Call
}

// AddCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockSpinnerWidget_Expecter) AddCssClass(cssClass interface{}) *MockSpinnerWidget_AddCssClass_Call {
	return &MockSpinnerWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
}

func (_c *MockSpinnerWidget_AddCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_AddCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_AddCssClass_Call) Return() *MockSpinnerWidget_AddCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) *MockSpinnerWidget_AddCssClass_Call {
	_c.Run(run)
	return _c
}

// ComputePoint provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) ComputePoint(target layout.Widget) (float64, float64, bool) {
	ret := _mock.Called(target)

	if len(ret) == 0 {
		panic("no return value specified for ComputePoint")
	}

	var r0 float64
	var r1 float64
	var r2 bool
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) (float64, float64, bool)); ok {
		return returnFunc(target)
	}
	if returnFunc, ok := ret.Get(0).(func(layout.Widget) float64); ok {
		r0 = returnFunc(target)
	} else {
		r0 = ret.Get(0).(float64)
	}
	if returnFunc, ok := ret.Get(1).(func(layout.Widget) float64); ok {
		r1 = returnFunc(target)
	} else {
		r1 = ret.Get(1).(float64)
	}
	if returnFunc, ok := ret.Get(2).(func(layout.Widget) bool); ok {
		r2 = returnFunc(target)
	} else {
		r2 = ret.Get(2).(bool)
	}
	return r0, r1, r2
}

// MockSpinnerWidget_ComputePoint_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ComputePoint'
type MockSpinnerWidget_ComputePoint_Call struct {
	*mock.Call
}

// ComputePoint is a helper method to define mock.On call
//   - target layout.Widget
func (_e *MockSpinnerWidget_Expecter) ComputePoint(target interface{}) *MockSpinnerWidget_ComputePoint_Call {
	return &MockSpinnerWidget_ComputePoint_Call{Call: _e.mock.On("ComputePoint", target)}
}

func (_c *MockSpinnerWidget_ComputePoint_Call) Run(run func(target layout.Widget)) *MockSpinnerWidget_ComputePoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Widget
		if args[0] != nil {
			arg0 = args[0].(layout.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_ComputePoint_Call) Return(x float64, y float64, ok bool) *MockSpinnerWidget_ComputePoint_Call {
	_c.Call.Return(x, y, ok)
	return _c
}

func (_c *MockSpinnerWidget_ComputePoint_Call) RunAndReturn(run func(target layout.Widget) (float64, float64, bool)) *MockSpinnerWidget_ComputePoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedHeight provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GetAllocatedHeight() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedHeight")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockSpinnerWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
type MockSpinnerWidget_GetAllocatedHeight_Call struct {
	*mock.Call
}

// GetAllocatedHeight is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GetAllocatedHeight() *MockSpinnerWidget_GetAllocatedHeight_Call {
	return &MockSpinnerWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
}

func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) Run(run func()) *MockSpinnerWidget_GetAllocatedHeight_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) Return(n int) *MockSpinnerWidget_GetAllocatedHeight_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockSpinnerWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) *MockSpinnerWidget_GetAllocatedHeight_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllocatedWidth provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GetAllocatedWidth() int {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetAllocatedWidth")
	}

	var r0 int
	if returnFunc, ok := ret.Get(0).(func() int); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(int)
	}
	return r0
}

// MockSpinnerWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
type MockSpinnerWidget_GetAllocatedWidth_Call struct {
	*mock.Call
}

// GetAllocatedWidth is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GetAllocatedWidth() *MockSpinnerWidget_GetAllocatedWidth_Call {
	return &MockSpinnerWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
}

func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) Run(run func()) *MockSpinnerWidget_GetAllocatedWidth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) Return(n int) *MockSpinnerWidget_GetAllocatedWidth_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockSpinnerWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) *MockSpinnerWidget_GetAllocatedWidth_Call {
	_c.Call.Return(run)
	return _c
}

// GetHexpand provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GetHexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetHexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
type MockSpinnerWidget_GetHexpand_Call struct {
	*mock.Call
}

// GetHexpand is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GetHexpand() *MockSpinnerWidget_GetHexpand_Call {
	return &MockSpinnerWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
}

func (_c *MockSpinnerWidget_GetHexpand_Call) Run(run func()) *MockSpinnerWidget_GetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GetHexpand_Call) Return(b bool) *MockSpinnerWidget_GetHexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_GetHexpand_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetHexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GetParent provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GetParent() layout.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetParent")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockSpinnerWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
type MockSpinnerWidget_GetParent_Call struct {
	*mock.Call
}

// GetParent is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GetParent() *MockSpinnerWidget_GetParent_Call {
	return &MockSpinnerWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
}

func (_c *MockSpinnerWidget_GetParent_Call) Run(run func()) *MockSpinnerWidget_GetParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GetParent_Call) Return(widget layout.Widget) *MockSpinnerWidget_GetParent_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockSpinnerWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) *MockSpinnerWidget_GetParent_Call {
	_c.Call.Return(run)
	return _c
}

// GetSpinning provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GetSpinning() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetSpinning")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_GetSpinning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpinning'
type MockSpinnerWidget_GetSpinning_Call struct {
	*mock.Call
}

// GetSpinning is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GetSpinning() *MockSpinnerWidget_GetSpinning_Call {
	return &MockSpinnerWidget_GetSpinning_Call{Call: _e.mock.On("GetSpinning")}
}

func (_c *MockSpinnerWidget_GetSpinning_Call) Run(run func()) *MockSpinnerWidget_GetSpinning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GetSpinning_Call) Return(b bool) *MockSpinnerWidget_GetSpinning_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_GetSpinning_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetSpinning_Call {
	_c.Call.Return(run)
	return _c
}

// GetVexpand provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GetVexpand() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GetVexpand")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
type MockSpinnerWidget_GetVexpand_Call struct {
	*mock.Call
}

// GetVexpand is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GetVexpand() *MockSpinnerWidget_GetVexpand_Call {
	return &MockSpinnerWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
}

func (_c *MockSpinnerWidget_GetVexpand_Call) Run(run func()) *MockSpinnerWidget_GetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GetVexpand_Call) Return(b bool) *MockSpinnerWidget_GetVexpand_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_GetVexpand_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GetVexpand_Call {
	_c.Call.Return(run)
	return _c
}

// GrabFocus provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GrabFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GrabFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
type MockSpinnerWidget_GrabFocus_Call struct {
	*mock.Call
}

// GrabFocus is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GrabFocus() *MockSpinnerWidget_GrabFocus_Call {
	return &MockSpinnerWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
}

func (_c *MockSpinnerWidget_GrabFocus_Call) Run(run func()) *MockSpinnerWidget_GrabFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GrabFocus_Call) Return(b bool) *MockSpinnerWidget_GrabFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_GrabFocus_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_GrabFocus_Call {
	_c.Call.Return(run)
	return _c
}

// GtkWidget provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) GtkWidget() *gtk.Widget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for GtkWidget")
	}

	var r0 *gtk.Widget
	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gtk.Widget)
		}
	}
	return r0
}

// MockSpinnerWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
type MockSpinnerWidget_GtkWidget_Call struct {
	*mock.Call
}

// GtkWidget is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) GtkWidget() *MockSpinnerWidget_GtkWidget_Call {
	return &MockSpinnerWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
}

func (_c *MockSpinnerWidget_GtkWidget_Call) Run(run func()) *MockSpinnerWidget_GtkWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_GtkWidget_Call) Return(widget *gtk.Widget) *MockSpinnerWidget_GtkWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockSpinnerWidget_GtkWidget_Call) RunAndReturn(run func() *gtk.Widget) *MockSpinnerWidget_GtkWidget_Call {
	_c.Call.Return(run)
	return _c
}

// HasCssClass provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) HasCssClass(cssClass string) bool {
	ret := _mock.Called(cssClass)

	if len(ret) == 0 {
		panic("no return value specified for HasCssClass")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(cssClass)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
type MockSpinnerWidget_HasCssClass_Call struct {
	*mock.Call
}

// HasCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockSpinnerWidget_Expecter) HasCssClass(cssClass interface{}) *MockSpinnerWidget_HasCssClass_Call {
	return &MockSpinnerWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
}

func (_c *MockSpinnerWidget_HasCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_HasCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_HasCssClass_Call) Return(b bool) *MockSpinnerWidget_HasCssClass_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) *MockSpinnerWidget_HasCssClass_Call {
	_c.Call.Return(run)
	return _c
}

// HasFocus provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) HasFocus() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for HasFocus")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
type MockSpinnerWidget_HasFocus_Call struct {
	*mock.Call
}

// HasFocus is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) HasFocus() *MockSpinnerWidget_HasFocus_Call {
	return &MockSpinnerWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
}

func (_c *MockSpinnerWidget_HasFocus_Call) Run(run func()) *MockSpinnerWidget_HasFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_HasFocus_Call) Return(b bool) *MockSpinnerWidget_HasFocus_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_HasFocus_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_HasFocus_Call {
	_c.Call.Return(run)
	return _c
}

// Hide provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) Hide() {
	_mock.Called()
	return
}

// MockSpinnerWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
type MockSpinnerWidget_Hide_Call struct {
	*mock.Call
}

// Hide is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) Hide() *MockSpinnerWidget_Hide_Call {
	return &MockSpinnerWidget_Hide_Call{Call: _e.mock.On("Hide")}
}

func (_c *MockSpinnerWidget_Hide_Call) Run(run func()) *MockSpinnerWidget_Hide_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_Hide_Call) Return() *MockSpinnerWidget_Hide_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_Hide_Call) RunAndReturn(run func()) *MockSpinnerWidget_Hide_Call {
	_c.Run(run)
	return _c
}

// IsVisible provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) IsVisible() bool {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsVisible")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockSpinnerWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
type MockSpinnerWidget_IsVisible_Call struct {
	*mock.Call
}

// IsVisible is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) IsVisible() *MockSpinnerWidget_IsVisible_Call {
	return &MockSpinnerWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
}

func (_c *MockSpinnerWidget_IsVisible_Call) Run(run func()) *MockSpinnerWidget_IsVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_IsVisible_Call) Return(b bool) *MockSpinnerWidget_IsVisible_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockSpinnerWidget_IsVisible_Call) RunAndReturn(run func() bool) *MockSpinnerWidget_IsVisible_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveCssClass provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) RemoveCssClass(cssClass string) {
	_mock.Called(cssClass)
	return
}

// MockSpinnerWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
type MockSpinnerWidget_RemoveCssClass_Call struct {
	*mock.Call
}

// RemoveCssClass is a helper method to define mock.On call
//   - cssClass string
func (_e *MockSpinnerWidget_Expecter) RemoveCssClass(cssClass interface{}) *MockSpinnerWidget_RemoveCssClass_Call {
	return &MockSpinnerWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
}

func (_c *MockSpinnerWidget_RemoveCssClass_Call) Run(run func(cssClass string)) *MockSpinnerWidget_RemoveCssClass_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_RemoveCssClass_Call) Return() *MockSpinnerWidget_RemoveCssClass_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) *MockSpinnerWidget_RemoveCssClass_Call {
	_c.Run(run)
	return _c
}

// SetCanFocus provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetCanFocus(canFocus bool) {
	_mock.Called(canFocus)
	return
}

// MockSpinnerWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
type MockSpinnerWidget_SetCanFocus_Call struct {
	*mock.Call
}

// SetCanFocus is a helper method to define mock.On call
//   - canFocus bool
func (_e *MockSpinnerWidget_Expecter) SetCanFocus(canFocus interface{}) *MockSpinnerWidget_SetCanFocus_Call {
	return &MockSpinnerWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
}

func (_c *MockSpinnerWidget_SetCanFocus_Call) Run(run func(canFocus bool)) *MockSpinnerWidget_SetCanFocus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetCanFocus_Call) Return() *MockSpinnerWidget_SetCanFocus_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) *MockSpinnerWidget_SetCanFocus_Call {
	_c.Run(run)
	return _c
}

// SetCanTarget provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetCanTarget(canTarget bool) {
	_mock.Called(canTarget)
	return
}

// MockSpinnerWidget_SetCanTarget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanTarget'
type MockSpinnerWidget_SetCanTarget_Call struct {
	*mock.Call
}

// SetCanTarget is a helper method to define mock.On call
//   - canTarget bool
func (_e *MockSpinnerWidget_Expecter) SetCanTarget(canTarget interface{}) *MockSpinnerWidget_SetCanTarget_Call {
	return &MockSpinnerWidget_SetCanTarget_Call{Call: _e.mock.On("SetCanTarget", canTarget)}
}

func (_c *MockSpinnerWidget_SetCanTarget_Call) Run(run func(canTarget bool)) *MockSpinnerWidget_SetCanTarget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetCanTarget_Call) Return() *MockSpinnerWidget_SetCanTarget_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetCanTarget_Call) RunAndReturn(run func(canTarget bool)) *MockSpinnerWidget_SetCanTarget_Call {
	_c.Run(run)
	return _c
}

// SetFocusOnClick provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetFocusOnClick(focusOnClick bool) {
	_mock.Called(focusOnClick)
	return
}

// MockSpinnerWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
type MockSpinnerWidget_SetFocusOnClick_Call struct {
	*mock.Call
}

// SetFocusOnClick is a helper method to define mock.On call
//   - focusOnClick bool
func (_e *MockSpinnerWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) *MockSpinnerWidget_SetFocusOnClick_Call {
	return &MockSpinnerWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
}

func (_c *MockSpinnerWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) *MockSpinnerWidget_SetFocusOnClick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetFocusOnClick_Call) Return() *MockSpinnerWidget_SetFocusOnClick_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) *MockSpinnerWidget_SetFocusOnClick_Call {
	_c.Run(run)
	return _c
}

// SetHalign provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetHalign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockSpinnerWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
type MockSpinnerWidget_SetHalign_Call struct {
	*mock.Call
}

// SetHalign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockSpinnerWidget_Expecter) SetHalign(align interface{}) *MockSpinnerWidget_SetHalign_Call {
	return &MockSpinnerWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
}

func (_c *MockSpinnerWidget_SetHalign_Call) Run(run func(align gtk.Align)) *MockSpinnerWidget_SetHalign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetHalign_Call) Return() *MockSpinnerWidget_SetHalign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) *MockSpinnerWidget_SetHalign_Call {
	_c.Run(run)
	return _c
}

// SetHexpand provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetHexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockSpinnerWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
type MockSpinnerWidget_SetHexpand_Call struct {
	*mock.Call
}

// SetHexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockSpinnerWidget_Expecter) SetHexpand(expand interface{}) *MockSpinnerWidget_SetHexpand_Call {
	return &MockSpinnerWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
}

func (_c *MockSpinnerWidget_SetHexpand_Call) Run(run func(expand bool)) *MockSpinnerWidget_SetHexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetHexpand_Call) Return() *MockSpinnerWidget_SetHexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) *MockSpinnerWidget_SetHexpand_Call {
	_c.Run(run)
	return _c
}

// SetSizeRequest provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetSizeRequest(width int, height int) {
	_mock.Called(width, height)
	return
}

// MockSpinnerWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
type MockSpinnerWidget_SetSizeRequest_Call struct {
	*mock.Call
}

// SetSizeRequest is a helper method to define mock.On call
//   - width int
//   - height int
func (_e *MockSpinnerWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) *MockSpinnerWidget_SetSizeRequest_Call {
	return &MockSpinnerWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
}

func (_c *MockSpinnerWidget_SetSizeRequest_Call) Run(run func(width int, height int)) *MockSpinnerWidget_SetSizeRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetSizeRequest_Call) Return() *MockSpinnerWidget_SetSizeRequest_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) *MockSpinnerWidget_SetSizeRequest_Call {
	_c.Run(run)
	return _c
}

// SetSpinning provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetSpinning(spinning bool) {
	_mock.Called(spinning)
	return
}

// MockSpinnerWidget_SetSpinning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpinning'
type MockSpinnerWidget_SetSpinning_Call struct {
	*mock.Call
}

// SetSpinning is a helper method to define mock.On call
//   - spinning bool
func (_e *MockSpinnerWidget_Expecter) SetSpinning(spinning interface{}) *MockSpinnerWidget_SetSpinning_Call {
	return &MockSpinnerWidget_SetSpinning_Call{Call: _e.mock.On("SetSpinning", spinning)}
}

func (_c *MockSpinnerWidget_SetSpinning_Call) Run(run func(spinning bool)) *MockSpinnerWidget_SetSpinning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetSpinning_Call) Return() *MockSpinnerWidget_SetSpinning_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetSpinning_Call) RunAndReturn(run func(spinning bool)) *MockSpinnerWidget_SetSpinning_Call {
	_c.Run(run)
	return _c
}

// SetValign provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetValign(align gtk.Align) {
	_mock.Called(align)
	return
}

// MockSpinnerWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
type MockSpinnerWidget_SetValign_Call struct {
	*mock.Call
}

// SetValign is a helper method to define mock.On call
//   - align gtk.Align
func (_e *MockSpinnerWidget_Expecter) SetValign(align interface{}) *MockSpinnerWidget_SetValign_Call {
	return &MockSpinnerWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
}

func (_c *MockSpinnerWidget_SetValign_Call) Run(run func(align gtk.Align)) *MockSpinnerWidget_SetValign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 gtk.Align
		if args[0] != nil {
			arg0 = args[0].(gtk.Align)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetValign_Call) Return() *MockSpinnerWidget_SetValign_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) *MockSpinnerWidget_SetValign_Call {
	_c.Run(run)
	return _c
}

// SetVexpand provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetVexpand(expand bool) {
	_mock.Called(expand)
	return
}

// MockSpinnerWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
type MockSpinnerWidget_SetVexpand_Call struct {
	*mock.Call
}

// SetVexpand is a helper method to define mock.On call
//   - expand bool
func (_e *MockSpinnerWidget_Expecter) SetVexpand(expand interface{}) *MockSpinnerWidget_SetVexpand_Call {
	return &MockSpinnerWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
}

func (_c *MockSpinnerWidget_SetVexpand_Call) Run(run func(expand bool)) *MockSpinnerWidget_SetVexpand_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetVexpand_Call) Return() *MockSpinnerWidget_SetVexpand_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) *MockSpinnerWidget_SetVexpand_Call {
	_c.Run(run)
	return _c
}

// SetVisible provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) SetVisible(visible bool) {
	_mock.Called(visible)
	return
}

// MockSpinnerWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
type MockSpinnerWidget_SetVisible_Call struct {
	*mock.Call
}

// SetVisible is a helper method to define mock.On call
//   - visible bool
func (_e *MockSpinnerWidget_Expecter) SetVisible(visible interface{}) *MockSpinnerWidget_SetVisible_Call {
	return &MockSpinnerWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
}

func (_c *MockSpinnerWidget_SetVisible_Call) Run(run func(visible bool)) *MockSpinnerWidget_SetVisible_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 bool
		if args[0] != nil {
			arg0 = args[0].(bool)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSpinnerWidget_SetVisible_Call) Return() *MockSpinnerWidget_SetVisible_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) *MockSpinnerWidget_SetVisible_Call {
	_c.Run(run)
	return _c
}

// Show provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) Show() {
	_mock.Called()
	return
}

// MockSpinnerWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
type MockSpinnerWidget_Show_Call struct {
	*mock.Call
}

// Show is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) Show() *MockSpinnerWidget_Show_Call {
	return &MockSpinnerWidget_Show_Call{Call: _e.mock.On("Show")}
}

func (_c *MockSpinnerWidget_Show_Call) Run(run func()) *MockSpinnerWidget_Show_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_Show_Call) Return() *MockSpinnerWidget_Show_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_Show_Call) RunAndReturn(run func()) *MockSpinnerWidget_Show_Call {
	_c.Run(run)
	return _c
}

// Start provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) Start() {
	_mock.Called()
	return
}

// MockSpinnerWidget_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
type MockSpinnerWidget_Start_Call struct {
	*mock.Call
}

// Start is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) Start() *MockSpinnerWidget_Start_Call {
	return &MockSpinnerWidget_Start_Call{Call: _e.mock.On("Start")}
}

func (_c *MockSpinnerWidget_Start_Call) Run(run func()) *MockSpinnerWidget_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_Start_Call) Return() *MockSpinnerWidget_Start_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_Start_Call) RunAndReturn(run func()) *MockSpinnerWidget_Start_Call {
	_c.Run(run)
	return _c
}

// Stop provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) Stop() {
	_mock.Called()
	return
}

// MockSpinnerWidget_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
type MockSpinnerWidget_Stop_Call struct {
	*mock.Call
}

// Stop is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) Stop() *MockSpinnerWidget_Stop_Call {
	return &MockSpinnerWidget_Stop_Call{Call: _e.mock.On("Stop")}
}

func (_c *MockSpinnerWidget_Stop_Call) Run(run func()) *MockSpinnerWidget_Stop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_Stop_Call) Return() *MockSpinnerWidget_Stop_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_Stop_Call) RunAndReturn(run func()) *MockSpinnerWidget_Stop_Call {
	_c.Run(run)
	return _c
}

// Unparent provides a mock function for the type MockSpinnerWidget
func (_mock *MockSpinnerWidget) Unparent() {
	_mock.Called()
	return
}

// MockSpinnerWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
type MockSpinnerWidget_Unparent_Call struct {
	*mock.Call
}

// Unparent is a helper method to define mock.On call
func (_e *MockSpinnerWidget_Expecter) Unparent() *MockSpinnerWidget_Unparent_Call {
	return &MockSpinnerWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
}

func (_c *MockSpinnerWidget_Unparent_Call) Run(run func()) *MockSpinnerWidget_Unparent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSpinnerWidget_Unparent_Call) Return() *MockSpinnerWidget_Unparent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSpinnerWidget_Unparent_Call) RunAndReturn(run func()) *MockSpinnerWidget_Unparent_Call {
	_c.Run(run)
	return _c
}

// NewMockWidgetFactory creates a new instance of MockWidgetFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockWidgetFactory(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWidgetFactory {
	mock := &MockWidgetFactory{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockWidgetFactory is an autogenerated mock type for the WidgetFactory type
type MockWidgetFactory struct {
	mock.Mock
}

type MockWidgetFactory_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWidgetFactory) EXPECT() *MockWidgetFactory_Expecter {
	return &MockWidgetFactory_Expecter{mock: &_m.Mock}
}

// NewBox provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewBox(orientation layout.Orientation, spacing int) layout.BoxWidget {
	ret := _mock.Called(orientation, spacing)

	if len(ret) == 0 {
		panic("no return value specified for NewBox")
	}

	var r0 layout.BoxWidget
	if returnFunc, ok := ret.Get(0).(func(layout.Orientation, int) layout.BoxWidget); ok {
		r0 = returnFunc(orientation, spacing)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.BoxWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewBox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBox'
type MockWidgetFactory_NewBox_Call struct {
	*mock.Call
}

// NewBox is a helper method to define mock.On call
//   - orientation layout.Orientation
//   - spacing int
func (_e *MockWidgetFactory_Expecter) NewBox(orientation interface{}, spacing interface{}) *MockWidgetFactory_NewBox_Call {
	return &MockWidgetFactory_NewBox_Call{Call: _e.mock.On("NewBox", orientation, spacing)}
}

func (_c *MockWidgetFactory_NewBox_Call) Run(run func(orientation layout.Orientation, spacing int)) *MockWidgetFactory_NewBox_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Orientation
		if args[0] != nil {
			arg0 = args[0].(layout.Orientation)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockWidgetFactory_NewBox_Call) Return(boxWidget layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
	_c.Call.Return(boxWidget)
	return _c
}

func (_c *MockWidgetFactory_NewBox_Call) RunAndReturn(run func(orientation layout.Orientation, spacing int) layout.BoxWidget) *MockWidgetFactory_NewBox_Call {
	_c.Call.Return(run)
	return _c
}

// NewButton provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewButton() layout.ButtonWidget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for NewButton")
	}

	var r0 layout.ButtonWidget
	if returnFunc, ok := ret.Get(0).(func() layout.ButtonWidget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.ButtonWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewButton_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewButton'
type MockWidgetFactory_NewButton_Call struct {
	*mock.Call
}

// NewButton is a helper method to define mock.On call
func (_e *MockWidgetFactory_Expecter) NewButton() *MockWidgetFactory_NewButton_Call {
	return &MockWidgetFactory_NewButton_Call{Call: _e.mock.On("NewButton")}
}

func (_c *MockWidgetFactory_NewButton_Call) Run(run func()) *MockWidgetFactory_NewButton_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidgetFactory_NewButton_Call) Return(buttonWidget layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
	_c.Call.Return(buttonWidget)
	return _c
}

func (_c *MockWidgetFactory_NewButton_Call) RunAndReturn(run func() layout.ButtonWidget) *MockWidgetFactory_NewButton_Call {
	_c.Call.Return(run)
	return _c
}

// NewImage provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewImage() layout.ImageWidget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for NewImage")
	}

	var r0 layout.ImageWidget
	if returnFunc, ok := ret.Get(0).(func() layout.ImageWidget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.ImageWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewImage'
type MockWidgetFactory_NewImage_Call struct {
	*mock.Call
}

// NewImage is a helper method to define mock.On call
func (_e *MockWidgetFactory_Expecter) NewImage() *MockWidgetFactory_NewImage_Call {
	return &MockWidgetFactory_NewImage_Call{Call: _e.mock.On("NewImage")}
}

func (_c *MockWidgetFactory_NewImage_Call) Run(run func()) *MockWidgetFactory_NewImage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidgetFactory_NewImage_Call) Return(imageWidget layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
	_c.Call.Return(imageWidget)
	return _c
}

func (_c *MockWidgetFactory_NewImage_Call) RunAndReturn(run func() layout.ImageWidget) *MockWidgetFactory_NewImage_Call {
	_c.Call.Return(run)
	return _c
}

// NewLabel provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewLabel(text string) layout.LabelWidget {
	ret := _mock.Called(text)

	if len(ret) == 0 {
		panic("no return value specified for NewLabel")
	}

	var r0 layout.LabelWidget
	if returnFunc, ok := ret.Get(0).(func(string) layout.LabelWidget); ok {
		r0 = returnFunc(text)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.LabelWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewLabel'
type MockWidgetFactory_NewLabel_Call struct {
	*mock.Call
}

// NewLabel is a helper method to define mock.On call
//   - text string
func (_e *MockWidgetFactory_Expecter) NewLabel(text interface{}) *MockWidgetFactory_NewLabel_Call {
	return &MockWidgetFactory_NewLabel_Call{Call: _e.mock.On("NewLabel", text)}
}

func (_c *MockWidgetFactory_NewLabel_Call) Run(run func(text string)) *MockWidgetFactory_NewLabel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidgetFactory_NewLabel_Call) Return(labelWidget layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
	_c.Call.Return(labelWidget)
	return _c
}

func (_c *MockWidgetFactory_NewLabel_Call) RunAndReturn(run func(text string) layout.LabelWidget) *MockWidgetFactory_NewLabel_Call {
	_c.Call.Return(run)
	return _c
}

// NewOverlay provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewOverlay() layout.OverlayWidget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for NewOverlay")
	}

	var r0 layout.OverlayWidget
	if returnFunc, ok := ret.Get(0).(func() layout.OverlayWidget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.OverlayWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewOverlay'
type MockWidgetFactory_NewOverlay_Call struct {
	*mock.Call
}

// NewOverlay is a helper method to define mock.On call
func (_e *MockWidgetFactory_Expecter) NewOverlay() *MockWidgetFactory_NewOverlay_Call {
	return &MockWidgetFactory_NewOverlay_Call{Call: _e.mock.On("NewOverlay")}
}

func (_c *MockWidgetFactory_NewOverlay_Call) Run(run func()) *MockWidgetFactory_NewOverlay_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidgetFactory_NewOverlay_Call) Return(overlayWidget layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
	_c.Call.Return(overlayWidget)
	return _c
}

func (_c *MockWidgetFactory_NewOverlay_Call) RunAndReturn(run func() layout.OverlayWidget) *MockWidgetFactory_NewOverlay_Call {
	_c.Call.Return(run)
	return _c
}

// NewPaned provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewPaned(orientation layout.Orientation) layout.PanedWidget {
	ret := _mock.Called(orientation)

	if len(ret) == 0 {
		panic("no return value specified for NewPaned")
	}

	var r0 layout.PanedWidget
	if returnFunc, ok := ret.Get(0).(func(layout.Orientation) layout.PanedWidget); ok {
		r0 = returnFunc(orientation)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.PanedWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewPaned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewPaned'
type MockWidgetFactory_NewPaned_Call struct {
	*mock.Call
}

// NewPaned is a helper method to define mock.On call
//   - orientation layout.Orientation
func (_e *MockWidgetFactory_Expecter) NewPaned(orientation interface{}) *MockWidgetFactory_NewPaned_Call {
	return &MockWidgetFactory_NewPaned_Call{Call: _e.mock.On("NewPaned", orientation)}
}

func (_c *MockWidgetFactory_NewPaned_Call) Run(run func(orientation layout.Orientation)) *MockWidgetFactory_NewPaned_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 layout.Orientation
		if args[0] != nil {
			arg0 = args[0].(layout.Orientation)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidgetFactory_NewPaned_Call) Return(panedWidget layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
	_c.Call.Return(panedWidget)
	return _c
}

func (_c *MockWidgetFactory_NewPaned_Call) RunAndReturn(run func(orientation layout.Orientation) layout.PanedWidget) *MockWidgetFactory_NewPaned_Call {
	_c.Call.Return(run)
	return _c
}

// NewProgressBar provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewProgressBar() layout.ProgressBarWidget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for NewProgressBar")
	}

	var r0 layout.ProgressBarWidget
	if returnFunc, ok := ret.Get(0).(func() layout.ProgressBarWidget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.ProgressBarWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewProgressBar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewProgressBar'
type MockWidgetFactory_NewProgressBar_Call struct {
	*mock.Call
}

// NewProgressBar is a helper method to define mock.On call
func (_e *MockWidgetFactory_Expecter) NewProgressBar() *MockWidgetFactory_NewProgressBar_Call {
	return &MockWidgetFactory_NewProgressBar_Call{Call: _e.mock.On("NewProgressBar")}
}

func (_c *MockWidgetFactory_NewProgressBar_Call) Run(run func()) *MockWidgetFactory_NewProgressBar_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidgetFactory_NewProgressBar_Call) Return(progressBarWidget layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
	_c.Call.Return(progressBarWidget)
	return _c
}

func (_c *MockWidgetFactory_NewProgressBar_Call) RunAndReturn(run func() layout.ProgressBarWidget) *MockWidgetFactory_NewProgressBar_Call {
	_c.Call.Return(run)
	return _c
}

// NewSpinner provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) NewSpinner() layout.SpinnerWidget {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for NewSpinner")
	}

	var r0 layout.SpinnerWidget
	if returnFunc, ok := ret.Get(0).(func() layout.SpinnerWidget); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.SpinnerWidget)
		}
	}
	return r0
}

// MockWidgetFactory_NewSpinner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSpinner'
type MockWidgetFactory_NewSpinner_Call struct {
	*mock.Call
}

// NewSpinner is a helper method to define mock.On call
func (_e *MockWidgetFactory_Expecter) NewSpinner() *MockWidgetFactory_NewSpinner_Call {
	return &MockWidgetFactory_NewSpinner_Call{Call: _e.mock.On("NewSpinner")}
}

func (_c *MockWidgetFactory_NewSpinner_Call) Run(run func()) *MockWidgetFactory_NewSpinner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWidgetFactory_NewSpinner_Call) Return(spinnerWidget layout.SpinnerWidget) *MockWidgetFactory_NewSpinner_Call {
	_c.Call.Return(spinnerWidget)
	return _c
}

func (_c *MockWidgetFactory_NewSpinner_Call) RunAndReturn(run func() layout.SpinnerWidget) *MockWidgetFactory_NewSpinner_Call {
	_c.Call.Return(run)
	return _c
}

// WrapWidget provides a mock function for the type MockWidgetFactory
func (_mock *MockWidgetFactory) WrapWidget(w *gtk.Widget) layout.Widget {
	ret := _mock.Called(w)

	if len(ret) == 0 {
		panic("no return value specified for WrapWidget")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func(*gtk.Widget) layout.Widget); ok {
		r0 = returnFunc(w)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockWidgetFactory_WrapWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WrapWidget'
type MockWidgetFactory_WrapWidget_Call struct {
	*mock.Call
}

// WrapWidget is a helper method to define mock.On call
//   - w *gtk.Widget
func (_e *MockWidgetFactory_Expecter) WrapWidget(w interface{}) *MockWidgetFactory_WrapWidget_Call {
	return &MockWidgetFactory_WrapWidget_Call{Call: _e.mock.On("WrapWidget", w)}
}

func (_c *MockWidgetFactory_WrapWidget_Call) Run(run func(w *gtk.Widget)) *MockWidgetFactory_WrapWidget_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *gtk.Widget
		if args[0] != nil {
			arg0 = args[0].(*gtk.Widget)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWidgetFactory_WrapWidget_Call) Return(widget layout.Widget) *MockWidgetFactory_WrapWidget_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockWidgetFactory_WrapWidget_Call) RunAndReturn(run func(w *gtk.Widget) layout.Widget) *MockWidgetFactory_WrapWidget_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockPaneRenderer creates a new instance of MockPaneRenderer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockPaneRenderer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPaneRenderer {
	mock := &MockPaneRenderer{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockPaneRenderer is an autogenerated mock type for the PaneRenderer type
type MockPaneRenderer struct {
	mock.Mock
}

type MockPaneRenderer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPaneRenderer) EXPECT() *MockPaneRenderer_Expecter {
	return &MockPaneRenderer_Expecter{mock: &_m.Mock}
}

// RenderPane provides a mock function for the type MockPaneRenderer
func (_mock *MockPaneRenderer) RenderPane(paneID string, webViewWidget layout.Widget) layout.Widget {
	ret := _mock.Called(paneID, webViewWidget)

	if len(ret) == 0 {
		panic("no return value specified for RenderPane")
	}

	var r0 layout.Widget
	if returnFunc, ok := ret.Get(0).(func(string, layout.Widget) layout.Widget); ok {
		r0 = returnFunc(paneID, webViewWidget)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(layout.Widget)
		}
	}
	return r0
}

// MockPaneRenderer_RenderPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenderPane'
type MockPaneRenderer_RenderPane_Call struct {
	*mock.Call
}

// RenderPane is a helper method to define mock.On call
//   - paneID string
//   - webViewWidget layout.Widget
func (_e *MockPaneRenderer_Expecter) RenderPane(paneID interface{}, webViewWidget interface{}) *MockPaneRenderer_RenderPane_Call {
	return &MockPaneRenderer_RenderPane_Call{Call: _e.mock.On("RenderPane", paneID, webViewWidget)}
}

func (_c *MockPaneRenderer_RenderPane_Call) Run(run func(paneID string, webViewWidget layout.Widget)) *MockPaneRenderer_RenderPane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 layout.Widget
		if args[1] != nil {
			arg1 = args[1].(layout.Widget)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockPaneRenderer_RenderPane_Call) Return(widget layout.Widget) *MockPaneRenderer_RenderPane_Call {
	_c.Call.Return(widget)
	return _c
}

func (_c *MockPaneRenderer_RenderPane_Call) RunAndReturn(run func(paneID string, webViewWidget layout.Widget) layout.Widget) *MockPaneRenderer_RenderPane_Call {
	_c.Call.Return(run)
	return _c
}