feat(ui): add layout widget abstractions and split view with ratio support

- Add Widget, PanedWidget, BoxWidget, OverlayWidget interfaces
- Implement GTK widget wrappers with GtkWidget() accessor
- Add SplitView with ratio-to-pixel conversion on widget map
- Add TreeRenderer for building pane tree layouts
- Add StackedView for tabbed pane stacks
- Include ConnectMap signal for deferred ratio application

commit: ba9aeae82f60a1719c58dafb9bcf3c696f7e7ada
author: brice · 10mo ago · 2025-12-09 19:03 UTC
committer: brice · 10mo ago · 2025-12-09 17:17 UTC
parent: 13b335c
signature: unsigned

22 files · +13468 -0

A .mockery.yaml +28 -0

@@ -0,0 +1,28 @@
	1	+	packages:
	2	+	github.com/bnema/dumber/internal/application/port:
	3	+	config:
	4	+	dir: "{{.InterfaceDir}}/mocks"
	5	+	filename: "mock_{{.InterfaceName \| snakecase}}.go"
	6	+	structname: "Mock{{.InterfaceName}}"
	7	+	pkgname: "mocks"
	8	+	interfaces:
	9	+	WebView:
	10	+	WebViewPool:
	11	+	WebViewFactory:
	12	+	github.com/bnema/dumber/internal/ui/layout:
	13	+	config:
	14	+	dir: "{{.InterfaceDir}}/mocks"
	15	+	filename: "mock_{{.InterfaceName \| snakecase}}.go"
	16	+	structname: "Mock{{.InterfaceName}}"
	17	+	pkgname: "mocks"
	18	+	interfaces:
	19	+	Widget:
	20	+	PanedWidget:
	21	+	BoxWidget:
	22	+	OverlayWidget:
	23	+	LabelWidget:
	24	+	ButtonWidget:
	25	+	ImageWidget:
	26	+	WidgetFactory:
	27	+	PaneRenderer:
	28	+	PaneViewFactory:

A internal/application/port/mocks/mock_web_view.go +984 -0

@@ -0,0 +1,984 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"context"
	9	+
	10	+	"github.com/bnema/dumber/internal/application/port"
	11	+	mock "github.com/stretchr/testify/mock"
	12	+	)
	13	+
	14	+	// NewMockWebView creates a new instance of MockWebView. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	15	+	// The first argument is typically a *testing.T value.
	16	+	func NewMockWebView(t interface {
	17	+	mock.TestingT
	18	+	Cleanup(func())
	19	+	}) *MockWebView {
	20	+	mock := &MockWebView{}
	21	+	mock.Mock.Test(t)
	22	+
	23	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	24	+
	25	+	return mock
	26	+	}
	27	+
	28	+	// MockWebView is an autogenerated mock type for the WebView type
	29	+	type MockWebView struct {
	30	+	mock.Mock
	31	+	}
	32	+
	33	+	type MockWebView_Expecter struct {
	34	+	mock *mock.Mock
	35	+	}
	36	+
	37	+	func (_m MockWebView) EXPECT() MockWebView_Expecter {
	38	+	return &MockWebView_Expecter{mock: &_m.Mock}
	39	+	}
	40	+
	41	+	// CanGoBack provides a mock function for the type MockWebView
	42	+	func (_mock *MockWebView) CanGoBack() bool {
	43	+	ret := _mock.Called()
	44	+
	45	+	if len(ret) == 0 {
	46	+	panic("no return value specified for CanGoBack")
	47	+	}
	48	+
	49	+	var r0 bool
	50	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	51	+	r0 = returnFunc()
	52	+	} else {
	53	+	r0 = ret.Get(0).(bool)
	54	+	}
	55	+	return r0
	56	+	}
	57	+
	58	+	// MockWebView_CanGoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoBack'
	59	+	type MockWebView_CanGoBack_Call struct {
	60	+	*mock.Call
	61	+	}
	62	+
	63	+	// CanGoBack is a helper method to define mock.On call
	64	+	func (_e MockWebView_Expecter) CanGoBack() MockWebView_CanGoBack_Call {
	65	+	return &MockWebView_CanGoBack_Call{Call: _e.mock.On("CanGoBack")}
	66	+	}
	67	+
	68	+	func (_c MockWebView_CanGoBack_Call) Run(run func()) MockWebView_CanGoBack_Call {
	69	+	_c.Call.Run(func(args mock.Arguments) {
	70	+	run()
	71	+	})
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockWebView_CanGoBack_Call) Return(b bool) MockWebView_CanGoBack_Call {
	76	+	_c.Call.Return(b)
	77	+	return _c
	78	+	}
	79	+
	80	+	func (_c MockWebView_CanGoBack_Call) RunAndReturn(run func() bool) MockWebView_CanGoBack_Call {
	81	+	_c.Call.Return(run)
	82	+	return _c
	83	+	}
	84	+
	85	+	// CanGoForward provides a mock function for the type MockWebView
	86	+	func (_mock *MockWebView) CanGoForward() bool {
	87	+	ret := _mock.Called()
	88	+
	89	+	if len(ret) == 0 {
	90	+	panic("no return value specified for CanGoForward")
	91	+	}
	92	+
	93	+	var r0 bool
	94	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	95	+	r0 = returnFunc()
	96	+	} else {
	97	+	r0 = ret.Get(0).(bool)
	98	+	}
	99	+	return r0
	100	+	}
	101	+
	102	+	// MockWebView_CanGoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CanGoForward'
	103	+	type MockWebView_CanGoForward_Call struct {
	104	+	*mock.Call
	105	+	}
	106	+
	107	+	// CanGoForward is a helper method to define mock.On call
	108	+	func (_e MockWebView_Expecter) CanGoForward() MockWebView_CanGoForward_Call {
	109	+	return &MockWebView_CanGoForward_Call{Call: _e.mock.On("CanGoForward")}
	110	+	}
	111	+
	112	+	func (_c MockWebView_CanGoForward_Call) Run(run func()) MockWebView_CanGoForward_Call {
	113	+	_c.Call.Run(func(args mock.Arguments) {
	114	+	run()
	115	+	})
	116	+	return _c
	117	+	}
	118	+
	119	+	func (_c MockWebView_CanGoForward_Call) Return(b bool) MockWebView_CanGoForward_Call {
	120	+	_c.Call.Return(b)
	121	+	return _c
	122	+	}
	123	+
	124	+	func (_c MockWebView_CanGoForward_Call) RunAndReturn(run func() bool) MockWebView_CanGoForward_Call {
	125	+	_c.Call.Return(run)
	126	+	return _c
	127	+	}
	128	+
	129	+	// Destroy provides a mock function for the type MockWebView
	130	+	func (_mock *MockWebView) Destroy() {
	131	+	_mock.Called()
	132	+	return
	133	+	}
	134	+
	135	+	// MockWebView_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'
	136	+	type MockWebView_Destroy_Call struct {
	137	+	*mock.Call
	138	+	}
	139	+
	140	+	// Destroy is a helper method to define mock.On call
	141	+	func (_e MockWebView_Expecter) Destroy() MockWebView_Destroy_Call {
	142	+	return &MockWebView_Destroy_Call{Call: _e.mock.On("Destroy")}
	143	+	}
	144	+
	145	+	func (_c MockWebView_Destroy_Call) Run(run func()) MockWebView_Destroy_Call {
	146	+	_c.Call.Run(func(args mock.Arguments) {
	147	+	run()
	148	+	})
	149	+	return _c
	150	+	}
	151	+
	152	+	func (_c MockWebView_Destroy_Call) Return() MockWebView_Destroy_Call {
	153	+	_c.Call.Return()
	154	+	return _c
	155	+	}
	156	+
	157	+	func (_c MockWebView_Destroy_Call) RunAndReturn(run func()) MockWebView_Destroy_Call {
	158	+	_c.Run(run)
	159	+	return _c
	160	+	}
	161	+
	162	+	// EstimatedProgress provides a mock function for the type MockWebView
	163	+	func (_mock *MockWebView) EstimatedProgress() float64 {
	164	+	ret := _mock.Called()
	165	+
	166	+	if len(ret) == 0 {
	167	+	panic("no return value specified for EstimatedProgress")
	168	+	}
	169	+
	170	+	var r0 float64
	171	+	if returnFunc, ok := ret.Get(0).(func() float64); ok {
	172	+	r0 = returnFunc()
	173	+	} else {
	174	+	r0 = ret.Get(0).(float64)
	175	+	}
	176	+	return r0
	177	+	}
	178	+
	179	+	// MockWebView_EstimatedProgress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimatedProgress'
	180	+	type MockWebView_EstimatedProgress_Call struct {
	181	+	*mock.Call
	182	+	}
	183	+
	184	+	// EstimatedProgress is a helper method to define mock.On call
	185	+	func (_e MockWebView_Expecter) EstimatedProgress() MockWebView_EstimatedProgress_Call {
	186	+	return &MockWebView_EstimatedProgress_Call{Call: _e.mock.On("EstimatedProgress")}
	187	+	}
	188	+
	189	+	func (_c MockWebView_EstimatedProgress_Call) Run(run func()) MockWebView_EstimatedProgress_Call {
	190	+	_c.Call.Run(func(args mock.Arguments) {
	191	+	run()
	192	+	})
	193	+	return _c
	194	+	}
	195	+
	196	+	func (_c MockWebView_EstimatedProgress_Call) Return(f float64) MockWebView_EstimatedProgress_Call {
	197	+	_c.Call.Return(f)
	198	+	return _c
	199	+	}
	200	+
	201	+	func (_c MockWebView_EstimatedProgress_Call) RunAndReturn(run func() float64) MockWebView_EstimatedProgress_Call {
	202	+	_c.Call.Return(run)
	203	+	return _c
	204	+	}
	205	+
	206	+	// GetZoomLevel provides a mock function for the type MockWebView
	207	+	func (_mock *MockWebView) GetZoomLevel() float64 {
	208	+	ret := _mock.Called()
	209	+
	210	+	if len(ret) == 0 {
	211	+	panic("no return value specified for GetZoomLevel")
	212	+	}
	213	+
	214	+	var r0 float64
	215	+	if returnFunc, ok := ret.Get(0).(func() float64); ok {
	216	+	r0 = returnFunc()
	217	+	} else {
	218	+	r0 = ret.Get(0).(float64)
	219	+	}
	220	+	return r0
	221	+	}
	222	+
	223	+	// MockWebView_GetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetZoomLevel'
	224	+	type MockWebView_GetZoomLevel_Call struct {
	225	+	*mock.Call
	226	+	}
	227	+
	228	+	// GetZoomLevel is a helper method to define mock.On call
	229	+	func (_e MockWebView_Expecter) GetZoomLevel() MockWebView_GetZoomLevel_Call {
	230	+	return &MockWebView_GetZoomLevel_Call{Call: _e.mock.On("GetZoomLevel")}
	231	+	}
	232	+
	233	+	func (_c MockWebView_GetZoomLevel_Call) Run(run func()) MockWebView_GetZoomLevel_Call {
	234	+	_c.Call.Run(func(args mock.Arguments) {
	235	+	run()
	236	+	})
	237	+	return _c
	238	+	}
	239	+
	240	+	func (_c MockWebView_GetZoomLevel_Call) Return(f float64) MockWebView_GetZoomLevel_Call {
	241	+	_c.Call.Return(f)
	242	+	return _c
	243	+	}
	244	+
	245	+	func (_c MockWebView_GetZoomLevel_Call) RunAndReturn(run func() float64) MockWebView_GetZoomLevel_Call {
	246	+	_c.Call.Return(run)
	247	+	return _c
	248	+	}
	249	+
	250	+	// GoBack provides a mock function for the type MockWebView
	251	+	func (_mock *MockWebView) GoBack(ctx context.Context) error {
	252	+	ret := _mock.Called(ctx)
	253	+
	254	+	if len(ret) == 0 {
	255	+	panic("no return value specified for GoBack")
	256	+	}
	257	+
	258	+	var r0 error
	259	+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
	260	+	r0 = returnFunc(ctx)
	261	+	} else {
	262	+	r0 = ret.Error(0)
	263	+	}
	264	+	return r0
	265	+	}
	266	+
	267	+	// MockWebView_GoBack_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoBack'
	268	+	type MockWebView_GoBack_Call struct {
	269	+	*mock.Call
	270	+	}
	271	+
	272	+	// GoBack is a helper method to define mock.On call
	273	+	// - ctx context.Context
	274	+	func (_e MockWebView_Expecter) GoBack(ctx interface{}) MockWebView_GoBack_Call {
	275	+	return &MockWebView_GoBack_Call{Call: _e.mock.On("GoBack", ctx)}
	276	+	}
	277	+
	278	+	func (_c MockWebView_GoBack_Call) Run(run func(ctx context.Context)) MockWebView_GoBack_Call {
	279	+	_c.Call.Run(func(args mock.Arguments) {
	280	+	var arg0 context.Context
	281	+	if args[0] != nil {
	282	+	arg0 = args[0].(context.Context)
	283	+	}
	284	+	run(
	285	+	arg0,
	286	+	)
	287	+	})
	288	+	return _c
	289	+	}
	290	+
	291	+	func (_c MockWebView_GoBack_Call) Return(err error) MockWebView_GoBack_Call {
	292	+	_c.Call.Return(err)
	293	+	return _c
	294	+	}
	295	+
	296	+	func (_c MockWebView_GoBack_Call) RunAndReturn(run func(ctx context.Context) error) MockWebView_GoBack_Call {
	297	+	_c.Call.Return(run)
	298	+	return _c
	299	+	}
	300	+
	301	+	// GoForward provides a mock function for the type MockWebView
	302	+	func (_mock *MockWebView) GoForward(ctx context.Context) error {
	303	+	ret := _mock.Called(ctx)
	304	+
	305	+	if len(ret) == 0 {
	306	+	panic("no return value specified for GoForward")
	307	+	}
	308	+
	309	+	var r0 error
	310	+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
	311	+	r0 = returnFunc(ctx)
	312	+	} else {
	313	+	r0 = ret.Error(0)
	314	+	}
	315	+	return r0
	316	+	}
	317	+
	318	+	// MockWebView_GoForward_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GoForward'
	319	+	type MockWebView_GoForward_Call struct {
	320	+	*mock.Call
	321	+	}
	322	+
	323	+	// GoForward is a helper method to define mock.On call
	324	+	// - ctx context.Context
	325	+	func (_e MockWebView_Expecter) GoForward(ctx interface{}) MockWebView_GoForward_Call {
	326	+	return &MockWebView_GoForward_Call{Call: _e.mock.On("GoForward", ctx)}
	327	+	}
	328	+
	329	+	func (_c MockWebView_GoForward_Call) Run(run func(ctx context.Context)) MockWebView_GoForward_Call {
	330	+	_c.Call.Run(func(args mock.Arguments) {
	331	+	var arg0 context.Context
	332	+	if args[0] != nil {
	333	+	arg0 = args[0].(context.Context)
	334	+	}
	335	+	run(
	336	+	arg0,
	337	+	)
	338	+	})
	339	+	return _c
	340	+	}
	341	+
	342	+	func (_c MockWebView_GoForward_Call) Return(err error) MockWebView_GoForward_Call {
	343	+	_c.Call.Return(err)
	344	+	return _c
	345	+	}
	346	+
	347	+	func (_c MockWebView_GoForward_Call) RunAndReturn(run func(ctx context.Context) error) MockWebView_GoForward_Call {
	348	+	_c.Call.Return(run)
	349	+	return _c
	350	+	}
	351	+
	352	+	// ID provides a mock function for the type MockWebView
	353	+	func (_mock *MockWebView) ID() port.WebViewID {
	354	+	ret := _mock.Called()
	355	+
	356	+	if len(ret) == 0 {
	357	+	panic("no return value specified for ID")
	358	+	}
	359	+
	360	+	var r0 port.WebViewID
	361	+	if returnFunc, ok := ret.Get(0).(func() port.WebViewID); ok {
	362	+	r0 = returnFunc()
	363	+	} else {
	364	+	r0 = ret.Get(0).(port.WebViewID)
	365	+	}
	366	+	return r0
	367	+	}
	368	+
	369	+	// MockWebView_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'
	370	+	type MockWebView_ID_Call struct {
	371	+	*mock.Call
	372	+	}
	373	+
	374	+	// ID is a helper method to define mock.On call
	375	+	func (_e MockWebView_Expecter) ID() MockWebView_ID_Call {
	376	+	return &MockWebView_ID_Call{Call: _e.mock.On("ID")}
	377	+	}
	378	+
	379	+	func (_c MockWebView_ID_Call) Run(run func()) MockWebView_ID_Call {
	380	+	_c.Call.Run(func(args mock.Arguments) {
	381	+	run()
	382	+	})
	383	+	return _c
	384	+	}
	385	+
	386	+	func (_c MockWebView_ID_Call) Return(webViewID port.WebViewID) MockWebView_ID_Call {
	387	+	_c.Call.Return(webViewID)
	388	+	return _c
	389	+	}
	390	+
	391	+	func (_c MockWebView_ID_Call) RunAndReturn(run func() port.WebViewID) MockWebView_ID_Call {
	392	+	_c.Call.Return(run)
	393	+	return _c
	394	+	}
	395	+
	396	+	// IsDestroyed provides a mock function for the type MockWebView
	397	+	func (_mock *MockWebView) IsDestroyed() bool {
	398	+	ret := _mock.Called()
	399	+
	400	+	if len(ret) == 0 {
	401	+	panic("no return value specified for IsDestroyed")
	402	+	}
	403	+
	404	+	var r0 bool
	405	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	406	+	r0 = returnFunc()
	407	+	} else {
	408	+	r0 = ret.Get(0).(bool)
	409	+	}
	410	+	return r0
	411	+	}
	412	+
	413	+	// MockWebView_IsDestroyed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsDestroyed'
	414	+	type MockWebView_IsDestroyed_Call struct {
	415	+	*mock.Call
	416	+	}
	417	+
	418	+	// IsDestroyed is a helper method to define mock.On call
	419	+	func (_e MockWebView_Expecter) IsDestroyed() MockWebView_IsDestroyed_Call {
	420	+	return &MockWebView_IsDestroyed_Call{Call: _e.mock.On("IsDestroyed")}
	421	+	}
	422	+
	423	+	func (_c MockWebView_IsDestroyed_Call) Run(run func()) MockWebView_IsDestroyed_Call {
	424	+	_c.Call.Run(func(args mock.Arguments) {
	425	+	run()
	426	+	})
	427	+	return _c
	428	+	}
	429	+
	430	+	func (_c MockWebView_IsDestroyed_Call) Return(b bool) MockWebView_IsDestroyed_Call {
	431	+	_c.Call.Return(b)
	432	+	return _c
	433	+	}
	434	+
	435	+	func (_c MockWebView_IsDestroyed_Call) RunAndReturn(run func() bool) MockWebView_IsDestroyed_Call {
	436	+	_c.Call.Return(run)
	437	+	return _c
	438	+	}
	439	+
	440	+	// IsLoading provides a mock function for the type MockWebView
	441	+	func (_mock *MockWebView) IsLoading() bool {
	442	+	ret := _mock.Called()
	443	+
	444	+	if len(ret) == 0 {
	445	+	panic("no return value specified for IsLoading")
	446	+	}
	447	+
	448	+	var r0 bool
	449	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	450	+	r0 = returnFunc()
	451	+	} else {
	452	+	r0 = ret.Get(0).(bool)
	453	+	}
	454	+	return r0
	455	+	}
	456	+
	457	+	// MockWebView_IsLoading_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsLoading'
	458	+	type MockWebView_IsLoading_Call struct {
	459	+	*mock.Call
	460	+	}
	461	+
	462	+	// IsLoading is a helper method to define mock.On call
	463	+	func (_e MockWebView_Expecter) IsLoading() MockWebView_IsLoading_Call {
	464	+	return &MockWebView_IsLoading_Call{Call: _e.mock.On("IsLoading")}
	465	+	}
	466	+
	467	+	func (_c MockWebView_IsLoading_Call) Run(run func()) MockWebView_IsLoading_Call {
	468	+	_c.Call.Run(func(args mock.Arguments) {
	469	+	run()
	470	+	})
	471	+	return _c
	472	+	}
	473	+
	474	+	func (_c MockWebView_IsLoading_Call) Return(b bool) MockWebView_IsLoading_Call {
	475	+	_c.Call.Return(b)
	476	+	return _c
	477	+	}
	478	+
	479	+	func (_c MockWebView_IsLoading_Call) RunAndReturn(run func() bool) MockWebView_IsLoading_Call {
	480	+	_c.Call.Return(run)
	481	+	return _c
	482	+	}
	483	+
	484	+	// LoadHTML provides a mock function for the type MockWebView
	485	+	func (_mock *MockWebView) LoadHTML(ctx context.Context, content string, baseURI string) error {
	486	+	ret := _mock.Called(ctx, content, baseURI)
	487	+
	488	+	if len(ret) == 0 {
	489	+	panic("no return value specified for LoadHTML")
	490	+	}
	491	+
	492	+	var r0 error
	493	+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
	494	+	r0 = returnFunc(ctx, content, baseURI)
	495	+	} else {
	496	+	r0 = ret.Error(0)
	497	+	}
	498	+	return r0
	499	+	}
	500	+
	501	+	// MockWebView_LoadHTML_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadHTML'
	502	+	type MockWebView_LoadHTML_Call struct {
	503	+	*mock.Call
	504	+	}
	505	+
	506	+	// LoadHTML is a helper method to define mock.On call
	507	+	// - ctx context.Context
	508	+	// - content string
	509	+	// - baseURI string
	510	+	func (_e MockWebView_Expecter) LoadHTML(ctx interface{}, content interface{}, baseURI interface{}) MockWebView_LoadHTML_Call {
	511	+	return &MockWebView_LoadHTML_Call{Call: _e.mock.On("LoadHTML", ctx, content, baseURI)}
	512	+	}
	513	+
	514	+	func (_c MockWebView_LoadHTML_Call) Run(run func(ctx context.Context, content string, baseURI string)) MockWebView_LoadHTML_Call {
	515	+	_c.Call.Run(func(args mock.Arguments) {
	516	+	var arg0 context.Context
	517	+	if args[0] != nil {
	518	+	arg0 = args[0].(context.Context)
	519	+	}
	520	+	var arg1 string
	521	+	if args[1] != nil {
	522	+	arg1 = args[1].(string)
	523	+	}
	524	+	var arg2 string
	525	+	if args[2] != nil {
	526	+	arg2 = args[2].(string)
	527	+	}
	528	+	run(
	529	+	arg0,
	530	+	arg1,
	531	+	arg2,
	532	+	)
	533	+	})
	534	+	return _c
	535	+	}
	536	+
	537	+	func (_c MockWebView_LoadHTML_Call) Return(err error) MockWebView_LoadHTML_Call {
	538	+	_c.Call.Return(err)
	539	+	return _c
	540	+	}
	541	+
	542	+	func (_c MockWebView_LoadHTML_Call) RunAndReturn(run func(ctx context.Context, content string, baseURI string) error) MockWebView_LoadHTML_Call {
	543	+	_c.Call.Return(run)
	544	+	return _c
	545	+	}
	546	+
	547	+	// LoadURI provides a mock function for the type MockWebView
	548	+	func (_mock *MockWebView) LoadURI(ctx context.Context, uri string) error {
	549	+	ret := _mock.Called(ctx, uri)
	550	+
	551	+	if len(ret) == 0 {
	552	+	panic("no return value specified for LoadURI")
	553	+	}
	554	+
	555	+	var r0 error
	556	+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
	557	+	r0 = returnFunc(ctx, uri)
	558	+	} else {
	559	+	r0 = ret.Error(0)
	560	+	}
	561	+	return r0
	562	+	}
	563	+
	564	+	// MockWebView_LoadURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadURI'
	565	+	type MockWebView_LoadURI_Call struct {
	566	+	*mock.Call
	567	+	}
	568	+
	569	+	// LoadURI is a helper method to define mock.On call
	570	+	// - ctx context.Context
	571	+	// - uri string
	572	+	func (_e MockWebView_Expecter) LoadURI(ctx interface{}, uri interface{}) MockWebView_LoadURI_Call {
	573	+	return &MockWebView_LoadURI_Call{Call: _e.mock.On("LoadURI", ctx, uri)}
	574	+	}
	575	+
	576	+	func (_c MockWebView_LoadURI_Call) Run(run func(ctx context.Context, uri string)) MockWebView_LoadURI_Call {
	577	+	_c.Call.Run(func(args mock.Arguments) {
	578	+	var arg0 context.Context
	579	+	if args[0] != nil {
	580	+	arg0 = args[0].(context.Context)
	581	+	}
	582	+	var arg1 string
	583	+	if args[1] != nil {
	584	+	arg1 = args[1].(string)
	585	+	}
	586	+	run(
	587	+	arg0,
	588	+	arg1,
	589	+	)
	590	+	})
	591	+	return _c
	592	+	}
	593	+
	594	+	func (_c MockWebView_LoadURI_Call) Return(err error) MockWebView_LoadURI_Call {
	595	+	_c.Call.Return(err)
	596	+	return _c
	597	+	}
	598	+
	599	+	func (_c MockWebView_LoadURI_Call) RunAndReturn(run func(ctx context.Context, uri string) error) MockWebView_LoadURI_Call {
	600	+	_c.Call.Return(run)
	601	+	return _c
	602	+	}
	603	+
	604	+	// Reload provides a mock function for the type MockWebView
	605	+	func (_mock *MockWebView) Reload(ctx context.Context) error {
	606	+	ret := _mock.Called(ctx)
	607	+
	608	+	if len(ret) == 0 {
	609	+	panic("no return value specified for Reload")
	610	+	}
	611	+
	612	+	var r0 error
	613	+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
	614	+	r0 = returnFunc(ctx)
	615	+	} else {
	616	+	r0 = ret.Error(0)
	617	+	}
	618	+	return r0
	619	+	}
	620	+
	621	+	// MockWebView_Reload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reload'
	622	+	type MockWebView_Reload_Call struct {
	623	+	*mock.Call
	624	+	}
	625	+
	626	+	// Reload is a helper method to define mock.On call
	627	+	// - ctx context.Context
	628	+	func (_e MockWebView_Expecter) Reload(ctx interface{}) MockWebView_Reload_Call {
	629	+	return &MockWebView_Reload_Call{Call: _e.mock.On("Reload", ctx)}
	630	+	}
	631	+
	632	+	func (_c MockWebView_Reload_Call) Run(run func(ctx context.Context)) MockWebView_Reload_Call {
	633	+	_c.Call.Run(func(args mock.Arguments) {
	634	+	var arg0 context.Context
	635	+	if args[0] != nil {
	636	+	arg0 = args[0].(context.Context)
	637	+	}
	638	+	run(
	639	+	arg0,
	640	+	)
	641	+	})
	642	+	return _c
	643	+	}
	644	+
	645	+	func (_c MockWebView_Reload_Call) Return(err error) MockWebView_Reload_Call {
	646	+	_c.Call.Return(err)
	647	+	return _c
	648	+	}
	649	+
	650	+	func (_c MockWebView_Reload_Call) RunAndReturn(run func(ctx context.Context) error) MockWebView_Reload_Call {
	651	+	_c.Call.Return(run)
	652	+	return _c
	653	+	}
	654	+
	655	+	// ReloadBypassCache provides a mock function for the type MockWebView
	656	+	func (_mock *MockWebView) ReloadBypassCache(ctx context.Context) error {
	657	+	ret := _mock.Called(ctx)
	658	+
	659	+	if len(ret) == 0 {
	660	+	panic("no return value specified for ReloadBypassCache")
	661	+	}
	662	+
	663	+	var r0 error
	664	+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
	665	+	r0 = returnFunc(ctx)
	666	+	} else {
	667	+	r0 = ret.Error(0)
	668	+	}
	669	+	return r0
	670	+	}
	671	+
	672	+	// MockWebView_ReloadBypassCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReloadBypassCache'
	673	+	type MockWebView_ReloadBypassCache_Call struct {
	674	+	*mock.Call
	675	+	}
	676	+
	677	+	// ReloadBypassCache is a helper method to define mock.On call
	678	+	// - ctx context.Context
	679	+	func (_e MockWebView_Expecter) ReloadBypassCache(ctx interface{}) MockWebView_ReloadBypassCache_Call {
	680	+	return &MockWebView_ReloadBypassCache_Call{Call: _e.mock.On("ReloadBypassCache", ctx)}
	681	+	}
	682	+
	683	+	func (_c MockWebView_ReloadBypassCache_Call) Run(run func(ctx context.Context)) MockWebView_ReloadBypassCache_Call {
	684	+	_c.Call.Run(func(args mock.Arguments) {
	685	+	var arg0 context.Context
	686	+	if args[0] != nil {
	687	+	arg0 = args[0].(context.Context)
	688	+	}
	689	+	run(
	690	+	arg0,
	691	+	)
	692	+	})
	693	+	return _c
	694	+	}
	695	+
	696	+	func (_c MockWebView_ReloadBypassCache_Call) Return(err error) MockWebView_ReloadBypassCache_Call {
	697	+	_c.Call.Return(err)
	698	+	return _c
	699	+	}
	700	+
	701	+	func (_c MockWebView_ReloadBypassCache_Call) RunAndReturn(run func(ctx context.Context) error) MockWebView_ReloadBypassCache_Call {
	702	+	_c.Call.Return(run)
	703	+	return _c
	704	+	}
	705	+
	706	+	// SetCallbacks provides a mock function for the type MockWebView
	707	+	func (_mock MockWebView) SetCallbacks(callbacks port.WebViewCallbacks) {
	708	+	_mock.Called(callbacks)
	709	+	return
	710	+	}
	711	+
	712	+	// MockWebView_SetCallbacks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallbacks'
	713	+	type MockWebView_SetCallbacks_Call struct {
	714	+	*mock.Call
	715	+	}
	716	+
	717	+	// SetCallbacks is a helper method to define mock.On call
	718	+	// - callbacks *port.WebViewCallbacks
	719	+	func (_e MockWebView_Expecter) SetCallbacks(callbacks interface{}) MockWebView_SetCallbacks_Call {
	720	+	return &MockWebView_SetCallbacks_Call{Call: _e.mock.On("SetCallbacks", callbacks)}
	721	+	}
	722	+
	723	+	func (_c MockWebView_SetCallbacks_Call) Run(run func(callbacks port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
	724	+	_c.Call.Run(func(args mock.Arguments) {
	725	+	var arg0 *port.WebViewCallbacks
	726	+	if args[0] != nil {
	727	+	arg0 = args[0].(*port.WebViewCallbacks)
	728	+	}
	729	+	run(
	730	+	arg0,
	731	+	)
	732	+	})
	733	+	return _c
	734	+	}
	735	+
	736	+	func (_c MockWebView_SetCallbacks_Call) Return() MockWebView_SetCallbacks_Call {
	737	+	_c.Call.Return()
	738	+	return _c
	739	+	}
	740	+
	741	+	func (_c MockWebView_SetCallbacks_Call) RunAndReturn(run func(callbacks port.WebViewCallbacks)) *MockWebView_SetCallbacks_Call {
	742	+	_c.Run(run)
	743	+	return _c
	744	+	}
	745	+
	746	+	// SetZoomLevel provides a mock function for the type MockWebView
	747	+	func (_mock *MockWebView) SetZoomLevel(ctx context.Context, level float64) error {
	748	+	ret := _mock.Called(ctx, level)
	749	+
	750	+	if len(ret) == 0 {
	751	+	panic("no return value specified for SetZoomLevel")
	752	+	}
	753	+
	754	+	var r0 error
	755	+	if returnFunc, ok := ret.Get(0).(func(context.Context, float64) error); ok {
	756	+	r0 = returnFunc(ctx, level)
	757	+	} else {
	758	+	r0 = ret.Error(0)
	759	+	}
	760	+	return r0
	761	+	}
	762	+
	763	+	// MockWebView_SetZoomLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetZoomLevel'
	764	+	type MockWebView_SetZoomLevel_Call struct {
	765	+	*mock.Call
	766	+	}
	767	+
	768	+	// SetZoomLevel is a helper method to define mock.On call
	769	+	// - ctx context.Context
	770	+	// - level float64
	771	+	func (_e MockWebView_Expecter) SetZoomLevel(ctx interface{}, level interface{}) MockWebView_SetZoomLevel_Call {
	772	+	return &MockWebView_SetZoomLevel_Call{Call: _e.mock.On("SetZoomLevel", ctx, level)}
	773	+	}
	774	+
	775	+	func (_c MockWebView_SetZoomLevel_Call) Run(run func(ctx context.Context, level float64)) MockWebView_SetZoomLevel_Call {
	776	+	_c.Call.Run(func(args mock.Arguments) {
	777	+	var arg0 context.Context
	778	+	if args[0] != nil {
	779	+	arg0 = args[0].(context.Context)
	780	+	}
	781	+	var arg1 float64
	782	+	if args[1] != nil {
	783	+	arg1 = args[1].(float64)
	784	+	}
	785	+	run(
	786	+	arg0,
	787	+	arg1,
	788	+	)
	789	+	})
	790	+	return _c
	791	+	}
	792	+
	793	+	func (_c MockWebView_SetZoomLevel_Call) Return(err error) MockWebView_SetZoomLevel_Call {
	794	+	_c.Call.Return(err)
	795	+	return _c
	796	+	}
	797	+
	798	+	func (_c MockWebView_SetZoomLevel_Call) RunAndReturn(run func(ctx context.Context, level float64) error) MockWebView_SetZoomLevel_Call {
	799	+	_c.Call.Return(run)
	800	+	return _c
	801	+	}
	802	+
	803	+	// State provides a mock function for the type MockWebView
	804	+	func (_mock *MockWebView) State() port.WebViewState {
	805	+	ret := _mock.Called()
	806	+
	807	+	if len(ret) == 0 {
	808	+	panic("no return value specified for State")
	809	+	}
	810	+
	811	+	var r0 port.WebViewState
	812	+	if returnFunc, ok := ret.Get(0).(func() port.WebViewState); ok {
	813	+	r0 = returnFunc()
	814	+	} else {
	815	+	r0 = ret.Get(0).(port.WebViewState)
	816	+	}
	817	+	return r0
	818	+	}
	819	+
	820	+	// MockWebView_State_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'State'
	821	+	type MockWebView_State_Call struct {
	822	+	*mock.Call
	823	+	}
	824	+
	825	+	// State is a helper method to define mock.On call
	826	+	func (_e MockWebView_Expecter) State() MockWebView_State_Call {
	827	+	return &MockWebView_State_Call{Call: _e.mock.On("State")}
	828	+	}
	829	+
	830	+	func (_c MockWebView_State_Call) Run(run func()) MockWebView_State_Call {
	831	+	_c.Call.Run(func(args mock.Arguments) {
	832	+	run()
	833	+	})
	834	+	return _c
	835	+	}
	836	+
	837	+	func (_c MockWebView_State_Call) Return(webViewState port.WebViewState) MockWebView_State_Call {
	838	+	_c.Call.Return(webViewState)
	839	+	return _c
	840	+	}
	841	+
	842	+	func (_c MockWebView_State_Call) RunAndReturn(run func() port.WebViewState) MockWebView_State_Call {
	843	+	_c.Call.Return(run)
	844	+	return _c
	845	+	}
	846	+
	847	+	// Stop provides a mock function for the type MockWebView
	848	+	func (_mock *MockWebView) Stop(ctx context.Context) error {
	849	+	ret := _mock.Called(ctx)
	850	+
	851	+	if len(ret) == 0 {
	852	+	panic("no return value specified for Stop")
	853	+	}
	854	+
	855	+	var r0 error
	856	+	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
	857	+	r0 = returnFunc(ctx)
	858	+	} else {
	859	+	r0 = ret.Error(0)
	860	+	}
	861	+	return r0
	862	+	}
	863	+
	864	+	// MockWebView_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
	865	+	type MockWebView_Stop_Call struct {
	866	+	*mock.Call
	867	+	}
	868	+
	869	+	// Stop is a helper method to define mock.On call
	870	+	// - ctx context.Context
	871	+	func (_e MockWebView_Expecter) Stop(ctx interface{}) MockWebView_Stop_Call {
	872	+	return &MockWebView_Stop_Call{Call: _e.mock.On("Stop", ctx)}
	873	+	}
	874	+
	875	+	func (_c MockWebView_Stop_Call) Run(run func(ctx context.Context)) MockWebView_Stop_Call {
	876	+	_c.Call.Run(func(args mock.Arguments) {
	877	+	var arg0 context.Context
	878	+	if args[0] != nil {
	879	+	arg0 = args[0].(context.Context)
	880	+	}
	881	+	run(
	882	+	arg0,
	883	+	)
	884	+	})
	885	+	return _c
	886	+	}
	887	+
	888	+	func (_c MockWebView_Stop_Call) Return(err error) MockWebView_Stop_Call {
	889	+	_c.Call.Return(err)
	890	+	return _c
	891	+	}
	892	+
	893	+	func (_c MockWebView_Stop_Call) RunAndReturn(run func(ctx context.Context) error) MockWebView_Stop_Call {
	894	+	_c.Call.Return(run)
	895	+	return _c
	896	+	}
	897	+
	898	+	// Title provides a mock function for the type MockWebView
	899	+	func (_mock *MockWebView) Title() string {
	900	+	ret := _mock.Called()
	901	+
	902	+	if len(ret) == 0 {
	903	+	panic("no return value specified for Title")
	904	+	}
	905	+
	906	+	var r0 string
	907	+	if returnFunc, ok := ret.Get(0).(func() string); ok {
	908	+	r0 = returnFunc()
	909	+	} else {
	910	+	r0 = ret.Get(0).(string)
	911	+	}
	912	+	return r0
	913	+	}
	914	+
	915	+	// MockWebView_Title_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Title'
	916	+	type MockWebView_Title_Call struct {
	917	+	*mock.Call
	918	+	}
	919	+
	920	+	// Title is a helper method to define mock.On call
	921	+	func (_e MockWebView_Expecter) Title() MockWebView_Title_Call {
	922	+	return &MockWebView_Title_Call{Call: _e.mock.On("Title")}
	923	+	}
	924	+
	925	+	func (_c MockWebView_Title_Call) Run(run func()) MockWebView_Title_Call {
	926	+	_c.Call.Run(func(args mock.Arguments) {
	927	+	run()
	928	+	})
	929	+	return _c
	930	+	}
	931	+
	932	+	func (_c MockWebView_Title_Call) Return(s string) MockWebView_Title_Call {
	933	+	_c.Call.Return(s)
	934	+	return _c
	935	+	}
	936	+
	937	+	func (_c MockWebView_Title_Call) RunAndReturn(run func() string) MockWebView_Title_Call {
	938	+	_c.Call.Return(run)
	939	+	return _c
	940	+	}
	941	+
	942	+	// URI provides a mock function for the type MockWebView
	943	+	func (_mock *MockWebView) URI() string {
	944	+	ret := _mock.Called()
	945	+
	946	+	if len(ret) == 0 {
	947	+	panic("no return value specified for URI")
	948	+	}
	949	+
	950	+	var r0 string
	951	+	if returnFunc, ok := ret.Get(0).(func() string); ok {
	952	+	r0 = returnFunc()
	953	+	} else {
	954	+	r0 = ret.Get(0).(string)
	955	+	}
	956	+	return r0
	957	+	}
	958	+
	959	+	// MockWebView_URI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'URI'
	960	+	type MockWebView_URI_Call struct {
	961	+	*mock.Call
	962	+	}
	963	+
	964	+	// URI is a helper method to define mock.On call
	965	+	func (_e MockWebView_Expecter) URI() MockWebView_URI_Call {
	966	+	return &MockWebView_URI_Call{Call: _e.mock.On("URI")}
	967	+	}
	968	+
	969	+	func (_c MockWebView_URI_Call) Run(run func()) MockWebView_URI_Call {
	970	+	_c.Call.Run(func(args mock.Arguments) {
	971	+	run()
	972	+	})
	973	+	return _c
	974	+	}
	975	+
	976	+	func (_c MockWebView_URI_Call) Return(s string) MockWebView_URI_Call {
	977	+	_c.Call.Return(s)
	978	+	return _c
	979	+	}
	980	+
	981	+	func (_c MockWebView_URI_Call) RunAndReturn(run func() string) MockWebView_URI_Call {
	982	+	_c.Call.Return(run)
	983	+	return _c
	984	+	}

A internal/application/port/mocks/mock_web_view_factory.go +169 -0

@@ -0,0 +1,169 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"context"
	9	+
	10	+	"github.com/bnema/dumber/internal/application/port"
	11	+	mock "github.com/stretchr/testify/mock"
	12	+	)
	13	+
	14	+	// NewMockWebViewFactory creates a new instance of MockWebViewFactory. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	15	+	// The first argument is typically a *testing.T value.
	16	+	func NewMockWebViewFactory(t interface {
	17	+	mock.TestingT
	18	+	Cleanup(func())
	19	+	}) *MockWebViewFactory {
	20	+	mock := &MockWebViewFactory{}
	21	+	mock.Mock.Test(t)
	22	+
	23	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	24	+
	25	+	return mock
	26	+	}
	27	+
	28	+	// MockWebViewFactory is an autogenerated mock type for the WebViewFactory type
	29	+	type MockWebViewFactory struct {
	30	+	mock.Mock
	31	+	}
	32	+
	33	+	type MockWebViewFactory_Expecter struct {
	34	+	mock *mock.Mock
	35	+	}
	36	+
	37	+	func (_m MockWebViewFactory) EXPECT() MockWebViewFactory_Expecter {
	38	+	return &MockWebViewFactory_Expecter{mock: &_m.Mock}
	39	+	}
	40	+
	41	+	// Create provides a mock function for the type MockWebViewFactory
	42	+	func (_mock *MockWebViewFactory) Create(ctx context.Context) (port.WebView, error) {
	43	+	ret := _mock.Called(ctx)
	44	+
	45	+	if len(ret) == 0 {
	46	+	panic("no return value specified for Create")
	47	+	}
	48	+
	49	+	var r0 port.WebView
	50	+	var r1 error
	51	+	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
	52	+	return returnFunc(ctx)
	53	+	}
	54	+	if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
	55	+	r0 = returnFunc(ctx)
	56	+	} else {
	57	+	if ret.Get(0) != nil {
	58	+	r0 = ret.Get(0).(port.WebView)
	59	+	}
	60	+	}
	61	+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
	62	+	r1 = returnFunc(ctx)
	63	+	} else {
	64	+	r1 = ret.Error(1)
	65	+	}
	66	+	return r0, r1
	67	+	}
	68	+
	69	+	// MockWebViewFactory_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
	70	+	type MockWebViewFactory_Create_Call struct {
	71	+	*mock.Call
	72	+	}
	73	+
	74	+	// Create is a helper method to define mock.On call
	75	+	// - ctx context.Context
	76	+	func (_e MockWebViewFactory_Expecter) Create(ctx interface{}) MockWebViewFactory_Create_Call {
	77	+	return &MockWebViewFactory_Create_Call{Call: _e.mock.On("Create", ctx)}
	78	+	}
	79	+
	80	+	func (_c MockWebViewFactory_Create_Call) Run(run func(ctx context.Context)) MockWebViewFactory_Create_Call {
	81	+	_c.Call.Run(func(args mock.Arguments) {
	82	+	var arg0 context.Context
	83	+	if args[0] != nil {
	84	+	arg0 = args[0].(context.Context)
	85	+	}
	86	+	run(
	87	+	arg0,
	88	+	)
	89	+	})
	90	+	return _c
	91	+	}
	92	+
	93	+	func (_c MockWebViewFactory_Create_Call) Return(webView port.WebView, err error) MockWebViewFactory_Create_Call {
	94	+	_c.Call.Return(webView, err)
	95	+	return _c
	96	+	}
	97	+
	98	+	func (_c MockWebViewFactory_Create_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) MockWebViewFactory_Create_Call {
	99	+	_c.Call.Return(run)
	100	+	return _c
	101	+	}
	102	+
	103	+	// CreateRelated provides a mock function for the type MockWebViewFactory
	104	+	func (_mock *MockWebViewFactory) CreateRelated(ctx context.Context, parentID port.WebViewID) (port.WebView, error) {
	105	+	ret := _mock.Called(ctx, parentID)
	106	+
	107	+	if len(ret) == 0 {
	108	+	panic("no return value specified for CreateRelated")
	109	+	}
	110	+
	111	+	var r0 port.WebView
	112	+	var r1 error
	113	+	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) (port.WebView, error)); ok {
	114	+	return returnFunc(ctx, parentID)
	115	+	}
	116	+	if returnFunc, ok := ret.Get(0).(func(context.Context, port.WebViewID) port.WebView); ok {
	117	+	r0 = returnFunc(ctx, parentID)
	118	+	} else {
	119	+	if ret.Get(0) != nil {
	120	+	r0 = ret.Get(0).(port.WebView)
	121	+	}
	122	+	}
	123	+	if returnFunc, ok := ret.Get(1).(func(context.Context, port.WebViewID) error); ok {
	124	+	r1 = returnFunc(ctx, parentID)
	125	+	} else {
	126	+	r1 = ret.Error(1)
	127	+	}
	128	+	return r0, r1
	129	+	}
	130	+
	131	+	// MockWebViewFactory_CreateRelated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRelated'
	132	+	type MockWebViewFactory_CreateRelated_Call struct {
	133	+	*mock.Call
	134	+	}
	135	+
	136	+	// CreateRelated is a helper method to define mock.On call
	137	+	// - ctx context.Context
	138	+	// - parentID port.WebViewID
	139	+	func (_e MockWebViewFactory_Expecter) CreateRelated(ctx interface{}, parentID interface{}) MockWebViewFactory_CreateRelated_Call {
	140	+	return &MockWebViewFactory_CreateRelated_Call{Call: _e.mock.On("CreateRelated", ctx, parentID)}
	141	+	}
	142	+
	143	+	func (_c MockWebViewFactory_CreateRelated_Call) Run(run func(ctx context.Context, parentID port.WebViewID)) MockWebViewFactory_CreateRelated_Call {
	144	+	_c.Call.Run(func(args mock.Arguments) {
	145	+	var arg0 context.Context
	146	+	if args[0] != nil {
	147	+	arg0 = args[0].(context.Context)
	148	+	}
	149	+	var arg1 port.WebViewID
	150	+	if args[1] != nil {
	151	+	arg1 = args[1].(port.WebViewID)
	152	+	}
	153	+	run(
	154	+	arg0,
	155	+	arg1,
	156	+	)
	157	+	})
	158	+	return _c
	159	+	}
	160	+
	161	+	func (_c MockWebViewFactory_CreateRelated_Call) Return(webView port.WebView, err error) MockWebViewFactory_CreateRelated_Call {
	162	+	_c.Call.Return(webView, err)
	163	+	return _c
	164	+	}
	165	+
	166	+	func (_c MockWebViewFactory_CreateRelated_Call) RunAndReturn(run func(ctx context.Context, parentID port.WebViewID) (port.WebView, error)) MockWebViewFactory_CreateRelated_Call {
	167	+	_c.Call.Return(run)
	168	+	return _c
	169	+	}

A internal/application/port/mocks/mock_web_view_pool.go +258 -0

@@ -0,0 +1,258 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"context"
	9	+
	10	+	"github.com/bnema/dumber/internal/application/port"
	11	+	mock "github.com/stretchr/testify/mock"
	12	+	)
	13	+
	14	+	// NewMockWebViewPool creates a new instance of MockWebViewPool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	15	+	// The first argument is typically a *testing.T value.
	16	+	func NewMockWebViewPool(t interface {
	17	+	mock.TestingT
	18	+	Cleanup(func())
	19	+	}) *MockWebViewPool {
	20	+	mock := &MockWebViewPool{}
	21	+	mock.Mock.Test(t)
	22	+
	23	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	24	+
	25	+	return mock
	26	+	}
	27	+
	28	+	// MockWebViewPool is an autogenerated mock type for the WebViewPool type
	29	+	type MockWebViewPool struct {
	30	+	mock.Mock
	31	+	}
	32	+
	33	+	type MockWebViewPool_Expecter struct {
	34	+	mock *mock.Mock
	35	+	}
	36	+
	37	+	func (_m MockWebViewPool) EXPECT() MockWebViewPool_Expecter {
	38	+	return &MockWebViewPool_Expecter{mock: &_m.Mock}
	39	+	}
	40	+
	41	+	// Acquire provides a mock function for the type MockWebViewPool
	42	+	func (_mock *MockWebViewPool) Acquire(ctx context.Context) (port.WebView, error) {
	43	+	ret := _mock.Called(ctx)
	44	+
	45	+	if len(ret) == 0 {
	46	+	panic("no return value specified for Acquire")
	47	+	}
	48	+
	49	+	var r0 port.WebView
	50	+	var r1 error
	51	+	if returnFunc, ok := ret.Get(0).(func(context.Context) (port.WebView, error)); ok {
	52	+	return returnFunc(ctx)
	53	+	}
	54	+	if returnFunc, ok := ret.Get(0).(func(context.Context) port.WebView); ok {
	55	+	r0 = returnFunc(ctx)
	56	+	} else {
	57	+	if ret.Get(0) != nil {
	58	+	r0 = ret.Get(0).(port.WebView)
	59	+	}
	60	+	}
	61	+	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
	62	+	r1 = returnFunc(ctx)
	63	+	} else {
	64	+	r1 = ret.Error(1)
	65	+	}
	66	+	return r0, r1
	67	+	}
	68	+
	69	+	// MockWebViewPool_Acquire_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Acquire'
	70	+	type MockWebViewPool_Acquire_Call struct {
	71	+	*mock.Call
	72	+	}
	73	+
	74	+	// Acquire is a helper method to define mock.On call
	75	+	// - ctx context.Context
	76	+	func (_e MockWebViewPool_Expecter) Acquire(ctx interface{}) MockWebViewPool_Acquire_Call {
	77	+	return &MockWebViewPool_Acquire_Call{Call: _e.mock.On("Acquire", ctx)}
	78	+	}
	79	+
	80	+	func (_c MockWebViewPool_Acquire_Call) Run(run func(ctx context.Context)) MockWebViewPool_Acquire_Call {
	81	+	_c.Call.Run(func(args mock.Arguments) {
	82	+	var arg0 context.Context
	83	+	if args[0] != nil {
	84	+	arg0 = args[0].(context.Context)
	85	+	}
	86	+	run(
	87	+	arg0,
	88	+	)
	89	+	})
	90	+	return _c
	91	+	}
	92	+
	93	+	func (_c MockWebViewPool_Acquire_Call) Return(webView port.WebView, err error) MockWebViewPool_Acquire_Call {
	94	+	_c.Call.Return(webView, err)
	95	+	return _c
	96	+	}
	97	+
	98	+	func (_c MockWebViewPool_Acquire_Call) RunAndReturn(run func(ctx context.Context) (port.WebView, error)) MockWebViewPool_Acquire_Call {
	99	+	_c.Call.Return(run)
	100	+	return _c
	101	+	}
	102	+
	103	+	// Close provides a mock function for the type MockWebViewPool
	104	+	func (_mock *MockWebViewPool) Close() {
	105	+	_mock.Called()
	106	+	return
	107	+	}
	108	+
	109	+	// MockWebViewPool_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
	110	+	type MockWebViewPool_Close_Call struct {
	111	+	*mock.Call
	112	+	}
	113	+
	114	+	// Close is a helper method to define mock.On call
	115	+	func (_e MockWebViewPool_Expecter) Close() MockWebViewPool_Close_Call {
	116	+	return &MockWebViewPool_Close_Call{Call: _e.mock.On("Close")}
	117	+	}
	118	+
	119	+	func (_c MockWebViewPool_Close_Call) Run(run func()) MockWebViewPool_Close_Call {
	120	+	_c.Call.Run(func(args mock.Arguments) {
	121	+	run()
	122	+	})
	123	+	return _c
	124	+	}
	125	+
	126	+	func (_c MockWebViewPool_Close_Call) Return() MockWebViewPool_Close_Call {
	127	+	_c.Call.Return()
	128	+	return _c
	129	+	}
	130	+
	131	+	func (_c MockWebViewPool_Close_Call) RunAndReturn(run func()) MockWebViewPool_Close_Call {
	132	+	_c.Run(run)
	133	+	return _c
	134	+	}
	135	+
	136	+	// Prewarm provides a mock function for the type MockWebViewPool
	137	+	func (_mock *MockWebViewPool) Prewarm(count int) {
	138	+	_mock.Called(count)
	139	+	return
	140	+	}
	141	+
	142	+	// MockWebViewPool_Prewarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prewarm'
	143	+	type MockWebViewPool_Prewarm_Call struct {
	144	+	*mock.Call
	145	+	}
	146	+
	147	+	// Prewarm is a helper method to define mock.On call
	148	+	// - count int
	149	+	func (_e MockWebViewPool_Expecter) Prewarm(count interface{}) MockWebViewPool_Prewarm_Call {
	150	+	return &MockWebViewPool_Prewarm_Call{Call: _e.mock.On("Prewarm", count)}
	151	+	}
	152	+
	153	+	func (_c MockWebViewPool_Prewarm_Call) Run(run func(count int)) MockWebViewPool_Prewarm_Call {
	154	+	_c.Call.Run(func(args mock.Arguments) {
	155	+	var arg0 int
	156	+	if args[0] != nil {
	157	+	arg0 = args[0].(int)
	158	+	}
	159	+	run(
	160	+	arg0,
	161	+	)
	162	+	})
	163	+	return _c
	164	+	}
	165	+
	166	+	func (_c MockWebViewPool_Prewarm_Call) Return() MockWebViewPool_Prewarm_Call {
	167	+	_c.Call.Return()
	168	+	return _c
	169	+	}
	170	+
	171	+	func (_c MockWebViewPool_Prewarm_Call) RunAndReturn(run func(count int)) MockWebViewPool_Prewarm_Call {
	172	+	_c.Run(run)
	173	+	return _c
	174	+	}
	175	+
	176	+	// Release provides a mock function for the type MockWebViewPool
	177	+	func (_mock *MockWebViewPool) Release(wv port.WebView) {
	178	+	_mock.Called(wv)
	179	+	return
	180	+	}
	181	+
	182	+	// MockWebViewPool_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
	183	+	type MockWebViewPool_Release_Call struct {
	184	+	*mock.Call
	185	+	}
	186	+
	187	+	// Release is a helper method to define mock.On call
	188	+	// - wv port.WebView
	189	+	func (_e MockWebViewPool_Expecter) Release(wv interface{}) MockWebViewPool_Release_Call {
	190	+	return &MockWebViewPool_Release_Call{Call: _e.mock.On("Release", wv)}
	191	+	}
	192	+
	193	+	func (_c MockWebViewPool_Release_Call) Run(run func(wv port.WebView)) MockWebViewPool_Release_Call {
	194	+	_c.Call.Run(func(args mock.Arguments) {
	195	+	var arg0 port.WebView
	196	+	if args[0] != nil {
	197	+	arg0 = args[0].(port.WebView)
	198	+	}
	199	+	run(
	200	+	arg0,
	201	+	)
	202	+	})
	203	+	return _c
	204	+	}
	205	+
	206	+	func (_c MockWebViewPool_Release_Call) Return() MockWebViewPool_Release_Call {
	207	+	_c.Call.Return()
	208	+	return _c
	209	+	}
	210	+
	211	+	func (_c MockWebViewPool_Release_Call) RunAndReturn(run func(wv port.WebView)) MockWebViewPool_Release_Call {
	212	+	_c.Run(run)
	213	+	return _c
	214	+	}
	215	+
	216	+	// Size provides a mock function for the type MockWebViewPool
	217	+	func (_mock *MockWebViewPool) Size() int {
	218	+	ret := _mock.Called()
	219	+
	220	+	if len(ret) == 0 {
	221	+	panic("no return value specified for Size")
	222	+	}
	223	+
	224	+	var r0 int
	225	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	226	+	r0 = returnFunc()
	227	+	} else {
	228	+	r0 = ret.Get(0).(int)
	229	+	}
	230	+	return r0
	231	+	}
	232	+
	233	+	// MockWebViewPool_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
	234	+	type MockWebViewPool_Size_Call struct {
	235	+	*mock.Call
	236	+	}
	237	+
	238	+	// Size is a helper method to define mock.On call
	239	+	func (_e MockWebViewPool_Expecter) Size() MockWebViewPool_Size_Call {
	240	+	return &MockWebViewPool_Size_Call{Call: _e.mock.On("Size")}
	241	+	}
	242	+
	243	+	func (_c MockWebViewPool_Size_Call) Run(run func()) MockWebViewPool_Size_Call {
	244	+	_c.Call.Run(func(args mock.Arguments) {
	245	+	run()
	246	+	})
	247	+	return _c
	248	+	}
	249	+
	250	+	func (_c MockWebViewPool_Size_Call) Return(n int) MockWebViewPool_Size_Call {
	251	+	_c.Call.Return(n)
	252	+	return _c
	253	+	}
	254	+
	255	+	func (_c MockWebViewPool_Size_Call) RunAndReturn(run func() int) MockWebViewPool_Size_Call {
	256	+	_c.Call.Return(run)
	257	+	return _c
	258	+	}

A internal/ui/layout/gtk_widgets.go +508 -0

@@ -0,0 +1,508 @@
	1	+	package layout
	2	+
	3	+	import (
	4	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	5	+	"github.com/jwijenbergh/puregotk/v4/pango"
	6	+	)
	7	+
	8	+	// Ensure implementations satisfy interfaces at compile time.
	9	+	var (
	10	+	_ Widget = (*gtkWidget)(nil)
	11	+	_ PanedWidget = (*gtkPaned)(nil)
	12	+	_ BoxWidget = (*gtkBox)(nil)
	13	+	_ OverlayWidget = (*gtkOverlay)(nil)
	14	+	_ LabelWidget = (*gtkLabel)(nil)
	15	+	_ ButtonWidget = (*gtkButton)(nil)
	16	+	_ ImageWidget = (*gtkImage)(nil)
	17	+	_ WidgetFactory = (*GtkWidgetFactory)(nil)
	18	+	)
	19	+
	20	+	// gtkWidget wraps a gtk.Widget to implement the Widget interface.
	21	+	type gtkWidget struct {
	22	+	inner *gtk.Widget
	23	+	}
	24	+
	25	+	func (w *gtkWidget) Show() { w.inner.Show() }
	26	+	func (w *gtkWidget) Hide() { w.inner.Hide() }
	27	+	func (w *gtkWidget) SetVisible(visible bool) { w.inner.SetVisible(visible) }
	28	+	func (w *gtkWidget) IsVisible() bool { return w.inner.GetVisible() }
	29	+	func (w *gtkWidget) GrabFocus() bool { return w.inner.GrabFocus() }
	30	+	func (w *gtkWidget) HasFocus() bool { return w.inner.HasFocus() }
	31	+	func (w *gtkWidget) SetCanFocus(canFocus bool) { w.inner.SetCanFocus(canFocus) }
	32	+	func (w *gtkWidget) SetFocusOnClick(focus bool) { w.inner.SetFocusOnClick(focus) }
	33	+	func (w *gtkWidget) SetHexpand(expand bool) { w.inner.SetHexpand(expand) }
	34	+	func (w *gtkWidget) SetVexpand(expand bool) { w.inner.SetVexpand(expand) }
	35	+	func (w *gtkWidget) GetHexpand() bool { return w.inner.GetHexpand() }
	36	+	func (w *gtkWidget) GetVexpand() bool { return w.inner.GetVexpand() }
	37	+	func (w *gtkWidget) SetHalign(align gtk.Align) { w.inner.SetHalign(align) }
	38	+	func (w *gtkWidget) SetValign(align gtk.Align) { w.inner.SetValign(align) }
	39	+	func (w *gtkWidget) SetSizeRequest(w2, h int) { w.inner.SetSizeRequest(w2, h) }
	40	+	func (w *gtkWidget) AddCssClass(class string) { w.inner.AddCssClass(class) }
	41	+	func (w *gtkWidget) RemoveCssClass(class string) { w.inner.RemoveCssClass(class) }
	42	+	func (w *gtkWidget) HasCssClass(class string) bool { return w.inner.HasCssClass(class) }
	43	+	func (w *gtkWidget) Unparent() { w.inner.Unparent() }
	44	+	func (w gtkWidget) GtkWidget() gtk.Widget { return w.inner }
	45	+
	46	+	func (w *gtkWidget) GetParent() Widget {
	47	+	parent := w.inner.GetParent()
	48	+	if parent == nil {
	49	+	return nil
	50	+	}
	51	+	return &gtkWidget{inner: parent}
	52	+	}
	53	+
	54	+	// gtkPaned wraps gtk.Paned to implement PanedWidget.
	55	+	type gtkPaned struct {
	56	+	inner *gtk.Paned
	57	+	}
	58	+
	59	+	func (p *gtkPaned) Show() { p.inner.Show() }
	60	+	func (p *gtkPaned) Hide() { p.inner.Hide() }
	61	+	func (p *gtkPaned) SetVisible(visible bool) { p.inner.SetVisible(visible) }
	62	+	func (p *gtkPaned) IsVisible() bool { return p.inner.GetVisible() }
	63	+	func (p *gtkPaned) GrabFocus() bool { return p.inner.GrabFocus() }
	64	+	func (p *gtkPaned) HasFocus() bool { return p.inner.HasFocus() }
	65	+	func (p *gtkPaned) SetCanFocus(canFocus bool) { p.inner.SetCanFocus(canFocus) }
	66	+	func (p *gtkPaned) SetFocusOnClick(focus bool) { p.inner.SetFocusOnClick(focus) }
	67	+	func (p *gtkPaned) SetHexpand(expand bool) { p.inner.SetHexpand(expand) }
	68	+	func (p *gtkPaned) SetVexpand(expand bool) { p.inner.SetVexpand(expand) }
	69	+	func (p *gtkPaned) GetHexpand() bool { return p.inner.GetHexpand() }
	70	+	func (p *gtkPaned) GetVexpand() bool { return p.inner.GetVexpand() }
	71	+	func (p *gtkPaned) SetHalign(align gtk.Align) { p.inner.SetHalign(align) }
	72	+	func (p *gtkPaned) SetValign(align gtk.Align) { p.inner.SetValign(align) }
	73	+	func (p *gtkPaned) SetSizeRequest(w, h int) { p.inner.SetSizeRequest(w, h) }
	74	+	func (p *gtkPaned) AddCssClass(class string) { p.inner.AddCssClass(class) }
	75	+	func (p *gtkPaned) RemoveCssClass(class string) { p.inner.RemoveCssClass(class) }
	76	+	func (p *gtkPaned) HasCssClass(class string) bool { return p.inner.HasCssClass(class) }
	77	+	func (p *gtkPaned) Unparent() { p.inner.Unparent() }
	78	+	func (p gtkPaned) GtkWidget() gtk.Widget { return &p.inner.Widget }
	79	+
	80	+	func (p *gtkPaned) GetParent() Widget {
	81	+	parent := p.inner.GetParent()
	82	+	if parent == nil {
	83	+	return nil
	84	+	}
	85	+	return &gtkWidget{inner: parent}
	86	+	}
	87	+
	88	+	func (p *gtkPaned) SetStartChild(child Widget) {
	89	+	if child == nil {
	90	+	p.inner.SetStartChild(nil)
	91	+	return
	92	+	}
	93	+	p.inner.SetStartChild(child.GtkWidget())
	94	+	}
	95	+
	96	+	func (p *gtkPaned) SetEndChild(child Widget) {
	97	+	if child == nil {
	98	+	p.inner.SetEndChild(nil)
	99	+	return
	100	+	}
	101	+	p.inner.SetEndChild(child.GtkWidget())
	102	+	}
	103	+
	104	+	func (p *gtkPaned) GetStartChild() Widget {
	105	+	child := p.inner.GetStartChild()
	106	+	if child == nil {
	107	+	return nil
	108	+	}
	109	+	return &gtkWidget{inner: child}
	110	+	}
	111	+
	112	+	func (p *gtkPaned) GetEndChild() Widget {
	113	+	child := p.inner.GetEndChild()
	114	+	if child == nil {
	115	+	return nil
	116	+	}
	117	+	return &gtkWidget{inner: child}
	118	+	}
	119	+
	120	+	func (p *gtkPaned) SetPosition(pos int) { p.inner.SetPosition(pos) }
	121	+	func (p *gtkPaned) GetPosition() int { return p.inner.GetPosition() }
	122	+	func (p *gtkPaned) SetResizeStartChild(r bool) { p.inner.SetResizeStartChild(r) }
	123	+	func (p *gtkPaned) SetResizeEndChild(r bool) { p.inner.SetResizeEndChild(r) }
	124	+	func (p *gtkPaned) GetResizeStartChild() bool { return p.inner.GetResizeStartChild() }
	125	+	func (p *gtkPaned) GetResizeEndChild() bool { return p.inner.GetResizeEndChild() }
	126	+	func (p *gtkPaned) SetShrinkStartChild(s bool) { p.inner.SetShrinkStartChild(s) }
	127	+	func (p *gtkPaned) SetShrinkEndChild(s bool) { p.inner.SetShrinkEndChild(s) }
	128	+	func (p *gtkPaned) GetShrinkStartChild() bool { return p.inner.GetShrinkStartChild() }
	129	+	func (p *gtkPaned) GetShrinkEndChild() bool { return p.inner.GetShrinkEndChild() }
	130	+	func (p *gtkPaned) SetWideHandle(wide bool) { p.inner.SetWideHandle(wide) }
	131	+	func (p *gtkPaned) GetWideHandle() bool { return p.inner.GetWideHandle() }
	132	+
	133	+	func (p *gtkPaned) ConnectMap(callback func()) uint32 {
	134	+	cb := func(w gtk.Widget) {
	135	+	callback()
	136	+	}
	137	+	return p.inner.ConnectMap(&cb)
	138	+	}
	139	+
	140	+	func (p *gtkPaned) GetAllocatedWidth() int { return p.inner.GetAllocatedWidth() }
	141	+	func (p *gtkPaned) GetAllocatedHeight() int { return p.inner.GetAllocatedHeight() }
	142	+
	143	+	// gtkBox wraps gtk.Box to implement BoxWidget.
	144	+	type gtkBox struct {
	145	+	inner *gtk.Box
	146	+	}
	147	+
	148	+	func (b *gtkBox) Show() { b.inner.Show() }
	149	+	func (b *gtkBox) Hide() { b.inner.Hide() }
	150	+	func (b *gtkBox) SetVisible(visible bool) { b.inner.SetVisible(visible) }
	151	+	func (b *gtkBox) IsVisible() bool { return b.inner.GetVisible() }
	152	+	func (b *gtkBox) GrabFocus() bool { return b.inner.GrabFocus() }
	153	+	func (b *gtkBox) HasFocus() bool { return b.inner.HasFocus() }
	154	+	func (b *gtkBox) SetCanFocus(canFocus bool) { b.inner.SetCanFocus(canFocus) }
	155	+	func (b *gtkBox) SetFocusOnClick(focus bool) { b.inner.SetFocusOnClick(focus) }
	156	+	func (b *gtkBox) SetHexpand(expand bool) { b.inner.SetHexpand(expand) }
	157	+	func (b *gtkBox) SetVexpand(expand bool) { b.inner.SetVexpand(expand) }
	158	+	func (b *gtkBox) GetHexpand() bool { return b.inner.GetHexpand() }
	159	+	func (b *gtkBox) GetVexpand() bool { return b.inner.GetVexpand() }
	160	+	func (b *gtkBox) SetHalign(align gtk.Align) { b.inner.SetHalign(align) }
	161	+	func (b *gtkBox) SetValign(align gtk.Align) { b.inner.SetValign(align) }
	162	+	func (b *gtkBox) SetSizeRequest(w, h int) { b.inner.SetSizeRequest(w, h) }
	163	+	func (b *gtkBox) AddCssClass(class string) { b.inner.AddCssClass(class) }
	164	+	func (b *gtkBox) RemoveCssClass(class string) { b.inner.RemoveCssClass(class) }
	165	+	func (b *gtkBox) HasCssClass(class string) bool { return b.inner.HasCssClass(class) }
	166	+	func (b *gtkBox) Unparent() { b.inner.Unparent() }
	167	+	func (b gtkBox) GtkWidget() gtk.Widget { return &b.inner.Widget }
	168	+
	169	+	func (b *gtkBox) GetParent() Widget {
	170	+	parent := b.inner.GetParent()
	171	+	if parent == nil {
	172	+	return nil
	173	+	}
	174	+	return &gtkWidget{inner: parent}
	175	+	}
	176	+
	177	+	func (b *gtkBox) Append(child Widget) {
	178	+	if child == nil {
	179	+	return
	180	+	}
	181	+	b.inner.Append(child.GtkWidget())
	182	+	}
	183	+
	184	+	func (b *gtkBox) Prepend(child Widget) {
	185	+	if child == nil {
	186	+	return
	187	+	}
	188	+	b.inner.Prepend(child.GtkWidget())
	189	+	}
	190	+
	191	+	func (b *gtkBox) Remove(child Widget) {
	192	+	if child == nil {
	193	+	return
	194	+	}
	195	+	b.inner.Remove(child.GtkWidget())
	196	+	}
	197	+
	198	+	func (b *gtkBox) InsertChildAfter(child Widget, sibling Widget) {
	199	+	if child == nil {
	200	+	return
	201	+	}
	202	+	var sibGtk *gtk.Widget
	203	+	if sibling != nil {
	204	+	sibGtk = sibling.GtkWidget()
	205	+	}
	206	+	b.inner.InsertChildAfter(child.GtkWidget(), sibGtk)
	207	+	}
	208	+
	209	+	func (b *gtkBox) ReorderChildAfter(child Widget, sibling Widget) {
	210	+	if child == nil {
	211	+	return
	212	+	}
	213	+	var sibGtk *gtk.Widget
	214	+	if sibling != nil {
	215	+	sibGtk = sibling.GtkWidget()
	216	+	}
	217	+	b.inner.ReorderChildAfter(child.GtkWidget(), sibGtk)
	218	+	}
	219	+
	220	+	func (b *gtkBox) SetHomogeneous(h bool) { b.inner.SetHomogeneous(h) }
	221	+	func (b *gtkBox) GetHomogeneous() bool { return b.inner.GetHomogeneous() }
	222	+	func (b *gtkBox) SetSpacing(s int) { b.inner.SetSpacing(s) }
	223	+	func (b *gtkBox) GetSpacing() int { return b.inner.GetSpacing() }
	224	+	func (b *gtkBox) SetOrientation(o Orientation) { b.inner.SetOrientation(o) }
	225	+	func (b *gtkBox) GetOrientation() Orientation { return b.inner.GetOrientation() }
	226	+
	227	+	// gtkOverlay wraps gtk.Overlay to implement OverlayWidget.
	228	+	type gtkOverlay struct {
	229	+	inner *gtk.Overlay
	230	+	}
	231	+
	232	+	func (o *gtkOverlay) Show() { o.inner.Show() }
	233	+	func (o *gtkOverlay) Hide() { o.inner.Hide() }
	234	+	func (o *gtkOverlay) SetVisible(visible bool) { o.inner.SetVisible(visible) }
	235	+	func (o *gtkOverlay) IsVisible() bool { return o.inner.GetVisible() }
	236	+	func (o *gtkOverlay) GrabFocus() bool { return o.inner.GrabFocus() }
	237	+	func (o *gtkOverlay) HasFocus() bool { return o.inner.HasFocus() }
	238	+	func (o *gtkOverlay) SetCanFocus(canFocus bool) { o.inner.SetCanFocus(canFocus) }
	239	+	func (o *gtkOverlay) SetFocusOnClick(focus bool) { o.inner.SetFocusOnClick(focus) }
	240	+	func (o *gtkOverlay) SetHexpand(expand bool) { o.inner.SetHexpand(expand) }
	241	+	func (o *gtkOverlay) SetVexpand(expand bool) { o.inner.SetVexpand(expand) }
	242	+	func (o *gtkOverlay) GetHexpand() bool { return o.inner.GetHexpand() }
	243	+	func (o *gtkOverlay) GetVexpand() bool { return o.inner.GetVexpand() }
	244	+	func (o *gtkOverlay) SetHalign(align gtk.Align) { o.inner.SetHalign(align) }
	245	+	func (o *gtkOverlay) SetValign(align gtk.Align) { o.inner.SetValign(align) }
	246	+	func (o *gtkOverlay) SetSizeRequest(w, h int) { o.inner.SetSizeRequest(w, h) }
	247	+	func (o *gtkOverlay) AddCssClass(class string) { o.inner.AddCssClass(class) }
	248	+	func (o *gtkOverlay) RemoveCssClass(class string) { o.inner.RemoveCssClass(class) }
	249	+	func (o *gtkOverlay) HasCssClass(class string) bool { return o.inner.HasCssClass(class) }
	250	+	func (o *gtkOverlay) Unparent() { o.inner.Unparent() }
	251	+	func (o gtkOverlay) GtkWidget() gtk.Widget { return &o.inner.Widget }
	252	+
	253	+	func (o *gtkOverlay) GetParent() Widget {
	254	+	parent := o.inner.GetParent()
	255	+	if parent == nil {
	256	+	return nil
	257	+	}
	258	+	return &gtkWidget{inner: parent}
	259	+	}
	260	+
	261	+	func (o *gtkOverlay) SetChild(child Widget) {
	262	+	if child == nil {
	263	+	o.inner.SetChild(nil)
	264	+	return
	265	+	}
	266	+	o.inner.SetChild(child.GtkWidget())
	267	+	}
	268	+
	269	+	func (o *gtkOverlay) GetChild() Widget {
	270	+	child := o.inner.GetChild()
	271	+	if child == nil {
	272	+	return nil
	273	+	}
	274	+	return &gtkWidget{inner: child}
	275	+	}
	276	+
	277	+	func (o *gtkOverlay) AddOverlay(overlay Widget) {
	278	+	if overlay == nil {
	279	+	return
	280	+	}
	281	+	o.inner.AddOverlay(overlay.GtkWidget())
	282	+	}
	283	+
	284	+	func (o *gtkOverlay) RemoveOverlay(overlay Widget) {
	285	+	if overlay == nil {
	286	+	return
	287	+	}
	288	+	o.inner.RemoveOverlay(overlay.GtkWidget())
	289	+	}
	290	+
	291	+	func (o *gtkOverlay) SetClipOverlay(overlay Widget, clip bool) {
	292	+	if overlay == nil {
	293	+	return
	294	+	}
	295	+	o.inner.SetClipOverlay(overlay.GtkWidget(), clip)
	296	+	}
	297	+
	298	+	func (o *gtkOverlay) GetClipOverlay(overlay Widget) bool {
	299	+	if overlay == nil {
	300	+	return false
	301	+	}
	302	+	return o.inner.GetClipOverlay(overlay.GtkWidget())
	303	+	}
	304	+
	305	+	func (o *gtkOverlay) SetMeasureOverlay(overlay Widget, measure bool) {
	306	+	if overlay == nil {
	307	+	return
	308	+	}
	309	+	o.inner.SetMeasureOverlay(overlay.GtkWidget(), measure)
	310	+	}
	311	+
	312	+	func (o *gtkOverlay) GetMeasureOverlay(overlay Widget) bool {
	313	+	if overlay == nil {
	314	+	return false
	315	+	}
	316	+	return o.inner.GetMeasureOverlay(overlay.GtkWidget())
	317	+	}
	318	+
	319	+	// gtkLabel wraps gtk.Label to implement LabelWidget.
	320	+	type gtkLabel struct {
	321	+	inner *gtk.Label
	322	+	}
	323	+
	324	+	func (l *gtkLabel) Show() { l.inner.Show() }
	325	+	func (l *gtkLabel) Hide() { l.inner.Hide() }
	326	+	func (l *gtkLabel) SetVisible(visible bool) { l.inner.SetVisible(visible) }
	327	+	func (l *gtkLabel) IsVisible() bool { return l.inner.GetVisible() }
	328	+	func (l *gtkLabel) GrabFocus() bool { return l.inner.GrabFocus() }
	329	+	func (l *gtkLabel) HasFocus() bool { return l.inner.HasFocus() }
	330	+	func (l *gtkLabel) SetCanFocus(canFocus bool) { l.inner.SetCanFocus(canFocus) }
	331	+	func (l *gtkLabel) SetFocusOnClick(focus bool) { l.inner.SetFocusOnClick(focus) }
	332	+	func (l *gtkLabel) SetHexpand(expand bool) { l.inner.SetHexpand(expand) }
	333	+	func (l *gtkLabel) SetVexpand(expand bool) { l.inner.SetVexpand(expand) }
	334	+	func (l *gtkLabel) GetHexpand() bool { return l.inner.GetHexpand() }
	335	+	func (l *gtkLabel) GetVexpand() bool { return l.inner.GetVexpand() }
	336	+	func (l *gtkLabel) SetHalign(align gtk.Align) { l.inner.SetHalign(align) }
	337	+	func (l *gtkLabel) SetValign(align gtk.Align) { l.inner.SetValign(align) }
	338	+	func (l *gtkLabel) SetSizeRequest(w, h int) { l.inner.SetSizeRequest(w, h) }
	339	+	func (l *gtkLabel) AddCssClass(class string) { l.inner.AddCssClass(class) }
	340	+	func (l *gtkLabel) RemoveCssClass(class string) { l.inner.RemoveCssClass(class) }
	341	+	func (l *gtkLabel) HasCssClass(class string) bool { return l.inner.HasCssClass(class) }
	342	+	func (l *gtkLabel) Unparent() { l.inner.Unparent() }
	343	+	func (l gtkLabel) GtkWidget() gtk.Widget { return &l.inner.Widget }
	344	+
	345	+	func (l *gtkLabel) GetParent() Widget {
	346	+	parent := l.inner.GetParent()
	347	+	if parent == nil {
	348	+	return nil
	349	+	}
	350	+	return &gtkWidget{inner: parent}
	351	+	}
	352	+
	353	+	func (l *gtkLabel) SetText(text string) { l.inner.SetText(text) }
	354	+	func (l *gtkLabel) GetText() string { return l.inner.GetText() }
	355	+	func (l *gtkLabel) SetMarkup(markup string) { l.inner.SetMarkup(markup) }
	356	+	func (l *gtkLabel) SetEllipsize(mode EllipsizeMode) { l.inner.SetEllipsize(pango.EllipsizeMode(mode)) }
	357	+	func (l *gtkLabel) SetMaxWidthChars(n int) { l.inner.SetMaxWidthChars(n) }
	358	+	func (l *gtkLabel) SetXalign(x float32) { l.inner.SetXalign(x) }
	359	+
	360	+	// gtkButton wraps gtk.Button to implement ButtonWidget.
	361	+	type gtkButton struct {
	362	+	inner *gtk.Button
	363	+	}
	364	+
	365	+	func (btn *gtkButton) Show() { btn.inner.Show() }
	366	+	func (btn *gtkButton) Hide() { btn.inner.Hide() }
	367	+	func (btn *gtkButton) SetVisible(visible bool) { btn.inner.SetVisible(visible) }
	368	+	func (btn *gtkButton) IsVisible() bool { return btn.inner.GetVisible() }
	369	+	func (btn *gtkButton) GrabFocus() bool { return btn.inner.GrabFocus() }
	370	+	func (btn *gtkButton) HasFocus() bool { return btn.inner.HasFocus() }
	371	+	func (btn *gtkButton) SetCanFocus(canFocus bool) { btn.inner.SetCanFocus(canFocus) }
	372	+	func (btn *gtkButton) SetFocusOnClick(focus bool) { btn.inner.SetFocusOnClick(focus) }
	373	+	func (btn *gtkButton) SetHexpand(expand bool) { btn.inner.SetHexpand(expand) }
	374	+	func (btn *gtkButton) SetVexpand(expand bool) { btn.inner.SetVexpand(expand) }
	375	+	func (btn *gtkButton) GetHexpand() bool { return btn.inner.GetHexpand() }
	376	+	func (btn *gtkButton) GetVexpand() bool { return btn.inner.GetVexpand() }
	377	+	func (btn *gtkButton) SetHalign(align gtk.Align) { btn.inner.SetHalign(align) }
	378	+	func (btn *gtkButton) SetValign(align gtk.Align) { btn.inner.SetValign(align) }
	379	+	func (btn *gtkButton) SetSizeRequest(w, h int) { btn.inner.SetSizeRequest(w, h) }
	380	+	func (btn *gtkButton) AddCssClass(class string) { btn.inner.AddCssClass(class) }
	381	+	func (btn *gtkButton) RemoveCssClass(class string) { btn.inner.RemoveCssClass(class) }
	382	+	func (btn *gtkButton) HasCssClass(class string) bool { return btn.inner.HasCssClass(class) }
	383	+	func (btn *gtkButton) Unparent() { btn.inner.Unparent() }
	384	+	func (btn gtkButton) GtkWidget() gtk.Widget { return &btn.inner.Widget }
	385	+
	386	+	func (btn *gtkButton) GetParent() Widget {
	387	+	parent := btn.inner.GetParent()
	388	+	if parent == nil {
	389	+	return nil
	390	+	}
	391	+	return &gtkWidget{inner: parent}
	392	+	}
	393	+
	394	+	func (btn *gtkButton) SetLabel(label string) { btn.inner.SetLabel(label) }
	395	+	func (btn *gtkButton) GetLabel() string { return btn.inner.GetLabel() }
	396	+
	397	+	func (btn *gtkButton) SetChild(child Widget) {
	398	+	if child == nil {
	399	+	btn.inner.SetChild(nil)
	400	+	return
	401	+	}
	402	+	btn.inner.SetChild(child.GtkWidget())
	403	+	}
	404	+
	405	+	func (btn *gtkButton) GetChild() Widget {
	406	+	child := btn.inner.GetChild()
	407	+	if child == nil {
	408	+	return nil
	409	+	}
	410	+	return &gtkWidget{inner: child}
	411	+	}
	412	+
	413	+	func (btn *gtkButton) ConnectClicked(callback func()) uint32 {
	414	+	cb := func(b gtk.Button) {
	415	+	callback()
	416	+	}
	417	+	return btn.inner.ConnectClicked(&cb)
	418	+	}
	419	+
	420	+	// gtkImage wraps gtk.Image to implement ImageWidget.
	421	+	type gtkImage struct {
	422	+	inner *gtk.Image
	423	+	}
	424	+
	425	+	func (img *gtkImage) Show() { img.inner.Show() }
	426	+	func (img *gtkImage) Hide() { img.inner.Hide() }
	427	+	func (img *gtkImage) SetVisible(visible bool) { img.inner.SetVisible(visible) }
	428	+	func (img *gtkImage) IsVisible() bool { return img.inner.GetVisible() }
	429	+	func (img *gtkImage) GrabFocus() bool { return img.inner.GrabFocus() }
	430	+	func (img *gtkImage) HasFocus() bool { return img.inner.HasFocus() }
	431	+	func (img *gtkImage) SetCanFocus(canFocus bool) { img.inner.SetCanFocus(canFocus) }
	432	+	func (img *gtkImage) SetFocusOnClick(focus bool) { img.inner.SetFocusOnClick(focus) }
	433	+	func (img *gtkImage) SetHexpand(expand bool) { img.inner.SetHexpand(expand) }
	434	+	func (img *gtkImage) SetVexpand(expand bool) { img.inner.SetVexpand(expand) }
	435	+	func (img *gtkImage) GetHexpand() bool { return img.inner.GetHexpand() }
	436	+	func (img *gtkImage) GetVexpand() bool { return img.inner.GetVexpand() }
	437	+	func (img *gtkImage) SetHalign(align gtk.Align) { img.inner.SetHalign(align) }
	438	+	func (img *gtkImage) SetValign(align gtk.Align) { img.inner.SetValign(align) }
	439	+	func (img *gtkImage) SetSizeRequest(w, h int) { img.inner.SetSizeRequest(w, h) }
	440	+	func (img *gtkImage) AddCssClass(class string) { img.inner.AddCssClass(class) }
	441	+	func (img *gtkImage) RemoveCssClass(class string) { img.inner.RemoveCssClass(class) }
	442	+	func (img *gtkImage) HasCssClass(class string) bool { return img.inner.HasCssClass(class) }
	443	+	func (img *gtkImage) Unparent() { img.inner.Unparent() }
	444	+	func (img gtkImage) GtkWidget() gtk.Widget { return &img.inner.Widget }
	445	+
	446	+	func (img *gtkImage) GetParent() Widget {
	447	+	parent := img.inner.GetParent()
	448	+	if parent == nil {
	449	+	return nil
	450	+	}
	451	+	return &gtkWidget{inner: parent}
	452	+	}
	453	+
	454	+	func (img *gtkImage) SetFromIconName(name string) { img.inner.SetFromIconName(name) }
	455	+	func (img *gtkImage) SetFromFile(filename string) { img.inner.SetFromFile(filename) }
	456	+	func (img *gtkImage) SetPixelSize(size int) { img.inner.SetPixelSize(size) }
	457	+	func (img *gtkImage) Clear() { img.inner.Clear() }
	458	+
	459	+	// GtkWidgetFactory creates real GTK widgets.
	460	+	type GtkWidgetFactory struct{}
	461	+
	462	+	// NewGtkWidgetFactory creates a new factory for real GTK widgets.
	463	+	func NewGtkWidgetFactory() *GtkWidgetFactory {
	464	+	return &GtkWidgetFactory{}
	465	+	}
	466	+
	467	+	func (f *GtkWidgetFactory) NewPaned(orientation Orientation) PanedWidget {
	468	+	paned := gtk.NewPaned(orientation)
	469	+	paned.SetHexpand(true)
	470	+	paned.SetVexpand(true)
	471	+	return &gtkPaned{inner: paned}
	472	+	}
	473	+
	474	+	func (f *GtkWidgetFactory) NewBox(orientation Orientation, spacing int) BoxWidget {
	475	+	box := gtk.NewBox(orientation, spacing)
	476	+	box.SetHexpand(true)
	477	+	box.SetVexpand(true)
	478	+	return &gtkBox{inner: box}
	479	+	}
	480	+
	481	+	func (f *GtkWidgetFactory) NewOverlay() OverlayWidget {
	482	+	overlay := gtk.NewOverlay()
	483	+	overlay.SetHexpand(true)
	484	+	overlay.SetVexpand(true)
	485	+	return &gtkOverlay{inner: overlay}
	486	+	}
	487	+
	488	+	func (f *GtkWidgetFactory) NewLabel(text string) LabelWidget {
	489	+	label := gtk.NewLabel(text)
	490	+	return &gtkLabel{inner: label}
	491	+	}
	492	+
	493	+	func (f *GtkWidgetFactory) NewButton() ButtonWidget {
	494	+	button := gtk.NewButton()
	495	+	return &gtkButton{inner: button}
	496	+	}
	497	+
	498	+	func (f *GtkWidgetFactory) NewImage() ImageWidget {
	499	+	image := gtk.NewImage()
	500	+	return &gtkImage{inner: image}
	501	+	}
	502	+
	503	+	func (f GtkWidgetFactory) WrapWidget(w gtk.Widget) Widget {
	504	+	if w == nil {
	505	+	return nil
	506	+	}
	507	+	return &gtkWidget{inner: w}
	508	+	}

A internal/ui/layout/mocks/mock_box_widget.go +1370 -0

@@ -0,0 +1,1370 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockBoxWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockBoxWidget {
	19	+	mock := &MockBoxWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockBoxWidget is an autogenerated mock type for the BoxWidget type
	28	+	type MockBoxWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockBoxWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockBoxWidget) EXPECT() MockBoxWidget_Expecter {
	37	+	return &MockBoxWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockBoxWidget
	41	+	func (_mock *MockBoxWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockBoxWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockBoxWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockBoxWidget_Expecter) AddCssClass(cssClass interface{}) MockBoxWidget_AddCssClass_Call {
	54	+	return &MockBoxWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockBoxWidget_AddCssClass_Call) Run(run func(cssClass string)) MockBoxWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockBoxWidget_AddCssClass_Call) Return() MockBoxWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockBoxWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockBoxWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// Append provides a mock function for the type MockBoxWidget
	81	+	func (_mock *MockBoxWidget) Append(child layout.Widget) {
	82	+	_mock.Called(child)
	83	+	return
	84	+	}
	85	+
	86	+	// MockBoxWidget_Append_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Append'
	87	+	type MockBoxWidget_Append_Call struct {
	88	+	*mock.Call
	89	+	}
	90	+
	91	+	// Append is a helper method to define mock.On call
	92	+	// - child layout.Widget
	93	+	func (_e MockBoxWidget_Expecter) Append(child interface{}) MockBoxWidget_Append_Call {
	94	+	return &MockBoxWidget_Append_Call{Call: _e.mock.On("Append", child)}
	95	+	}
	96	+
	97	+	func (_c MockBoxWidget_Append_Call) Run(run func(child layout.Widget)) MockBoxWidget_Append_Call {
	98	+	_c.Call.Run(func(args mock.Arguments) {
	99	+	var arg0 layout.Widget
	100	+	if args[0] != nil {
	101	+	arg0 = args[0].(layout.Widget)
	102	+	}
	103	+	run(
	104	+	arg0,
	105	+	)
	106	+	})
	107	+	return _c
	108	+	}
	109	+
	110	+	func (_c MockBoxWidget_Append_Call) Return() MockBoxWidget_Append_Call {
	111	+	_c.Call.Return()
	112	+	return _c
	113	+	}
	114	+
	115	+	func (_c MockBoxWidget_Append_Call) RunAndReturn(run func(child layout.Widget)) MockBoxWidget_Append_Call {
	116	+	_c.Run(run)
	117	+	return _c
	118	+	}
	119	+
	120	+	// GetHexpand provides a mock function for the type MockBoxWidget
	121	+	func (_mock *MockBoxWidget) GetHexpand() bool {
	122	+	ret := _mock.Called()
	123	+
	124	+	if len(ret) == 0 {
	125	+	panic("no return value specified for GetHexpand")
	126	+	}
	127	+
	128	+	var r0 bool
	129	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	130	+	r0 = returnFunc()
	131	+	} else {
	132	+	r0 = ret.Get(0).(bool)
	133	+	}
	134	+	return r0
	135	+	}
	136	+
	137	+	// MockBoxWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	138	+	type MockBoxWidget_GetHexpand_Call struct {
	139	+	*mock.Call
	140	+	}
	141	+
	142	+	// GetHexpand is a helper method to define mock.On call
	143	+	func (_e MockBoxWidget_Expecter) GetHexpand() MockBoxWidget_GetHexpand_Call {
	144	+	return &MockBoxWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	145	+	}
	146	+
	147	+	func (_c MockBoxWidget_GetHexpand_Call) Run(run func()) MockBoxWidget_GetHexpand_Call {
	148	+	_c.Call.Run(func(args mock.Arguments) {
	149	+	run()
	150	+	})
	151	+	return _c
	152	+	}
	153	+
	154	+	func (_c MockBoxWidget_GetHexpand_Call) Return(b bool) MockBoxWidget_GetHexpand_Call {
	155	+	_c.Call.Return(b)
	156	+	return _c
	157	+	}
	158	+
	159	+	func (_c MockBoxWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockBoxWidget_GetHexpand_Call {
	160	+	_c.Call.Return(run)
	161	+	return _c
	162	+	}
	163	+
	164	+	// GetHomogeneous provides a mock function for the type MockBoxWidget
	165	+	func (_mock *MockBoxWidget) GetHomogeneous() bool {
	166	+	ret := _mock.Called()
	167	+
	168	+	if len(ret) == 0 {
	169	+	panic("no return value specified for GetHomogeneous")
	170	+	}
	171	+
	172	+	var r0 bool
	173	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	174	+	r0 = returnFunc()
	175	+	} else {
	176	+	r0 = ret.Get(0).(bool)
	177	+	}
	178	+	return r0
	179	+	}
	180	+
	181	+	// MockBoxWidget_GetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomogeneous'
	182	+	type MockBoxWidget_GetHomogeneous_Call struct {
	183	+	*mock.Call
	184	+	}
	185	+
	186	+	// GetHomogeneous is a helper method to define mock.On call
	187	+	func (_e MockBoxWidget_Expecter) GetHomogeneous() MockBoxWidget_GetHomogeneous_Call {
	188	+	return &MockBoxWidget_GetHomogeneous_Call{Call: _e.mock.On("GetHomogeneous")}
	189	+	}
	190	+
	191	+	func (_c MockBoxWidget_GetHomogeneous_Call) Run(run func()) MockBoxWidget_GetHomogeneous_Call {
	192	+	_c.Call.Run(func(args mock.Arguments) {
	193	+	run()
	194	+	})
	195	+	return _c
	196	+	}
	197	+
	198	+	func (_c MockBoxWidget_GetHomogeneous_Call) Return(b bool) MockBoxWidget_GetHomogeneous_Call {
	199	+	_c.Call.Return(b)
	200	+	return _c
	201	+	}
	202	+
	203	+	func (_c MockBoxWidget_GetHomogeneous_Call) RunAndReturn(run func() bool) MockBoxWidget_GetHomogeneous_Call {
	204	+	_c.Call.Return(run)
	205	+	return _c
	206	+	}
	207	+
	208	+	// GetOrientation provides a mock function for the type MockBoxWidget
	209	+	func (_mock *MockBoxWidget) GetOrientation() layout.Orientation {
	210	+	ret := _mock.Called()
	211	+
	212	+	if len(ret) == 0 {
	213	+	panic("no return value specified for GetOrientation")
	214	+	}
	215	+
	216	+	var r0 layout.Orientation
	217	+	if returnFunc, ok := ret.Get(0).(func() layout.Orientation); ok {
	218	+	r0 = returnFunc()
	219	+	} else {
	220	+	r0 = ret.Get(0).(layout.Orientation)
	221	+	}
	222	+	return r0
	223	+	}
	224	+
	225	+	// MockBoxWidget_GetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrientation'
	226	+	type MockBoxWidget_GetOrientation_Call struct {
	227	+	*mock.Call
	228	+	}
	229	+
	230	+	// GetOrientation is a helper method to define mock.On call
	231	+	func (_e MockBoxWidget_Expecter) GetOrientation() MockBoxWidget_GetOrientation_Call {
	232	+	return &MockBoxWidget_GetOrientation_Call{Call: _e.mock.On("GetOrientation")}
	233	+	}
	234	+
	235	+	func (_c MockBoxWidget_GetOrientation_Call) Run(run func()) MockBoxWidget_GetOrientation_Call {
	236	+	_c.Call.Run(func(args mock.Arguments) {
	237	+	run()
	238	+	})
	239	+	return _c
	240	+	}
	241	+
	242	+	func (_c MockBoxWidget_GetOrientation_Call) Return(v layout.Orientation) MockBoxWidget_GetOrientation_Call {
	243	+	_c.Call.Return(v)
	244	+	return _c
	245	+	}
	246	+
	247	+	func (_c MockBoxWidget_GetOrientation_Call) RunAndReturn(run func() layout.Orientation) MockBoxWidget_GetOrientation_Call {
	248	+	_c.Call.Return(run)
	249	+	return _c
	250	+	}
	251	+
	252	+	// GetParent provides a mock function for the type MockBoxWidget
	253	+	func (_mock *MockBoxWidget) GetParent() layout.Widget {
	254	+	ret := _mock.Called()
	255	+
	256	+	if len(ret) == 0 {
	257	+	panic("no return value specified for GetParent")
	258	+	}
	259	+
	260	+	var r0 layout.Widget
	261	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	262	+	r0 = returnFunc()
	263	+	} else {
	264	+	if ret.Get(0) != nil {
	265	+	r0 = ret.Get(0).(layout.Widget)
	266	+	}
	267	+	}
	268	+	return r0
	269	+	}
	270	+
	271	+	// MockBoxWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	272	+	type MockBoxWidget_GetParent_Call struct {
	273	+	*mock.Call
	274	+	}
	275	+
	276	+	// GetParent is a helper method to define mock.On call
	277	+	func (_e MockBoxWidget_Expecter) GetParent() MockBoxWidget_GetParent_Call {
	278	+	return &MockBoxWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	279	+	}
	280	+
	281	+	func (_c MockBoxWidget_GetParent_Call) Run(run func()) MockBoxWidget_GetParent_Call {
	282	+	_c.Call.Run(func(args mock.Arguments) {
	283	+	run()
	284	+	})
	285	+	return _c
	286	+	}
	287	+
	288	+	func (_c MockBoxWidget_GetParent_Call) Return(widget layout.Widget) MockBoxWidget_GetParent_Call {
	289	+	_c.Call.Return(widget)
	290	+	return _c
	291	+	}
	292	+
	293	+	func (_c MockBoxWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockBoxWidget_GetParent_Call {
	294	+	_c.Call.Return(run)
	295	+	return _c
	296	+	}
	297	+
	298	+	// GetSpacing provides a mock function for the type MockBoxWidget
	299	+	func (_mock *MockBoxWidget) GetSpacing() int {
	300	+	ret := _mock.Called()
	301	+
	302	+	if len(ret) == 0 {
	303	+	panic("no return value specified for GetSpacing")
	304	+	}
	305	+
	306	+	var r0 int
	307	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	308	+	r0 = returnFunc()
	309	+	} else {
	310	+	r0 = ret.Get(0).(int)
	311	+	}
	312	+	return r0
	313	+	}
	314	+
	315	+	// MockBoxWidget_GetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpacing'
	316	+	type MockBoxWidget_GetSpacing_Call struct {
	317	+	*mock.Call
	318	+	}
	319	+
	320	+	// GetSpacing is a helper method to define mock.On call
	321	+	func (_e MockBoxWidget_Expecter) GetSpacing() MockBoxWidget_GetSpacing_Call {
	322	+	return &MockBoxWidget_GetSpacing_Call{Call: _e.mock.On("GetSpacing")}
	323	+	}
	324	+
	325	+	func (_c MockBoxWidget_GetSpacing_Call) Run(run func()) MockBoxWidget_GetSpacing_Call {
	326	+	_c.Call.Run(func(args mock.Arguments) {
	327	+	run()
	328	+	})
	329	+	return _c
	330	+	}
	331	+
	332	+	func (_c MockBoxWidget_GetSpacing_Call) Return(n int) MockBoxWidget_GetSpacing_Call {
	333	+	_c.Call.Return(n)
	334	+	return _c
	335	+	}
	336	+
	337	+	func (_c MockBoxWidget_GetSpacing_Call) RunAndReturn(run func() int) MockBoxWidget_GetSpacing_Call {
	338	+	_c.Call.Return(run)
	339	+	return _c
	340	+	}
	341	+
	342	+	// GetVexpand provides a mock function for the type MockBoxWidget
	343	+	func (_mock *MockBoxWidget) GetVexpand() bool {
	344	+	ret := _mock.Called()
	345	+
	346	+	if len(ret) == 0 {
	347	+	panic("no return value specified for GetVexpand")
	348	+	}
	349	+
	350	+	var r0 bool
	351	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	352	+	r0 = returnFunc()
	353	+	} else {
	354	+	r0 = ret.Get(0).(bool)
	355	+	}
	356	+	return r0
	357	+	}
	358	+
	359	+	// MockBoxWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	360	+	type MockBoxWidget_GetVexpand_Call struct {
	361	+	*mock.Call
	362	+	}
	363	+
	364	+	// GetVexpand is a helper method to define mock.On call
	365	+	func (_e MockBoxWidget_Expecter) GetVexpand() MockBoxWidget_GetVexpand_Call {
	366	+	return &MockBoxWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	367	+	}
	368	+
	369	+	func (_c MockBoxWidget_GetVexpand_Call) Run(run func()) MockBoxWidget_GetVexpand_Call {
	370	+	_c.Call.Run(func(args mock.Arguments) {
	371	+	run()
	372	+	})
	373	+	return _c
	374	+	}
	375	+
	376	+	func (_c MockBoxWidget_GetVexpand_Call) Return(b bool) MockBoxWidget_GetVexpand_Call {
	377	+	_c.Call.Return(b)
	378	+	return _c
	379	+	}
	380	+
	381	+	func (_c MockBoxWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockBoxWidget_GetVexpand_Call {
	382	+	_c.Call.Return(run)
	383	+	return _c
	384	+	}
	385	+
	386	+	// GrabFocus provides a mock function for the type MockBoxWidget
	387	+	func (_mock *MockBoxWidget) GrabFocus() bool {
	388	+	ret := _mock.Called()
	389	+
	390	+	if len(ret) == 0 {
	391	+	panic("no return value specified for GrabFocus")
	392	+	}
	393	+
	394	+	var r0 bool
	395	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	396	+	r0 = returnFunc()
	397	+	} else {
	398	+	r0 = ret.Get(0).(bool)
	399	+	}
	400	+	return r0
	401	+	}
	402	+
	403	+	// MockBoxWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	404	+	type MockBoxWidget_GrabFocus_Call struct {
	405	+	*mock.Call
	406	+	}
	407	+
	408	+	// GrabFocus is a helper method to define mock.On call
	409	+	func (_e MockBoxWidget_Expecter) GrabFocus() MockBoxWidget_GrabFocus_Call {
	410	+	return &MockBoxWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	411	+	}
	412	+
	413	+	func (_c MockBoxWidget_GrabFocus_Call) Run(run func()) MockBoxWidget_GrabFocus_Call {
	414	+	_c.Call.Run(func(args mock.Arguments) {
	415	+	run()
	416	+	})
	417	+	return _c
	418	+	}
	419	+
	420	+	func (_c MockBoxWidget_GrabFocus_Call) Return(b bool) MockBoxWidget_GrabFocus_Call {
	421	+	_c.Call.Return(b)
	422	+	return _c
	423	+	}
	424	+
	425	+	func (_c MockBoxWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockBoxWidget_GrabFocus_Call {
	426	+	_c.Call.Return(run)
	427	+	return _c
	428	+	}
	429	+
	430	+	// GtkWidget provides a mock function for the type MockBoxWidget
	431	+	func (_mock MockBoxWidget) GtkWidget() gtk.Widget {
	432	+	ret := _mock.Called()
	433	+
	434	+	if len(ret) == 0 {
	435	+	panic("no return value specified for GtkWidget")
	436	+	}
	437	+
	438	+	var r0 *gtk.Widget
	439	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	440	+	r0 = returnFunc()
	441	+	} else {
	442	+	if ret.Get(0) != nil {
	443	+	r0 = ret.Get(0).(*gtk.Widget)
	444	+	}
	445	+	}
	446	+	return r0
	447	+	}
	448	+
	449	+	// MockBoxWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	450	+	type MockBoxWidget_GtkWidget_Call struct {
	451	+	*mock.Call
	452	+	}
	453	+
	454	+	// GtkWidget is a helper method to define mock.On call
	455	+	func (_e MockBoxWidget_Expecter) GtkWidget() MockBoxWidget_GtkWidget_Call {
	456	+	return &MockBoxWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	457	+	}
	458	+
	459	+	func (_c MockBoxWidget_GtkWidget_Call) Run(run func()) MockBoxWidget_GtkWidget_Call {
	460	+	_c.Call.Run(func(args mock.Arguments) {
	461	+	run()
	462	+	})
	463	+	return _c
	464	+	}
	465	+
	466	+	func (_c MockBoxWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockBoxWidget_GtkWidget_Call {
	467	+	_c.Call.Return(widget)
	468	+	return _c
	469	+	}
	470	+
	471	+	func (_c MockBoxWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockBoxWidget_GtkWidget_Call {
	472	+	_c.Call.Return(run)
	473	+	return _c
	474	+	}
	475	+
	476	+	// HasCssClass provides a mock function for the type MockBoxWidget
	477	+	func (_mock *MockBoxWidget) HasCssClass(cssClass string) bool {
	478	+	ret := _mock.Called(cssClass)
	479	+
	480	+	if len(ret) == 0 {
	481	+	panic("no return value specified for HasCssClass")
	482	+	}
	483	+
	484	+	var r0 bool
	485	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	486	+	r0 = returnFunc(cssClass)
	487	+	} else {
	488	+	r0 = ret.Get(0).(bool)
	489	+	}
	490	+	return r0
	491	+	}
	492	+
	493	+	// MockBoxWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	494	+	type MockBoxWidget_HasCssClass_Call struct {
	495	+	*mock.Call
	496	+	}
	497	+
	498	+	// HasCssClass is a helper method to define mock.On call
	499	+	// - cssClass string
	500	+	func (_e MockBoxWidget_Expecter) HasCssClass(cssClass interface{}) MockBoxWidget_HasCssClass_Call {
	501	+	return &MockBoxWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	502	+	}
	503	+
	504	+	func (_c MockBoxWidget_HasCssClass_Call) Run(run func(cssClass string)) MockBoxWidget_HasCssClass_Call {
	505	+	_c.Call.Run(func(args mock.Arguments) {
	506	+	var arg0 string
	507	+	if args[0] != nil {
	508	+	arg0 = args[0].(string)
	509	+	}
	510	+	run(
	511	+	arg0,
	512	+	)
	513	+	})
	514	+	return _c
	515	+	}
	516	+
	517	+	func (_c MockBoxWidget_HasCssClass_Call) Return(b bool) MockBoxWidget_HasCssClass_Call {
	518	+	_c.Call.Return(b)
	519	+	return _c
	520	+	}
	521	+
	522	+	func (_c MockBoxWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockBoxWidget_HasCssClass_Call {
	523	+	_c.Call.Return(run)
	524	+	return _c
	525	+	}
	526	+
	527	+	// HasFocus provides a mock function for the type MockBoxWidget
	528	+	func (_mock *MockBoxWidget) HasFocus() bool {
	529	+	ret := _mock.Called()
	530	+
	531	+	if len(ret) == 0 {
	532	+	panic("no return value specified for HasFocus")
	533	+	}
	534	+
	535	+	var r0 bool
	536	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	537	+	r0 = returnFunc()
	538	+	} else {
	539	+	r0 = ret.Get(0).(bool)
	540	+	}
	541	+	return r0
	542	+	}
	543	+
	544	+	// MockBoxWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	545	+	type MockBoxWidget_HasFocus_Call struct {
	546	+	*mock.Call
	547	+	}
	548	+
	549	+	// HasFocus is a helper method to define mock.On call
	550	+	func (_e MockBoxWidget_Expecter) HasFocus() MockBoxWidget_HasFocus_Call {
	551	+	return &MockBoxWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	552	+	}
	553	+
	554	+	func (_c MockBoxWidget_HasFocus_Call) Run(run func()) MockBoxWidget_HasFocus_Call {
	555	+	_c.Call.Run(func(args mock.Arguments) {
	556	+	run()
	557	+	})
	558	+	return _c
	559	+	}
	560	+
	561	+	func (_c MockBoxWidget_HasFocus_Call) Return(b bool) MockBoxWidget_HasFocus_Call {
	562	+	_c.Call.Return(b)
	563	+	return _c
	564	+	}
	565	+
	566	+	func (_c MockBoxWidget_HasFocus_Call) RunAndReturn(run func() bool) MockBoxWidget_HasFocus_Call {
	567	+	_c.Call.Return(run)
	568	+	return _c
	569	+	}
	570	+
	571	+	// Hide provides a mock function for the type MockBoxWidget
	572	+	func (_mock *MockBoxWidget) Hide() {
	573	+	_mock.Called()
	574	+	return
	575	+	}
	576	+
	577	+	// MockBoxWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	578	+	type MockBoxWidget_Hide_Call struct {
	579	+	*mock.Call
	580	+	}
	581	+
	582	+	// Hide is a helper method to define mock.On call
	583	+	func (_e MockBoxWidget_Expecter) Hide() MockBoxWidget_Hide_Call {
	584	+	return &MockBoxWidget_Hide_Call{Call: _e.mock.On("Hide")}
	585	+	}
	586	+
	587	+	func (_c MockBoxWidget_Hide_Call) Run(run func()) MockBoxWidget_Hide_Call {
	588	+	_c.Call.Run(func(args mock.Arguments) {
	589	+	run()
	590	+	})
	591	+	return _c
	592	+	}
	593	+
	594	+	func (_c MockBoxWidget_Hide_Call) Return() MockBoxWidget_Hide_Call {
	595	+	_c.Call.Return()
	596	+	return _c
	597	+	}
	598	+
	599	+	func (_c MockBoxWidget_Hide_Call) RunAndReturn(run func()) MockBoxWidget_Hide_Call {
	600	+	_c.Run(run)
	601	+	return _c
	602	+	}
	603	+
	604	+	// InsertChildAfter provides a mock function for the type MockBoxWidget
	605	+	func (_mock *MockBoxWidget) InsertChildAfter(child layout.Widget, sibling layout.Widget) {
	606	+	_mock.Called(child, sibling)
	607	+	return
	608	+	}
	609	+
	610	+	// MockBoxWidget_InsertChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertChildAfter'
	611	+	type MockBoxWidget_InsertChildAfter_Call struct {
	612	+	*mock.Call
	613	+	}
	614	+
	615	+	// InsertChildAfter is a helper method to define mock.On call
	616	+	// - child layout.Widget
	617	+	// - sibling layout.Widget
	618	+	func (_e MockBoxWidget_Expecter) InsertChildAfter(child interface{}, sibling interface{}) MockBoxWidget_InsertChildAfter_Call {
	619	+	return &MockBoxWidget_InsertChildAfter_Call{Call: _e.mock.On("InsertChildAfter", child, sibling)}
	620	+	}
	621	+
	622	+	func (_c MockBoxWidget_InsertChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) MockBoxWidget_InsertChildAfter_Call {
	623	+	_c.Call.Run(func(args mock.Arguments) {
	624	+	var arg0 layout.Widget
	625	+	if args[0] != nil {
	626	+	arg0 = args[0].(layout.Widget)
	627	+	}
	628	+	var arg1 layout.Widget
	629	+	if args[1] != nil {
	630	+	arg1 = args[1].(layout.Widget)
	631	+	}
	632	+	run(
	633	+	arg0,
	634	+	arg1,
	635	+	)
	636	+	})
	637	+	return _c
	638	+	}
	639	+
	640	+	func (_c MockBoxWidget_InsertChildAfter_Call) Return() MockBoxWidget_InsertChildAfter_Call {
	641	+	_c.Call.Return()
	642	+	return _c
	643	+	}
	644	+
	645	+	func (_c MockBoxWidget_InsertChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) MockBoxWidget_InsertChildAfter_Call {
	646	+	_c.Run(run)
	647	+	return _c
	648	+	}
	649	+
	650	+	// IsVisible provides a mock function for the type MockBoxWidget
	651	+	func (_mock *MockBoxWidget) IsVisible() bool {
	652	+	ret := _mock.Called()
	653	+
	654	+	if len(ret) == 0 {
	655	+	panic("no return value specified for IsVisible")
	656	+	}
	657	+
	658	+	var r0 bool
	659	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	660	+	r0 = returnFunc()
	661	+	} else {
	662	+	r0 = ret.Get(0).(bool)
	663	+	}
	664	+	return r0
	665	+	}
	666	+
	667	+	// MockBoxWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	668	+	type MockBoxWidget_IsVisible_Call struct {
	669	+	*mock.Call
	670	+	}
	671	+
	672	+	// IsVisible is a helper method to define mock.On call
	673	+	func (_e MockBoxWidget_Expecter) IsVisible() MockBoxWidget_IsVisible_Call {
	674	+	return &MockBoxWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	675	+	}
	676	+
	677	+	func (_c MockBoxWidget_IsVisible_Call) Run(run func()) MockBoxWidget_IsVisible_Call {
	678	+	_c.Call.Run(func(args mock.Arguments) {
	679	+	run()
	680	+	})
	681	+	return _c
	682	+	}
	683	+
	684	+	func (_c MockBoxWidget_IsVisible_Call) Return(b bool) MockBoxWidget_IsVisible_Call {
	685	+	_c.Call.Return(b)
	686	+	return _c
	687	+	}
	688	+
	689	+	func (_c MockBoxWidget_IsVisible_Call) RunAndReturn(run func() bool) MockBoxWidget_IsVisible_Call {
	690	+	_c.Call.Return(run)
	691	+	return _c
	692	+	}
	693	+
	694	+	// Prepend provides a mock function for the type MockBoxWidget
	695	+	func (_mock *MockBoxWidget) Prepend(child layout.Widget) {
	696	+	_mock.Called(child)
	697	+	return
	698	+	}
	699	+
	700	+	// MockBoxWidget_Prepend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prepend'
	701	+	type MockBoxWidget_Prepend_Call struct {
	702	+	*mock.Call
	703	+	}
	704	+
	705	+	// Prepend is a helper method to define mock.On call
	706	+	// - child layout.Widget
	707	+	func (_e MockBoxWidget_Expecter) Prepend(child interface{}) MockBoxWidget_Prepend_Call {
	708	+	return &MockBoxWidget_Prepend_Call{Call: _e.mock.On("Prepend", child)}
	709	+	}
	710	+
	711	+	func (_c MockBoxWidget_Prepend_Call) Run(run func(child layout.Widget)) MockBoxWidget_Prepend_Call {
	712	+	_c.Call.Run(func(args mock.Arguments) {
	713	+	var arg0 layout.Widget
	714	+	if args[0] != nil {
	715	+	arg0 = args[0].(layout.Widget)
	716	+	}
	717	+	run(
	718	+	arg0,
	719	+	)
	720	+	})
	721	+	return _c
	722	+	}
	723	+
	724	+	func (_c MockBoxWidget_Prepend_Call) Return() MockBoxWidget_Prepend_Call {
	725	+	_c.Call.Return()
	726	+	return _c
	727	+	}
	728	+
	729	+	func (_c MockBoxWidget_Prepend_Call) RunAndReturn(run func(child layout.Widget)) MockBoxWidget_Prepend_Call {
	730	+	_c.Run(run)
	731	+	return _c
	732	+	}
	733	+
	734	+	// Remove provides a mock function for the type MockBoxWidget
	735	+	func (_mock *MockBoxWidget) Remove(child layout.Widget) {
	736	+	_mock.Called(child)
	737	+	return
	738	+	}
	739	+
	740	+	// MockBoxWidget_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
	741	+	type MockBoxWidget_Remove_Call struct {
	742	+	*mock.Call
	743	+	}
	744	+
	745	+	// Remove is a helper method to define mock.On call
	746	+	// - child layout.Widget
	747	+	func (_e MockBoxWidget_Expecter) Remove(child interface{}) MockBoxWidget_Remove_Call {
	748	+	return &MockBoxWidget_Remove_Call{Call: _e.mock.On("Remove", child)}
	749	+	}
	750	+
	751	+	func (_c MockBoxWidget_Remove_Call) Run(run func(child layout.Widget)) MockBoxWidget_Remove_Call {
	752	+	_c.Call.Run(func(args mock.Arguments) {
	753	+	var arg0 layout.Widget
	754	+	if args[0] != nil {
	755	+	arg0 = args[0].(layout.Widget)
	756	+	}
	757	+	run(
	758	+	arg0,
	759	+	)
	760	+	})
	761	+	return _c
	762	+	}
	763	+
	764	+	func (_c MockBoxWidget_Remove_Call) Return() MockBoxWidget_Remove_Call {
	765	+	_c.Call.Return()
	766	+	return _c
	767	+	}
	768	+
	769	+	func (_c MockBoxWidget_Remove_Call) RunAndReturn(run func(child layout.Widget)) MockBoxWidget_Remove_Call {
	770	+	_c.Run(run)
	771	+	return _c
	772	+	}
	773	+
	774	+	// RemoveCssClass provides a mock function for the type MockBoxWidget
	775	+	func (_mock *MockBoxWidget) RemoveCssClass(cssClass string) {
	776	+	_mock.Called(cssClass)
	777	+	return
	778	+	}
	779	+
	780	+	// MockBoxWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	781	+	type MockBoxWidget_RemoveCssClass_Call struct {
	782	+	*mock.Call
	783	+	}
	784	+
	785	+	// RemoveCssClass is a helper method to define mock.On call
	786	+	// - cssClass string
	787	+	func (_e MockBoxWidget_Expecter) RemoveCssClass(cssClass interface{}) MockBoxWidget_RemoveCssClass_Call {
	788	+	return &MockBoxWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	789	+	}
	790	+
	791	+	func (_c MockBoxWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockBoxWidget_RemoveCssClass_Call {
	792	+	_c.Call.Run(func(args mock.Arguments) {
	793	+	var arg0 string
	794	+	if args[0] != nil {
	795	+	arg0 = args[0].(string)
	796	+	}
	797	+	run(
	798	+	arg0,
	799	+	)
	800	+	})
	801	+	return _c
	802	+	}
	803	+
	804	+	func (_c MockBoxWidget_RemoveCssClass_Call) Return() MockBoxWidget_RemoveCssClass_Call {
	805	+	_c.Call.Return()
	806	+	return _c
	807	+	}
	808	+
	809	+	func (_c MockBoxWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockBoxWidget_RemoveCssClass_Call {
	810	+	_c.Run(run)
	811	+	return _c
	812	+	}
	813	+
	814	+	// ReorderChildAfter provides a mock function for the type MockBoxWidget
	815	+	func (_mock *MockBoxWidget) ReorderChildAfter(child layout.Widget, sibling layout.Widget) {
	816	+	_mock.Called(child, sibling)
	817	+	return
	818	+	}
	819	+
	820	+	// MockBoxWidget_ReorderChildAfter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReorderChildAfter'
	821	+	type MockBoxWidget_ReorderChildAfter_Call struct {
	822	+	*mock.Call
	823	+	}
	824	+
	825	+	// ReorderChildAfter is a helper method to define mock.On call
	826	+	// - child layout.Widget
	827	+	// - sibling layout.Widget
	828	+	func (_e MockBoxWidget_Expecter) ReorderChildAfter(child interface{}, sibling interface{}) MockBoxWidget_ReorderChildAfter_Call {
	829	+	return &MockBoxWidget_ReorderChildAfter_Call{Call: _e.mock.On("ReorderChildAfter", child, sibling)}
	830	+	}
	831	+
	832	+	func (_c MockBoxWidget_ReorderChildAfter_Call) Run(run func(child layout.Widget, sibling layout.Widget)) MockBoxWidget_ReorderChildAfter_Call {
	833	+	_c.Call.Run(func(args mock.Arguments) {
	834	+	var arg0 layout.Widget
	835	+	if args[0] != nil {
	836	+	arg0 = args[0].(layout.Widget)
	837	+	}
	838	+	var arg1 layout.Widget
	839	+	if args[1] != nil {
	840	+	arg1 = args[1].(layout.Widget)
	841	+	}
	842	+	run(
	843	+	arg0,
	844	+	arg1,
	845	+	)
	846	+	})
	847	+	return _c
	848	+	}
	849	+
	850	+	func (_c MockBoxWidget_ReorderChildAfter_Call) Return() MockBoxWidget_ReorderChildAfter_Call {
	851	+	_c.Call.Return()
	852	+	return _c
	853	+	}
	854	+
	855	+	func (_c MockBoxWidget_ReorderChildAfter_Call) RunAndReturn(run func(child layout.Widget, sibling layout.Widget)) MockBoxWidget_ReorderChildAfter_Call {
	856	+	_c.Run(run)
	857	+	return _c
	858	+	}
	859	+
	860	+	// SetCanFocus provides a mock function for the type MockBoxWidget
	861	+	func (_mock *MockBoxWidget) SetCanFocus(canFocus bool) {
	862	+	_mock.Called(canFocus)
	863	+	return
	864	+	}
	865	+
	866	+	// MockBoxWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	867	+	type MockBoxWidget_SetCanFocus_Call struct {
	868	+	*mock.Call
	869	+	}
	870	+
	871	+	// SetCanFocus is a helper method to define mock.On call
	872	+	// - canFocus bool
	873	+	func (_e MockBoxWidget_Expecter) SetCanFocus(canFocus interface{}) MockBoxWidget_SetCanFocus_Call {
	874	+	return &MockBoxWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	875	+	}
	876	+
	877	+	func (_c MockBoxWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockBoxWidget_SetCanFocus_Call {
	878	+	_c.Call.Run(func(args mock.Arguments) {
	879	+	var arg0 bool
	880	+	if args[0] != nil {
	881	+	arg0 = args[0].(bool)
	882	+	}
	883	+	run(
	884	+	arg0,
	885	+	)
	886	+	})
	887	+	return _c
	888	+	}
	889	+
	890	+	func (_c MockBoxWidget_SetCanFocus_Call) Return() MockBoxWidget_SetCanFocus_Call {
	891	+	_c.Call.Return()
	892	+	return _c
	893	+	}
	894	+
	895	+	func (_c MockBoxWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockBoxWidget_SetCanFocus_Call {
	896	+	_c.Run(run)
	897	+	return _c
	898	+	}
	899	+
	900	+	// SetFocusOnClick provides a mock function for the type MockBoxWidget
	901	+	func (_mock *MockBoxWidget) SetFocusOnClick(focusOnClick bool) {
	902	+	_mock.Called(focusOnClick)
	903	+	return
	904	+	}
	905	+
	906	+	// MockBoxWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	907	+	type MockBoxWidget_SetFocusOnClick_Call struct {
	908	+	*mock.Call
	909	+	}
	910	+
	911	+	// SetFocusOnClick is a helper method to define mock.On call
	912	+	// - focusOnClick bool
	913	+	func (_e MockBoxWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockBoxWidget_SetFocusOnClick_Call {
	914	+	return &MockBoxWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	915	+	}
	916	+
	917	+	func (_c MockBoxWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockBoxWidget_SetFocusOnClick_Call {
	918	+	_c.Call.Run(func(args mock.Arguments) {
	919	+	var arg0 bool
	920	+	if args[0] != nil {
	921	+	arg0 = args[0].(bool)
	922	+	}
	923	+	run(
	924	+	arg0,
	925	+	)
	926	+	})
	927	+	return _c
	928	+	}
	929	+
	930	+	func (_c MockBoxWidget_SetFocusOnClick_Call) Return() MockBoxWidget_SetFocusOnClick_Call {
	931	+	_c.Call.Return()
	932	+	return _c
	933	+	}
	934	+
	935	+	func (_c MockBoxWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockBoxWidget_SetFocusOnClick_Call {
	936	+	_c.Run(run)
	937	+	return _c
	938	+	}
	939	+
	940	+	// SetHalign provides a mock function for the type MockBoxWidget
	941	+	func (_mock *MockBoxWidget) SetHalign(align gtk.Align) {
	942	+	_mock.Called(align)
	943	+	return
	944	+	}
	945	+
	946	+	// MockBoxWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	947	+	type MockBoxWidget_SetHalign_Call struct {
	948	+	*mock.Call
	949	+	}
	950	+
	951	+	// SetHalign is a helper method to define mock.On call
	952	+	// - align gtk.Align
	953	+	func (_e MockBoxWidget_Expecter) SetHalign(align interface{}) MockBoxWidget_SetHalign_Call {
	954	+	return &MockBoxWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	955	+	}
	956	+
	957	+	func (_c MockBoxWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockBoxWidget_SetHalign_Call {
	958	+	_c.Call.Run(func(args mock.Arguments) {
	959	+	var arg0 gtk.Align
	960	+	if args[0] != nil {
	961	+	arg0 = args[0].(gtk.Align)
	962	+	}
	963	+	run(
	964	+	arg0,
	965	+	)
	966	+	})
	967	+	return _c
	968	+	}
	969	+
	970	+	func (_c MockBoxWidget_SetHalign_Call) Return() MockBoxWidget_SetHalign_Call {
	971	+	_c.Call.Return()
	972	+	return _c
	973	+	}
	974	+
	975	+	func (_c MockBoxWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockBoxWidget_SetHalign_Call {
	976	+	_c.Run(run)
	977	+	return _c
	978	+	}
	979	+
	980	+	// SetHexpand provides a mock function for the type MockBoxWidget
	981	+	func (_mock *MockBoxWidget) SetHexpand(expand bool) {
	982	+	_mock.Called(expand)
	983	+	return
	984	+	}
	985	+
	986	+	// MockBoxWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	987	+	type MockBoxWidget_SetHexpand_Call struct {
	988	+	*mock.Call
	989	+	}
	990	+
	991	+	// SetHexpand is a helper method to define mock.On call
	992	+	// - expand bool
	993	+	func (_e MockBoxWidget_Expecter) SetHexpand(expand interface{}) MockBoxWidget_SetHexpand_Call {
	994	+	return &MockBoxWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	995	+	}
	996	+
	997	+	func (_c MockBoxWidget_SetHexpand_Call) Run(run func(expand bool)) MockBoxWidget_SetHexpand_Call {
	998	+	_c.Call.Run(func(args mock.Arguments) {
	999	+	var arg0 bool
	1000	+	if args[0] != nil {
	1001	+	arg0 = args[0].(bool)
	1002	+	}
	1003	+	run(
	1004	+	arg0,
	1005	+	)
	1006	+	})
	1007	+	return _c
	1008	+	}
	1009	+
	1010	+	func (_c MockBoxWidget_SetHexpand_Call) Return() MockBoxWidget_SetHexpand_Call {
	1011	+	_c.Call.Return()
	1012	+	return _c
	1013	+	}
	1014	+
	1015	+	func (_c MockBoxWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockBoxWidget_SetHexpand_Call {
	1016	+	_c.Run(run)
	1017	+	return _c
	1018	+	}
	1019	+
	1020	+	// SetHomogeneous provides a mock function for the type MockBoxWidget
	1021	+	func (_mock *MockBoxWidget) SetHomogeneous(homogeneous bool) {
	1022	+	_mock.Called(homogeneous)
	1023	+	return
	1024	+	}
	1025	+
	1026	+	// MockBoxWidget_SetHomogeneous_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHomogeneous'
	1027	+	type MockBoxWidget_SetHomogeneous_Call struct {
	1028	+	*mock.Call
	1029	+	}
	1030	+
	1031	+	// SetHomogeneous is a helper method to define mock.On call
	1032	+	// - homogeneous bool
	1033	+	func (_e MockBoxWidget_Expecter) SetHomogeneous(homogeneous interface{}) MockBoxWidget_SetHomogeneous_Call {
	1034	+	return &MockBoxWidget_SetHomogeneous_Call{Call: _e.mock.On("SetHomogeneous", homogeneous)}
	1035	+	}
	1036	+
	1037	+	func (_c MockBoxWidget_SetHomogeneous_Call) Run(run func(homogeneous bool)) MockBoxWidget_SetHomogeneous_Call {
	1038	+	_c.Call.Run(func(args mock.Arguments) {
	1039	+	var arg0 bool
	1040	+	if args[0] != nil {
	1041	+	arg0 = args[0].(bool)
	1042	+	}
	1043	+	run(
	1044	+	arg0,
	1045	+	)
	1046	+	})
	1047	+	return _c
	1048	+	}
	1049	+
	1050	+	func (_c MockBoxWidget_SetHomogeneous_Call) Return() MockBoxWidget_SetHomogeneous_Call {
	1051	+	_c.Call.Return()
	1052	+	return _c
	1053	+	}
	1054	+
	1055	+	func (_c MockBoxWidget_SetHomogeneous_Call) RunAndReturn(run func(homogeneous bool)) MockBoxWidget_SetHomogeneous_Call {
	1056	+	_c.Run(run)
	1057	+	return _c
	1058	+	}
	1059	+
	1060	+	// SetOrientation provides a mock function for the type MockBoxWidget
	1061	+	func (_mock *MockBoxWidget) SetOrientation(orientation layout.Orientation) {
	1062	+	_mock.Called(orientation)
	1063	+	return
	1064	+	}
	1065	+
	1066	+	// MockBoxWidget_SetOrientation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOrientation'
	1067	+	type MockBoxWidget_SetOrientation_Call struct {
	1068	+	*mock.Call
	1069	+	}
	1070	+
	1071	+	// SetOrientation is a helper method to define mock.On call
	1072	+	// - orientation layout.Orientation
	1073	+	func (_e MockBoxWidget_Expecter) SetOrientation(orientation interface{}) MockBoxWidget_SetOrientation_Call {
	1074	+	return &MockBoxWidget_SetOrientation_Call{Call: _e.mock.On("SetOrientation", orientation)}
	1075	+	}
	1076	+
	1077	+	func (_c MockBoxWidget_SetOrientation_Call) Run(run func(orientation layout.Orientation)) MockBoxWidget_SetOrientation_Call {
	1078	+	_c.Call.Run(func(args mock.Arguments) {
	1079	+	var arg0 layout.Orientation
	1080	+	if args[0] != nil {
	1081	+	arg0 = args[0].(layout.Orientation)
	1082	+	}
	1083	+	run(
	1084	+	arg0,
	1085	+	)
	1086	+	})
	1087	+	return _c
	1088	+	}
	1089	+
	1090	+	func (_c MockBoxWidget_SetOrientation_Call) Return() MockBoxWidget_SetOrientation_Call {
	1091	+	_c.Call.Return()
	1092	+	return _c
	1093	+	}
	1094	+
	1095	+	func (_c MockBoxWidget_SetOrientation_Call) RunAndReturn(run func(orientation layout.Orientation)) MockBoxWidget_SetOrientation_Call {
	1096	+	_c.Run(run)
	1097	+	return _c
	1098	+	}
	1099	+
	1100	+	// SetSizeRequest provides a mock function for the type MockBoxWidget
	1101	+	func (_mock *MockBoxWidget) SetSizeRequest(width int, height int) {
	1102	+	_mock.Called(width, height)
	1103	+	return
	1104	+	}
	1105	+
	1106	+	// MockBoxWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	1107	+	type MockBoxWidget_SetSizeRequest_Call struct {
	1108	+	*mock.Call
	1109	+	}
	1110	+
	1111	+	// SetSizeRequest is a helper method to define mock.On call
	1112	+	// - width int
	1113	+	// - height int
	1114	+	func (_e MockBoxWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockBoxWidget_SetSizeRequest_Call {
	1115	+	return &MockBoxWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	1116	+	}
	1117	+
	1118	+	func (_c MockBoxWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockBoxWidget_SetSizeRequest_Call {
	1119	+	_c.Call.Run(func(args mock.Arguments) {
	1120	+	var arg0 int
	1121	+	if args[0] != nil {
	1122	+	arg0 = args[0].(int)
	1123	+	}
	1124	+	var arg1 int
	1125	+	if args[1] != nil {
	1126	+	arg1 = args[1].(int)
	1127	+	}
	1128	+	run(
	1129	+	arg0,
	1130	+	arg1,
	1131	+	)
	1132	+	})
	1133	+	return _c
	1134	+	}
	1135	+
	1136	+	func (_c MockBoxWidget_SetSizeRequest_Call) Return() MockBoxWidget_SetSizeRequest_Call {
	1137	+	_c.Call.Return()
	1138	+	return _c
	1139	+	}
	1140	+
	1141	+	func (_c MockBoxWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockBoxWidget_SetSizeRequest_Call {
	1142	+	_c.Run(run)
	1143	+	return _c
	1144	+	}
	1145	+
	1146	+	// SetSpacing provides a mock function for the type MockBoxWidget
	1147	+	func (_mock *MockBoxWidget) SetSpacing(spacing int) {
	1148	+	_mock.Called(spacing)
	1149	+	return
	1150	+	}
	1151	+
	1152	+	// MockBoxWidget_SetSpacing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpacing'
	1153	+	type MockBoxWidget_SetSpacing_Call struct {
	1154	+	*mock.Call
	1155	+	}
	1156	+
	1157	+	// SetSpacing is a helper method to define mock.On call
	1158	+	// - spacing int
	1159	+	func (_e MockBoxWidget_Expecter) SetSpacing(spacing interface{}) MockBoxWidget_SetSpacing_Call {
	1160	+	return &MockBoxWidget_SetSpacing_Call{Call: _e.mock.On("SetSpacing", spacing)}
	1161	+	}
	1162	+
	1163	+	func (_c MockBoxWidget_SetSpacing_Call) Run(run func(spacing int)) MockBoxWidget_SetSpacing_Call {
	1164	+	_c.Call.Run(func(args mock.Arguments) {
	1165	+	var arg0 int
	1166	+	if args[0] != nil {
	1167	+	arg0 = args[0].(int)
	1168	+	}
	1169	+	run(
	1170	+	arg0,
	1171	+	)
	1172	+	})
	1173	+	return _c
	1174	+	}
	1175	+
	1176	+	func (_c MockBoxWidget_SetSpacing_Call) Return() MockBoxWidget_SetSpacing_Call {
	1177	+	_c.Call.Return()
	1178	+	return _c
	1179	+	}
	1180	+
	1181	+	func (_c MockBoxWidget_SetSpacing_Call) RunAndReturn(run func(spacing int)) MockBoxWidget_SetSpacing_Call {
	1182	+	_c.Run(run)
	1183	+	return _c
	1184	+	}
	1185	+
	1186	+	// SetValign provides a mock function for the type MockBoxWidget
	1187	+	func (_mock *MockBoxWidget) SetValign(align gtk.Align) {
	1188	+	_mock.Called(align)
	1189	+	return
	1190	+	}
	1191	+
	1192	+	// MockBoxWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	1193	+	type MockBoxWidget_SetValign_Call struct {
	1194	+	*mock.Call
	1195	+	}
	1196	+
	1197	+	// SetValign is a helper method to define mock.On call
	1198	+	// - align gtk.Align
	1199	+	func (_e MockBoxWidget_Expecter) SetValign(align interface{}) MockBoxWidget_SetValign_Call {
	1200	+	return &MockBoxWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	1201	+	}
	1202	+
	1203	+	func (_c MockBoxWidget_SetValign_Call) Run(run func(align gtk.Align)) MockBoxWidget_SetValign_Call {
	1204	+	_c.Call.Run(func(args mock.Arguments) {
	1205	+	var arg0 gtk.Align
	1206	+	if args[0] != nil {
	1207	+	arg0 = args[0].(gtk.Align)
	1208	+	}
	1209	+	run(
	1210	+	arg0,
	1211	+	)
	1212	+	})
	1213	+	return _c
	1214	+	}
	1215	+
	1216	+	func (_c MockBoxWidget_SetValign_Call) Return() MockBoxWidget_SetValign_Call {
	1217	+	_c.Call.Return()
	1218	+	return _c
	1219	+	}
	1220	+
	1221	+	func (_c MockBoxWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockBoxWidget_SetValign_Call {
	1222	+	_c.Run(run)
	1223	+	return _c
	1224	+	}
	1225	+
	1226	+	// SetVexpand provides a mock function for the type MockBoxWidget
	1227	+	func (_mock *MockBoxWidget) SetVexpand(expand bool) {
	1228	+	_mock.Called(expand)
	1229	+	return
	1230	+	}
	1231	+
	1232	+	// MockBoxWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	1233	+	type MockBoxWidget_SetVexpand_Call struct {
	1234	+	*mock.Call
	1235	+	}
	1236	+
	1237	+	// SetVexpand is a helper method to define mock.On call
	1238	+	// - expand bool
	1239	+	func (_e MockBoxWidget_Expecter) SetVexpand(expand interface{}) MockBoxWidget_SetVexpand_Call {
	1240	+	return &MockBoxWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	1241	+	}
	1242	+
	1243	+	func (_c MockBoxWidget_SetVexpand_Call) Run(run func(expand bool)) MockBoxWidget_SetVexpand_Call {
	1244	+	_c.Call.Run(func(args mock.Arguments) {
	1245	+	var arg0 bool
	1246	+	if args[0] != nil {
	1247	+	arg0 = args[0].(bool)
	1248	+	}
	1249	+	run(
	1250	+	arg0,
	1251	+	)
	1252	+	})
	1253	+	return _c
	1254	+	}
	1255	+
	1256	+	func (_c MockBoxWidget_SetVexpand_Call) Return() MockBoxWidget_SetVexpand_Call {
	1257	+	_c.Call.Return()
	1258	+	return _c
	1259	+	}
	1260	+
	1261	+	func (_c MockBoxWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockBoxWidget_SetVexpand_Call {
	1262	+	_c.Run(run)
	1263	+	return _c
	1264	+	}
	1265	+
	1266	+	// SetVisible provides a mock function for the type MockBoxWidget
	1267	+	func (_mock *MockBoxWidget) SetVisible(visible bool) {
	1268	+	_mock.Called(visible)
	1269	+	return
	1270	+	}
	1271	+
	1272	+	// MockBoxWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	1273	+	type MockBoxWidget_SetVisible_Call struct {
	1274	+	*mock.Call
	1275	+	}
	1276	+
	1277	+	// SetVisible is a helper method to define mock.On call
	1278	+	// - visible bool
	1279	+	func (_e MockBoxWidget_Expecter) SetVisible(visible interface{}) MockBoxWidget_SetVisible_Call {
	1280	+	return &MockBoxWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	1281	+	}
	1282	+
	1283	+	func (_c MockBoxWidget_SetVisible_Call) Run(run func(visible bool)) MockBoxWidget_SetVisible_Call {
	1284	+	_c.Call.Run(func(args mock.Arguments) {
	1285	+	var arg0 bool
	1286	+	if args[0] != nil {
	1287	+	arg0 = args[0].(bool)
	1288	+	}
	1289	+	run(
	1290	+	arg0,
	1291	+	)
	1292	+	})
	1293	+	return _c
	1294	+	}
	1295	+
	1296	+	func (_c MockBoxWidget_SetVisible_Call) Return() MockBoxWidget_SetVisible_Call {
	1297	+	_c.Call.Return()
	1298	+	return _c
	1299	+	}
	1300	+
	1301	+	func (_c MockBoxWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockBoxWidget_SetVisible_Call {
	1302	+	_c.Run(run)
	1303	+	return _c
	1304	+	}
	1305	+
	1306	+	// Show provides a mock function for the type MockBoxWidget
	1307	+	func (_mock *MockBoxWidget) Show() {
	1308	+	_mock.Called()
	1309	+	return
	1310	+	}
	1311	+
	1312	+	// MockBoxWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	1313	+	type MockBoxWidget_Show_Call struct {
	1314	+	*mock.Call
	1315	+	}
	1316	+
	1317	+	// Show is a helper method to define mock.On call
	1318	+	func (_e MockBoxWidget_Expecter) Show() MockBoxWidget_Show_Call {
	1319	+	return &MockBoxWidget_Show_Call{Call: _e.mock.On("Show")}
	1320	+	}
	1321	+
	1322	+	func (_c MockBoxWidget_Show_Call) Run(run func()) MockBoxWidget_Show_Call {
	1323	+	_c.Call.Run(func(args mock.Arguments) {
	1324	+	run()
	1325	+	})
	1326	+	return _c
	1327	+	}
	1328	+
	1329	+	func (_c MockBoxWidget_Show_Call) Return() MockBoxWidget_Show_Call {
	1330	+	_c.Call.Return()
	1331	+	return _c
	1332	+	}
	1333	+
	1334	+	func (_c MockBoxWidget_Show_Call) RunAndReturn(run func()) MockBoxWidget_Show_Call {
	1335	+	_c.Run(run)
	1336	+	return _c
	1337	+	}
	1338	+
	1339	+	// Unparent provides a mock function for the type MockBoxWidget
	1340	+	func (_mock *MockBoxWidget) Unparent() {
	1341	+	_mock.Called()
	1342	+	return
	1343	+	}
	1344	+
	1345	+	// MockBoxWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	1346	+	type MockBoxWidget_Unparent_Call struct {
	1347	+	*mock.Call
	1348	+	}
	1349	+
	1350	+	// Unparent is a helper method to define mock.On call
	1351	+	func (_e MockBoxWidget_Expecter) Unparent() MockBoxWidget_Unparent_Call {
	1352	+	return &MockBoxWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	1353	+	}
	1354	+
	1355	+	func (_c MockBoxWidget_Unparent_Call) Run(run func()) MockBoxWidget_Unparent_Call {
	1356	+	_c.Call.Run(func(args mock.Arguments) {
	1357	+	run()
	1358	+	})
	1359	+	return _c
	1360	+	}
	1361	+
	1362	+	func (_c MockBoxWidget_Unparent_Call) Return() MockBoxWidget_Unparent_Call {
	1363	+	_c.Call.Return()
	1364	+	return _c
	1365	+	}
	1366	+
	1367	+	func (_c MockBoxWidget_Unparent_Call) RunAndReturn(run func()) MockBoxWidget_Unparent_Call {
	1368	+	_c.Run(run)
	1369	+	return _c
	1370	+	}

A internal/ui/layout/mocks/mock_button_widget.go +1127 -0

@@ -0,0 +1,1127 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockButtonWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockButtonWidget {
	19	+	mock := &MockButtonWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockButtonWidget is an autogenerated mock type for the ButtonWidget type
	28	+	type MockButtonWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockButtonWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockButtonWidget) EXPECT() MockButtonWidget_Expecter {
	37	+	return &MockButtonWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockButtonWidget
	41	+	func (_mock *MockButtonWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockButtonWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockButtonWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockButtonWidget_Expecter) AddCssClass(cssClass interface{}) MockButtonWidget_AddCssClass_Call {
	54	+	return &MockButtonWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockButtonWidget_AddCssClass_Call) Run(run func(cssClass string)) MockButtonWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockButtonWidget_AddCssClass_Call) Return() MockButtonWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockButtonWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockButtonWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// ConnectClicked provides a mock function for the type MockButtonWidget
	81	+	func (_mock *MockButtonWidget) ConnectClicked(callback func()) uint32 {
	82	+	ret := _mock.Called(callback)
	83	+
	84	+	if len(ret) == 0 {
	85	+	panic("no return value specified for ConnectClicked")
	86	+	}
	87	+
	88	+	var r0 uint32
	89	+	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
	90	+	r0 = returnFunc(callback)
	91	+	} else {
	92	+	r0 = ret.Get(0).(uint32)
	93	+	}
	94	+	return r0
	95	+	}
	96	+
	97	+	// MockButtonWidget_ConnectClicked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectClicked'
	98	+	type MockButtonWidget_ConnectClicked_Call struct {
	99	+	*mock.Call
	100	+	}
	101	+
	102	+	// ConnectClicked is a helper method to define mock.On call
	103	+	// - callback func()
	104	+	func (_e MockButtonWidget_Expecter) ConnectClicked(callback interface{}) MockButtonWidget_ConnectClicked_Call {
	105	+	return &MockButtonWidget_ConnectClicked_Call{Call: _e.mock.On("ConnectClicked", callback)}
	106	+	}
	107	+
	108	+	func (_c MockButtonWidget_ConnectClicked_Call) Run(run func(callback func())) MockButtonWidget_ConnectClicked_Call {
	109	+	_c.Call.Run(func(args mock.Arguments) {
	110	+	var arg0 func()
	111	+	if args[0] != nil {
	112	+	arg0 = args[0].(func())
	113	+	}
	114	+	run(
	115	+	arg0,
	116	+	)
	117	+	})
	118	+	return _c
	119	+	}
	120	+
	121	+	func (_c MockButtonWidget_ConnectClicked_Call) Return(v uint32) MockButtonWidget_ConnectClicked_Call {
	122	+	_c.Call.Return(v)
	123	+	return _c
	124	+	}
	125	+
	126	+	func (_c MockButtonWidget_ConnectClicked_Call) RunAndReturn(run func(callback func()) uint32) MockButtonWidget_ConnectClicked_Call {
	127	+	_c.Call.Return(run)
	128	+	return _c
	129	+	}
	130	+
	131	+	// GetChild provides a mock function for the type MockButtonWidget
	132	+	func (_mock *MockButtonWidget) GetChild() layout.Widget {
	133	+	ret := _mock.Called()
	134	+
	135	+	if len(ret) == 0 {
	136	+	panic("no return value specified for GetChild")
	137	+	}
	138	+
	139	+	var r0 layout.Widget
	140	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	141	+	r0 = returnFunc()
	142	+	} else {
	143	+	if ret.Get(0) != nil {
	144	+	r0 = ret.Get(0).(layout.Widget)
	145	+	}
	146	+	}
	147	+	return r0
	148	+	}
	149	+
	150	+	// MockButtonWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
	151	+	type MockButtonWidget_GetChild_Call struct {
	152	+	*mock.Call
	153	+	}
	154	+
	155	+	// GetChild is a helper method to define mock.On call
	156	+	func (_e MockButtonWidget_Expecter) GetChild() MockButtonWidget_GetChild_Call {
	157	+	return &MockButtonWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
	158	+	}
	159	+
	160	+	func (_c MockButtonWidget_GetChild_Call) Run(run func()) MockButtonWidget_GetChild_Call {
	161	+	_c.Call.Run(func(args mock.Arguments) {
	162	+	run()
	163	+	})
	164	+	return _c
	165	+	}
	166	+
	167	+	func (_c MockButtonWidget_GetChild_Call) Return(widget layout.Widget) MockButtonWidget_GetChild_Call {
	168	+	_c.Call.Return(widget)
	169	+	return _c
	170	+	}
	171	+
	172	+	func (_c MockButtonWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) MockButtonWidget_GetChild_Call {
	173	+	_c.Call.Return(run)
	174	+	return _c
	175	+	}
	176	+
	177	+	// GetHexpand provides a mock function for the type MockButtonWidget
	178	+	func (_mock *MockButtonWidget) GetHexpand() bool {
	179	+	ret := _mock.Called()
	180	+
	181	+	if len(ret) == 0 {
	182	+	panic("no return value specified for GetHexpand")
	183	+	}
	184	+
	185	+	var r0 bool
	186	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	187	+	r0 = returnFunc()
	188	+	} else {
	189	+	r0 = ret.Get(0).(bool)
	190	+	}
	191	+	return r0
	192	+	}
	193	+
	194	+	// MockButtonWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	195	+	type MockButtonWidget_GetHexpand_Call struct {
	196	+	*mock.Call
	197	+	}
	198	+
	199	+	// GetHexpand is a helper method to define mock.On call
	200	+	func (_e MockButtonWidget_Expecter) GetHexpand() MockButtonWidget_GetHexpand_Call {
	201	+	return &MockButtonWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	202	+	}
	203	+
	204	+	func (_c MockButtonWidget_GetHexpand_Call) Run(run func()) MockButtonWidget_GetHexpand_Call {
	205	+	_c.Call.Run(func(args mock.Arguments) {
	206	+	run()
	207	+	})
	208	+	return _c
	209	+	}
	210	+
	211	+	func (_c MockButtonWidget_GetHexpand_Call) Return(b bool) MockButtonWidget_GetHexpand_Call {
	212	+	_c.Call.Return(b)
	213	+	return _c
	214	+	}
	215	+
	216	+	func (_c MockButtonWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockButtonWidget_GetHexpand_Call {
	217	+	_c.Call.Return(run)
	218	+	return _c
	219	+	}
	220	+
	221	+	// GetLabel provides a mock function for the type MockButtonWidget
	222	+	func (_mock *MockButtonWidget) GetLabel() string {
	223	+	ret := _mock.Called()
	224	+
	225	+	if len(ret) == 0 {
	226	+	panic("no return value specified for GetLabel")
	227	+	}
	228	+
	229	+	var r0 string
	230	+	if returnFunc, ok := ret.Get(0).(func() string); ok {
	231	+	r0 = returnFunc()
	232	+	} else {
	233	+	r0 = ret.Get(0).(string)
	234	+	}
	235	+	return r0
	236	+	}
	237	+
	238	+	// MockButtonWidget_GetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabel'
	239	+	type MockButtonWidget_GetLabel_Call struct {
	240	+	*mock.Call
	241	+	}
	242	+
	243	+	// GetLabel is a helper method to define mock.On call
	244	+	func (_e MockButtonWidget_Expecter) GetLabel() MockButtonWidget_GetLabel_Call {
	245	+	return &MockButtonWidget_GetLabel_Call{Call: _e.mock.On("GetLabel")}
	246	+	}
	247	+
	248	+	func (_c MockButtonWidget_GetLabel_Call) Run(run func()) MockButtonWidget_GetLabel_Call {
	249	+	_c.Call.Run(func(args mock.Arguments) {
	250	+	run()
	251	+	})
	252	+	return _c
	253	+	}
	254	+
	255	+	func (_c MockButtonWidget_GetLabel_Call) Return(s string) MockButtonWidget_GetLabel_Call {
	256	+	_c.Call.Return(s)
	257	+	return _c
	258	+	}
	259	+
	260	+	func (_c MockButtonWidget_GetLabel_Call) RunAndReturn(run func() string) MockButtonWidget_GetLabel_Call {
	261	+	_c.Call.Return(run)
	262	+	return _c
	263	+	}
	264	+
	265	+	// GetParent provides a mock function for the type MockButtonWidget
	266	+	func (_mock *MockButtonWidget) GetParent() layout.Widget {
	267	+	ret := _mock.Called()
	268	+
	269	+	if len(ret) == 0 {
	270	+	panic("no return value specified for GetParent")
	271	+	}
	272	+
	273	+	var r0 layout.Widget
	274	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	275	+	r0 = returnFunc()
	276	+	} else {
	277	+	if ret.Get(0) != nil {
	278	+	r0 = ret.Get(0).(layout.Widget)
	279	+	}
	280	+	}
	281	+	return r0
	282	+	}
	283	+
	284	+	// MockButtonWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	285	+	type MockButtonWidget_GetParent_Call struct {
	286	+	*mock.Call
	287	+	}
	288	+
	289	+	// GetParent is a helper method to define mock.On call
	290	+	func (_e MockButtonWidget_Expecter) GetParent() MockButtonWidget_GetParent_Call {
	291	+	return &MockButtonWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	292	+	}
	293	+
	294	+	func (_c MockButtonWidget_GetParent_Call) Run(run func()) MockButtonWidget_GetParent_Call {
	295	+	_c.Call.Run(func(args mock.Arguments) {
	296	+	run()
	297	+	})
	298	+	return _c
	299	+	}
	300	+
	301	+	func (_c MockButtonWidget_GetParent_Call) Return(widget layout.Widget) MockButtonWidget_GetParent_Call {
	302	+	_c.Call.Return(widget)
	303	+	return _c
	304	+	}
	305	+
	306	+	func (_c MockButtonWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockButtonWidget_GetParent_Call {
	307	+	_c.Call.Return(run)
	308	+	return _c
	309	+	}
	310	+
	311	+	// GetVexpand provides a mock function for the type MockButtonWidget
	312	+	func (_mock *MockButtonWidget) GetVexpand() bool {
	313	+	ret := _mock.Called()
	314	+
	315	+	if len(ret) == 0 {
	316	+	panic("no return value specified for GetVexpand")
	317	+	}
	318	+
	319	+	var r0 bool
	320	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	321	+	r0 = returnFunc()
	322	+	} else {
	323	+	r0 = ret.Get(0).(bool)
	324	+	}
	325	+	return r0
	326	+	}
	327	+
	328	+	// MockButtonWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	329	+	type MockButtonWidget_GetVexpand_Call struct {
	330	+	*mock.Call
	331	+	}
	332	+
	333	+	// GetVexpand is a helper method to define mock.On call
	334	+	func (_e MockButtonWidget_Expecter) GetVexpand() MockButtonWidget_GetVexpand_Call {
	335	+	return &MockButtonWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	336	+	}
	337	+
	338	+	func (_c MockButtonWidget_GetVexpand_Call) Run(run func()) MockButtonWidget_GetVexpand_Call {
	339	+	_c.Call.Run(func(args mock.Arguments) {
	340	+	run()
	341	+	})
	342	+	return _c
	343	+	}
	344	+
	345	+	func (_c MockButtonWidget_GetVexpand_Call) Return(b bool) MockButtonWidget_GetVexpand_Call {
	346	+	_c.Call.Return(b)
	347	+	return _c
	348	+	}
	349	+
	350	+	func (_c MockButtonWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockButtonWidget_GetVexpand_Call {
	351	+	_c.Call.Return(run)
	352	+	return _c
	353	+	}
	354	+
	355	+	// GrabFocus provides a mock function for the type MockButtonWidget
	356	+	func (_mock *MockButtonWidget) GrabFocus() bool {
	357	+	ret := _mock.Called()
	358	+
	359	+	if len(ret) == 0 {
	360	+	panic("no return value specified for GrabFocus")
	361	+	}
	362	+
	363	+	var r0 bool
	364	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	365	+	r0 = returnFunc()
	366	+	} else {
	367	+	r0 = ret.Get(0).(bool)
	368	+	}
	369	+	return r0
	370	+	}
	371	+
	372	+	// MockButtonWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	373	+	type MockButtonWidget_GrabFocus_Call struct {
	374	+	*mock.Call
	375	+	}
	376	+
	377	+	// GrabFocus is a helper method to define mock.On call
	378	+	func (_e MockButtonWidget_Expecter) GrabFocus() MockButtonWidget_GrabFocus_Call {
	379	+	return &MockButtonWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	380	+	}
	381	+
	382	+	func (_c MockButtonWidget_GrabFocus_Call) Run(run func()) MockButtonWidget_GrabFocus_Call {
	383	+	_c.Call.Run(func(args mock.Arguments) {
	384	+	run()
	385	+	})
	386	+	return _c
	387	+	}
	388	+
	389	+	func (_c MockButtonWidget_GrabFocus_Call) Return(b bool) MockButtonWidget_GrabFocus_Call {
	390	+	_c.Call.Return(b)
	391	+	return _c
	392	+	}
	393	+
	394	+	func (_c MockButtonWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockButtonWidget_GrabFocus_Call {
	395	+	_c.Call.Return(run)
	396	+	return _c
	397	+	}
	398	+
	399	+	// GtkWidget provides a mock function for the type MockButtonWidget
	400	+	func (_mock MockButtonWidget) GtkWidget() gtk.Widget {
	401	+	ret := _mock.Called()
	402	+
	403	+	if len(ret) == 0 {
	404	+	panic("no return value specified for GtkWidget")
	405	+	}
	406	+
	407	+	var r0 *gtk.Widget
	408	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	409	+	r0 = returnFunc()
	410	+	} else {
	411	+	if ret.Get(0) != nil {
	412	+	r0 = ret.Get(0).(*gtk.Widget)
	413	+	}
	414	+	}
	415	+	return r0
	416	+	}
	417	+
	418	+	// MockButtonWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	419	+	type MockButtonWidget_GtkWidget_Call struct {
	420	+	*mock.Call
	421	+	}
	422	+
	423	+	// GtkWidget is a helper method to define mock.On call
	424	+	func (_e MockButtonWidget_Expecter) GtkWidget() MockButtonWidget_GtkWidget_Call {
	425	+	return &MockButtonWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	426	+	}
	427	+
	428	+	func (_c MockButtonWidget_GtkWidget_Call) Run(run func()) MockButtonWidget_GtkWidget_Call {
	429	+	_c.Call.Run(func(args mock.Arguments) {
	430	+	run()
	431	+	})
	432	+	return _c
	433	+	}
	434	+
	435	+	func (_c MockButtonWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockButtonWidget_GtkWidget_Call {
	436	+	_c.Call.Return(widget)
	437	+	return _c
	438	+	}
	439	+
	440	+	func (_c MockButtonWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockButtonWidget_GtkWidget_Call {
	441	+	_c.Call.Return(run)
	442	+	return _c
	443	+	}
	444	+
	445	+	// HasCssClass provides a mock function for the type MockButtonWidget
	446	+	func (_mock *MockButtonWidget) HasCssClass(cssClass string) bool {
	447	+	ret := _mock.Called(cssClass)
	448	+
	449	+	if len(ret) == 0 {
	450	+	panic("no return value specified for HasCssClass")
	451	+	}
	452	+
	453	+	var r0 bool
	454	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	455	+	r0 = returnFunc(cssClass)
	456	+	} else {
	457	+	r0 = ret.Get(0).(bool)
	458	+	}
	459	+	return r0
	460	+	}
	461	+
	462	+	// MockButtonWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	463	+	type MockButtonWidget_HasCssClass_Call struct {
	464	+	*mock.Call
	465	+	}
	466	+
	467	+	// HasCssClass is a helper method to define mock.On call
	468	+	// - cssClass string
	469	+	func (_e MockButtonWidget_Expecter) HasCssClass(cssClass interface{}) MockButtonWidget_HasCssClass_Call {
	470	+	return &MockButtonWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	471	+	}
	472	+
	473	+	func (_c MockButtonWidget_HasCssClass_Call) Run(run func(cssClass string)) MockButtonWidget_HasCssClass_Call {
	474	+	_c.Call.Run(func(args mock.Arguments) {
	475	+	var arg0 string
	476	+	if args[0] != nil {
	477	+	arg0 = args[0].(string)
	478	+	}
	479	+	run(
	480	+	arg0,
	481	+	)
	482	+	})
	483	+	return _c
	484	+	}
	485	+
	486	+	func (_c MockButtonWidget_HasCssClass_Call) Return(b bool) MockButtonWidget_HasCssClass_Call {
	487	+	_c.Call.Return(b)
	488	+	return _c
	489	+	}
	490	+
	491	+	func (_c MockButtonWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockButtonWidget_HasCssClass_Call {
	492	+	_c.Call.Return(run)
	493	+	return _c
	494	+	}
	495	+
	496	+	// HasFocus provides a mock function for the type MockButtonWidget
	497	+	func (_mock *MockButtonWidget) HasFocus() bool {
	498	+	ret := _mock.Called()
	499	+
	500	+	if len(ret) == 0 {
	501	+	panic("no return value specified for HasFocus")
	502	+	}
	503	+
	504	+	var r0 bool
	505	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	506	+	r0 = returnFunc()
	507	+	} else {
	508	+	r0 = ret.Get(0).(bool)
	509	+	}
	510	+	return r0
	511	+	}
	512	+
	513	+	// MockButtonWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	514	+	type MockButtonWidget_HasFocus_Call struct {
	515	+	*mock.Call
	516	+	}
	517	+
	518	+	// HasFocus is a helper method to define mock.On call
	519	+	func (_e MockButtonWidget_Expecter) HasFocus() MockButtonWidget_HasFocus_Call {
	520	+	return &MockButtonWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	521	+	}
	522	+
	523	+	func (_c MockButtonWidget_HasFocus_Call) Run(run func()) MockButtonWidget_HasFocus_Call {
	524	+	_c.Call.Run(func(args mock.Arguments) {
	525	+	run()
	526	+	})
	527	+	return _c
	528	+	}
	529	+
	530	+	func (_c MockButtonWidget_HasFocus_Call) Return(b bool) MockButtonWidget_HasFocus_Call {
	531	+	_c.Call.Return(b)
	532	+	return _c
	533	+	}
	534	+
	535	+	func (_c MockButtonWidget_HasFocus_Call) RunAndReturn(run func() bool) MockButtonWidget_HasFocus_Call {
	536	+	_c.Call.Return(run)
	537	+	return _c
	538	+	}
	539	+
	540	+	// Hide provides a mock function for the type MockButtonWidget
	541	+	func (_mock *MockButtonWidget) Hide() {
	542	+	_mock.Called()
	543	+	return
	544	+	}
	545	+
	546	+	// MockButtonWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	547	+	type MockButtonWidget_Hide_Call struct {
	548	+	*mock.Call
	549	+	}
	550	+
	551	+	// Hide is a helper method to define mock.On call
	552	+	func (_e MockButtonWidget_Expecter) Hide() MockButtonWidget_Hide_Call {
	553	+	return &MockButtonWidget_Hide_Call{Call: _e.mock.On("Hide")}
	554	+	}
	555	+
	556	+	func (_c MockButtonWidget_Hide_Call) Run(run func()) MockButtonWidget_Hide_Call {
	557	+	_c.Call.Run(func(args mock.Arguments) {
	558	+	run()
	559	+	})
	560	+	return _c
	561	+	}
	562	+
	563	+	func (_c MockButtonWidget_Hide_Call) Return() MockButtonWidget_Hide_Call {
	564	+	_c.Call.Return()
	565	+	return _c
	566	+	}
	567	+
	568	+	func (_c MockButtonWidget_Hide_Call) RunAndReturn(run func()) MockButtonWidget_Hide_Call {
	569	+	_c.Run(run)
	570	+	return _c
	571	+	}
	572	+
	573	+	// IsVisible provides a mock function for the type MockButtonWidget
	574	+	func (_mock *MockButtonWidget) IsVisible() bool {
	575	+	ret := _mock.Called()
	576	+
	577	+	if len(ret) == 0 {
	578	+	panic("no return value specified for IsVisible")
	579	+	}
	580	+
	581	+	var r0 bool
	582	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	583	+	r0 = returnFunc()
	584	+	} else {
	585	+	r0 = ret.Get(0).(bool)
	586	+	}
	587	+	return r0
	588	+	}
	589	+
	590	+	// MockButtonWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	591	+	type MockButtonWidget_IsVisible_Call struct {
	592	+	*mock.Call
	593	+	}
	594	+
	595	+	// IsVisible is a helper method to define mock.On call
	596	+	func (_e MockButtonWidget_Expecter) IsVisible() MockButtonWidget_IsVisible_Call {
	597	+	return &MockButtonWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	598	+	}
	599	+
	600	+	func (_c MockButtonWidget_IsVisible_Call) Run(run func()) MockButtonWidget_IsVisible_Call {
	601	+	_c.Call.Run(func(args mock.Arguments) {
	602	+	run()
	603	+	})
	604	+	return _c
	605	+	}
	606	+
	607	+	func (_c MockButtonWidget_IsVisible_Call) Return(b bool) MockButtonWidget_IsVisible_Call {
	608	+	_c.Call.Return(b)
	609	+	return _c
	610	+	}
	611	+
	612	+	func (_c MockButtonWidget_IsVisible_Call) RunAndReturn(run func() bool) MockButtonWidget_IsVisible_Call {
	613	+	_c.Call.Return(run)
	614	+	return _c
	615	+	}
	616	+
	617	+	// RemoveCssClass provides a mock function for the type MockButtonWidget
	618	+	func (_mock *MockButtonWidget) RemoveCssClass(cssClass string) {
	619	+	_mock.Called(cssClass)
	620	+	return
	621	+	}
	622	+
	623	+	// MockButtonWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	624	+	type MockButtonWidget_RemoveCssClass_Call struct {
	625	+	*mock.Call
	626	+	}
	627	+
	628	+	// RemoveCssClass is a helper method to define mock.On call
	629	+	// - cssClass string
	630	+	func (_e MockButtonWidget_Expecter) RemoveCssClass(cssClass interface{}) MockButtonWidget_RemoveCssClass_Call {
	631	+	return &MockButtonWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	632	+	}
	633	+
	634	+	func (_c MockButtonWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockButtonWidget_RemoveCssClass_Call {
	635	+	_c.Call.Run(func(args mock.Arguments) {
	636	+	var arg0 string
	637	+	if args[0] != nil {
	638	+	arg0 = args[0].(string)
	639	+	}
	640	+	run(
	641	+	arg0,
	642	+	)
	643	+	})
	644	+	return _c
	645	+	}
	646	+
	647	+	func (_c MockButtonWidget_RemoveCssClass_Call) Return() MockButtonWidget_RemoveCssClass_Call {
	648	+	_c.Call.Return()
	649	+	return _c
	650	+	}
	651	+
	652	+	func (_c MockButtonWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockButtonWidget_RemoveCssClass_Call {
	653	+	_c.Run(run)
	654	+	return _c
	655	+	}
	656	+
	657	+	// SetCanFocus provides a mock function for the type MockButtonWidget
	658	+	func (_mock *MockButtonWidget) SetCanFocus(canFocus bool) {
	659	+	_mock.Called(canFocus)
	660	+	return
	661	+	}
	662	+
	663	+	// MockButtonWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	664	+	type MockButtonWidget_SetCanFocus_Call struct {
	665	+	*mock.Call
	666	+	}
	667	+
	668	+	// SetCanFocus is a helper method to define mock.On call
	669	+	// - canFocus bool
	670	+	func (_e MockButtonWidget_Expecter) SetCanFocus(canFocus interface{}) MockButtonWidget_SetCanFocus_Call {
	671	+	return &MockButtonWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	672	+	}
	673	+
	674	+	func (_c MockButtonWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockButtonWidget_SetCanFocus_Call {
	675	+	_c.Call.Run(func(args mock.Arguments) {
	676	+	var arg0 bool
	677	+	if args[0] != nil {
	678	+	arg0 = args[0].(bool)
	679	+	}
	680	+	run(
	681	+	arg0,
	682	+	)
	683	+	})
	684	+	return _c
	685	+	}
	686	+
	687	+	func (_c MockButtonWidget_SetCanFocus_Call) Return() MockButtonWidget_SetCanFocus_Call {
	688	+	_c.Call.Return()
	689	+	return _c
	690	+	}
	691	+
	692	+	func (_c MockButtonWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockButtonWidget_SetCanFocus_Call {
	693	+	_c.Run(run)
	694	+	return _c
	695	+	}
	696	+
	697	+	// SetChild provides a mock function for the type MockButtonWidget
	698	+	func (_mock *MockButtonWidget) SetChild(child layout.Widget) {
	699	+	_mock.Called(child)
	700	+	return
	701	+	}
	702	+
	703	+	// MockButtonWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
	704	+	type MockButtonWidget_SetChild_Call struct {
	705	+	*mock.Call
	706	+	}
	707	+
	708	+	// SetChild is a helper method to define mock.On call
	709	+	// - child layout.Widget
	710	+	func (_e MockButtonWidget_Expecter) SetChild(child interface{}) MockButtonWidget_SetChild_Call {
	711	+	return &MockButtonWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
	712	+	}
	713	+
	714	+	func (_c MockButtonWidget_SetChild_Call) Run(run func(child layout.Widget)) MockButtonWidget_SetChild_Call {
	715	+	_c.Call.Run(func(args mock.Arguments) {
	716	+	var arg0 layout.Widget
	717	+	if args[0] != nil {
	718	+	arg0 = args[0].(layout.Widget)
	719	+	}
	720	+	run(
	721	+	arg0,
	722	+	)
	723	+	})
	724	+	return _c
	725	+	}
	726	+
	727	+	func (_c MockButtonWidget_SetChild_Call) Return() MockButtonWidget_SetChild_Call {
	728	+	_c.Call.Return()
	729	+	return _c
	730	+	}
	731	+
	732	+	func (_c MockButtonWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) MockButtonWidget_SetChild_Call {
	733	+	_c.Run(run)
	734	+	return _c
	735	+	}
	736	+
	737	+	// SetFocusOnClick provides a mock function for the type MockButtonWidget
	738	+	func (_mock *MockButtonWidget) SetFocusOnClick(focusOnClick bool) {
	739	+	_mock.Called(focusOnClick)
	740	+	return
	741	+	}
	742	+
	743	+	// MockButtonWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	744	+	type MockButtonWidget_SetFocusOnClick_Call struct {
	745	+	*mock.Call
	746	+	}
	747	+
	748	+	// SetFocusOnClick is a helper method to define mock.On call
	749	+	// - focusOnClick bool
	750	+	func (_e MockButtonWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockButtonWidget_SetFocusOnClick_Call {
	751	+	return &MockButtonWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	752	+	}
	753	+
	754	+	func (_c MockButtonWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockButtonWidget_SetFocusOnClick_Call {
	755	+	_c.Call.Run(func(args mock.Arguments) {
	756	+	var arg0 bool
	757	+	if args[0] != nil {
	758	+	arg0 = args[0].(bool)
	759	+	}
	760	+	run(
	761	+	arg0,
	762	+	)
	763	+	})
	764	+	return _c
	765	+	}
	766	+
	767	+	func (_c MockButtonWidget_SetFocusOnClick_Call) Return() MockButtonWidget_SetFocusOnClick_Call {
	768	+	_c.Call.Return()
	769	+	return _c
	770	+	}
	771	+
	772	+	func (_c MockButtonWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockButtonWidget_SetFocusOnClick_Call {
	773	+	_c.Run(run)
	774	+	return _c
	775	+	}
	776	+
	777	+	// SetHalign provides a mock function for the type MockButtonWidget
	778	+	func (_mock *MockButtonWidget) SetHalign(align gtk.Align) {
	779	+	_mock.Called(align)
	780	+	return
	781	+	}
	782	+
	783	+	// MockButtonWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	784	+	type MockButtonWidget_SetHalign_Call struct {
	785	+	*mock.Call
	786	+	}
	787	+
	788	+	// SetHalign is a helper method to define mock.On call
	789	+	// - align gtk.Align
	790	+	func (_e MockButtonWidget_Expecter) SetHalign(align interface{}) MockButtonWidget_SetHalign_Call {
	791	+	return &MockButtonWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	792	+	}
	793	+
	794	+	func (_c MockButtonWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockButtonWidget_SetHalign_Call {
	795	+	_c.Call.Run(func(args mock.Arguments) {
	796	+	var arg0 gtk.Align
	797	+	if args[0] != nil {
	798	+	arg0 = args[0].(gtk.Align)
	799	+	}
	800	+	run(
	801	+	arg0,
	802	+	)
	803	+	})
	804	+	return _c
	805	+	}
	806	+
	807	+	func (_c MockButtonWidget_SetHalign_Call) Return() MockButtonWidget_SetHalign_Call {
	808	+	_c.Call.Return()
	809	+	return _c
	810	+	}
	811	+
	812	+	func (_c MockButtonWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockButtonWidget_SetHalign_Call {
	813	+	_c.Run(run)
	814	+	return _c
	815	+	}
	816	+
	817	+	// SetHexpand provides a mock function for the type MockButtonWidget
	818	+	func (_mock *MockButtonWidget) SetHexpand(expand bool) {
	819	+	_mock.Called(expand)
	820	+	return
	821	+	}
	822	+
	823	+	// MockButtonWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	824	+	type MockButtonWidget_SetHexpand_Call struct {
	825	+	*mock.Call
	826	+	}
	827	+
	828	+	// SetHexpand is a helper method to define mock.On call
	829	+	// - expand bool
	830	+	func (_e MockButtonWidget_Expecter) SetHexpand(expand interface{}) MockButtonWidget_SetHexpand_Call {
	831	+	return &MockButtonWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	832	+	}
	833	+
	834	+	func (_c MockButtonWidget_SetHexpand_Call) Run(run func(expand bool)) MockButtonWidget_SetHexpand_Call {
	835	+	_c.Call.Run(func(args mock.Arguments) {
	836	+	var arg0 bool
	837	+	if args[0] != nil {
	838	+	arg0 = args[0].(bool)
	839	+	}
	840	+	run(
	841	+	arg0,
	842	+	)
	843	+	})
	844	+	return _c
	845	+	}
	846	+
	847	+	func (_c MockButtonWidget_SetHexpand_Call) Return() MockButtonWidget_SetHexpand_Call {
	848	+	_c.Call.Return()
	849	+	return _c
	850	+	}
	851	+
	852	+	func (_c MockButtonWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockButtonWidget_SetHexpand_Call {
	853	+	_c.Run(run)
	854	+	return _c
	855	+	}
	856	+
	857	+	// SetLabel provides a mock function for the type MockButtonWidget
	858	+	func (_mock *MockButtonWidget) SetLabel(label string) {
	859	+	_mock.Called(label)
	860	+	return
	861	+	}
	862	+
	863	+	// MockButtonWidget_SetLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabel'
	864	+	type MockButtonWidget_SetLabel_Call struct {
	865	+	*mock.Call
	866	+	}
	867	+
	868	+	// SetLabel is a helper method to define mock.On call
	869	+	// - label string
	870	+	func (_e MockButtonWidget_Expecter) SetLabel(label interface{}) MockButtonWidget_SetLabel_Call {
	871	+	return &MockButtonWidget_SetLabel_Call{Call: _e.mock.On("SetLabel", label)}
	872	+	}
	873	+
	874	+	func (_c MockButtonWidget_SetLabel_Call) Run(run func(label string)) MockButtonWidget_SetLabel_Call {
	875	+	_c.Call.Run(func(args mock.Arguments) {
	876	+	var arg0 string
	877	+	if args[0] != nil {
	878	+	arg0 = args[0].(string)
	879	+	}
	880	+	run(
	881	+	arg0,
	882	+	)
	883	+	})
	884	+	return _c
	885	+	}
	886	+
	887	+	func (_c MockButtonWidget_SetLabel_Call) Return() MockButtonWidget_SetLabel_Call {
	888	+	_c.Call.Return()
	889	+	return _c
	890	+	}
	891	+
	892	+	func (_c MockButtonWidget_SetLabel_Call) RunAndReturn(run func(label string)) MockButtonWidget_SetLabel_Call {
	893	+	_c.Run(run)
	894	+	return _c
	895	+	}
	896	+
	897	+	// SetSizeRequest provides a mock function for the type MockButtonWidget
	898	+	func (_mock *MockButtonWidget) SetSizeRequest(width int, height int) {
	899	+	_mock.Called(width, height)
	900	+	return
	901	+	}
	902	+
	903	+	// MockButtonWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	904	+	type MockButtonWidget_SetSizeRequest_Call struct {
	905	+	*mock.Call
	906	+	}
	907	+
	908	+	// SetSizeRequest is a helper method to define mock.On call
	909	+	// - width int
	910	+	// - height int
	911	+	func (_e MockButtonWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockButtonWidget_SetSizeRequest_Call {
	912	+	return &MockButtonWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	913	+	}
	914	+
	915	+	func (_c MockButtonWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockButtonWidget_SetSizeRequest_Call {
	916	+	_c.Call.Run(func(args mock.Arguments) {
	917	+	var arg0 int
	918	+	if args[0] != nil {
	919	+	arg0 = args[0].(int)
	920	+	}
	921	+	var arg1 int
	922	+	if args[1] != nil {
	923	+	arg1 = args[1].(int)
	924	+	}
	925	+	run(
	926	+	arg0,
	927	+	arg1,
	928	+	)
	929	+	})
	930	+	return _c
	931	+	}
	932	+
	933	+	func (_c MockButtonWidget_SetSizeRequest_Call) Return() MockButtonWidget_SetSizeRequest_Call {
	934	+	_c.Call.Return()
	935	+	return _c
	936	+	}
	937	+
	938	+	func (_c MockButtonWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockButtonWidget_SetSizeRequest_Call {
	939	+	_c.Run(run)
	940	+	return _c
	941	+	}
	942	+
	943	+	// SetValign provides a mock function for the type MockButtonWidget
	944	+	func (_mock *MockButtonWidget) SetValign(align gtk.Align) {
	945	+	_mock.Called(align)
	946	+	return
	947	+	}
	948	+
	949	+	// MockButtonWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	950	+	type MockButtonWidget_SetValign_Call struct {
	951	+	*mock.Call
	952	+	}
	953	+
	954	+	// SetValign is a helper method to define mock.On call
	955	+	// - align gtk.Align
	956	+	func (_e MockButtonWidget_Expecter) SetValign(align interface{}) MockButtonWidget_SetValign_Call {
	957	+	return &MockButtonWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	958	+	}
	959	+
	960	+	func (_c MockButtonWidget_SetValign_Call) Run(run func(align gtk.Align)) MockButtonWidget_SetValign_Call {
	961	+	_c.Call.Run(func(args mock.Arguments) {
	962	+	var arg0 gtk.Align
	963	+	if args[0] != nil {
	964	+	arg0 = args[0].(gtk.Align)
	965	+	}
	966	+	run(
	967	+	arg0,
	968	+	)
	969	+	})
	970	+	return _c
	971	+	}
	972	+
	973	+	func (_c MockButtonWidget_SetValign_Call) Return() MockButtonWidget_SetValign_Call {
	974	+	_c.Call.Return()
	975	+	return _c
	976	+	}
	977	+
	978	+	func (_c MockButtonWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockButtonWidget_SetValign_Call {
	979	+	_c.Run(run)
	980	+	return _c
	981	+	}
	982	+
	983	+	// SetVexpand provides a mock function for the type MockButtonWidget
	984	+	func (_mock *MockButtonWidget) SetVexpand(expand bool) {
	985	+	_mock.Called(expand)
	986	+	return
	987	+	}
	988	+
	989	+	// MockButtonWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	990	+	type MockButtonWidget_SetVexpand_Call struct {
	991	+	*mock.Call
	992	+	}
	993	+
	994	+	// SetVexpand is a helper method to define mock.On call
	995	+	// - expand bool
	996	+	func (_e MockButtonWidget_Expecter) SetVexpand(expand interface{}) MockButtonWidget_SetVexpand_Call {
	997	+	return &MockButtonWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	998	+	}
	999	+
	1000	+	func (_c MockButtonWidget_SetVexpand_Call) Run(run func(expand bool)) MockButtonWidget_SetVexpand_Call {
	1001	+	_c.Call.Run(func(args mock.Arguments) {
	1002	+	var arg0 bool
	1003	+	if args[0] != nil {
	1004	+	arg0 = args[0].(bool)
	1005	+	}
	1006	+	run(
	1007	+	arg0,
	1008	+	)
	1009	+	})
	1010	+	return _c
	1011	+	}
	1012	+
	1013	+	func (_c MockButtonWidget_SetVexpand_Call) Return() MockButtonWidget_SetVexpand_Call {
	1014	+	_c.Call.Return()
	1015	+	return _c
	1016	+	}
	1017	+
	1018	+	func (_c MockButtonWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockButtonWidget_SetVexpand_Call {
	1019	+	_c.Run(run)
	1020	+	return _c
	1021	+	}
	1022	+
	1023	+	// SetVisible provides a mock function for the type MockButtonWidget
	1024	+	func (_mock *MockButtonWidget) SetVisible(visible bool) {
	1025	+	_mock.Called(visible)
	1026	+	return
	1027	+	}
	1028	+
	1029	+	// MockButtonWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	1030	+	type MockButtonWidget_SetVisible_Call struct {
	1031	+	*mock.Call
	1032	+	}
	1033	+
	1034	+	// SetVisible is a helper method to define mock.On call
	1035	+	// - visible bool
	1036	+	func (_e MockButtonWidget_Expecter) SetVisible(visible interface{}) MockButtonWidget_SetVisible_Call {
	1037	+	return &MockButtonWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	1038	+	}
	1039	+
	1040	+	func (_c MockButtonWidget_SetVisible_Call) Run(run func(visible bool)) MockButtonWidget_SetVisible_Call {
	1041	+	_c.Call.Run(func(args mock.Arguments) {
	1042	+	var arg0 bool
	1043	+	if args[0] != nil {
	1044	+	arg0 = args[0].(bool)
	1045	+	}
	1046	+	run(
	1047	+	arg0,
	1048	+	)
	1049	+	})
	1050	+	return _c
	1051	+	}
	1052	+
	1053	+	func (_c MockButtonWidget_SetVisible_Call) Return() MockButtonWidget_SetVisible_Call {
	1054	+	_c.Call.Return()
	1055	+	return _c
	1056	+	}
	1057	+
	1058	+	func (_c MockButtonWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockButtonWidget_SetVisible_Call {
	1059	+	_c.Run(run)
	1060	+	return _c
	1061	+	}
	1062	+
	1063	+	// Show provides a mock function for the type MockButtonWidget
	1064	+	func (_mock *MockButtonWidget) Show() {
	1065	+	_mock.Called()
	1066	+	return
	1067	+	}
	1068	+
	1069	+	// MockButtonWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	1070	+	type MockButtonWidget_Show_Call struct {
	1071	+	*mock.Call
	1072	+	}
	1073	+
	1074	+	// Show is a helper method to define mock.On call
	1075	+	func (_e MockButtonWidget_Expecter) Show() MockButtonWidget_Show_Call {
	1076	+	return &MockButtonWidget_Show_Call{Call: _e.mock.On("Show")}
	1077	+	}
	1078	+
	1079	+	func (_c MockButtonWidget_Show_Call) Run(run func()) MockButtonWidget_Show_Call {
	1080	+	_c.Call.Run(func(args mock.Arguments) {
	1081	+	run()
	1082	+	})
	1083	+	return _c
	1084	+	}
	1085	+
	1086	+	func (_c MockButtonWidget_Show_Call) Return() MockButtonWidget_Show_Call {
	1087	+	_c.Call.Return()
	1088	+	return _c
	1089	+	}
	1090	+
	1091	+	func (_c MockButtonWidget_Show_Call) RunAndReturn(run func()) MockButtonWidget_Show_Call {
	1092	+	_c.Run(run)
	1093	+	return _c
	1094	+	}
	1095	+
	1096	+	// Unparent provides a mock function for the type MockButtonWidget
	1097	+	func (_mock *MockButtonWidget) Unparent() {
	1098	+	_mock.Called()
	1099	+	return
	1100	+	}
	1101	+
	1102	+	// MockButtonWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	1103	+	type MockButtonWidget_Unparent_Call struct {
	1104	+	*mock.Call
	1105	+	}
	1106	+
	1107	+	// Unparent is a helper method to define mock.On call
	1108	+	func (_e MockButtonWidget_Expecter) Unparent() MockButtonWidget_Unparent_Call {
	1109	+	return &MockButtonWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	1110	+	}
	1111	+
	1112	+	func (_c MockButtonWidget_Unparent_Call) Run(run func()) MockButtonWidget_Unparent_Call {
	1113	+	_c.Call.Run(func(args mock.Arguments) {
	1114	+	run()
	1115	+	})
	1116	+	return _c
	1117	+	}
	1118	+
	1119	+	func (_c MockButtonWidget_Unparent_Call) Return() MockButtonWidget_Unparent_Call {
	1120	+	_c.Call.Return()
	1121	+	return _c
	1122	+	}
	1123	+
	1124	+	func (_c MockButtonWidget_Unparent_Call) RunAndReturn(run func()) MockButtonWidget_Unparent_Call {
	1125	+	_c.Run(run)
	1126	+	return _c
	1127	+	}

A internal/ui/layout/mocks/mock_image_widget.go +1059 -0

@@ -0,0 +1,1059 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockImageWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockImageWidget {
	19	+	mock := &MockImageWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockImageWidget is an autogenerated mock type for the ImageWidget type
	28	+	type MockImageWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockImageWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockImageWidget) EXPECT() MockImageWidget_Expecter {
	37	+	return &MockImageWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockImageWidget
	41	+	func (_mock *MockImageWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockImageWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockImageWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockImageWidget_Expecter) AddCssClass(cssClass interface{}) MockImageWidget_AddCssClass_Call {
	54	+	return &MockImageWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockImageWidget_AddCssClass_Call) Run(run func(cssClass string)) MockImageWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockImageWidget_AddCssClass_Call) Return() MockImageWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockImageWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockImageWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// Clear provides a mock function for the type MockImageWidget
	81	+	func (_mock *MockImageWidget) Clear() {
	82	+	_mock.Called()
	83	+	return
	84	+	}
	85	+
	86	+	// MockImageWidget_Clear_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clear'
	87	+	type MockImageWidget_Clear_Call struct {
	88	+	*mock.Call
	89	+	}
	90	+
	91	+	// Clear is a helper method to define mock.On call
	92	+	func (_e MockImageWidget_Expecter) Clear() MockImageWidget_Clear_Call {
	93	+	return &MockImageWidget_Clear_Call{Call: _e.mock.On("Clear")}
	94	+	}
	95	+
	96	+	func (_c MockImageWidget_Clear_Call) Run(run func()) MockImageWidget_Clear_Call {
	97	+	_c.Call.Run(func(args mock.Arguments) {
	98	+	run()
	99	+	})
	100	+	return _c
	101	+	}
	102	+
	103	+	func (_c MockImageWidget_Clear_Call) Return() MockImageWidget_Clear_Call {
	104	+	_c.Call.Return()
	105	+	return _c
	106	+	}
	107	+
	108	+	func (_c MockImageWidget_Clear_Call) RunAndReturn(run func()) MockImageWidget_Clear_Call {
	109	+	_c.Run(run)
	110	+	return _c
	111	+	}
	112	+
	113	+	// GetHexpand provides a mock function for the type MockImageWidget
	114	+	func (_mock *MockImageWidget) GetHexpand() bool {
	115	+	ret := _mock.Called()
	116	+
	117	+	if len(ret) == 0 {
	118	+	panic("no return value specified for GetHexpand")
	119	+	}
	120	+
	121	+	var r0 bool
	122	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	123	+	r0 = returnFunc()
	124	+	} else {
	125	+	r0 = ret.Get(0).(bool)
	126	+	}
	127	+	return r0
	128	+	}
	129	+
	130	+	// MockImageWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	131	+	type MockImageWidget_GetHexpand_Call struct {
	132	+	*mock.Call
	133	+	}
	134	+
	135	+	// GetHexpand is a helper method to define mock.On call
	136	+	func (_e MockImageWidget_Expecter) GetHexpand() MockImageWidget_GetHexpand_Call {
	137	+	return &MockImageWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	138	+	}
	139	+
	140	+	func (_c MockImageWidget_GetHexpand_Call) Run(run func()) MockImageWidget_GetHexpand_Call {
	141	+	_c.Call.Run(func(args mock.Arguments) {
	142	+	run()
	143	+	})
	144	+	return _c
	145	+	}
	146	+
	147	+	func (_c MockImageWidget_GetHexpand_Call) Return(b bool) MockImageWidget_GetHexpand_Call {
	148	+	_c.Call.Return(b)
	149	+	return _c
	150	+	}
	151	+
	152	+	func (_c MockImageWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockImageWidget_GetHexpand_Call {
	153	+	_c.Call.Return(run)
	154	+	return _c
	155	+	}
	156	+
	157	+	// GetParent provides a mock function for the type MockImageWidget
	158	+	func (_mock *MockImageWidget) GetParent() layout.Widget {
	159	+	ret := _mock.Called()
	160	+
	161	+	if len(ret) == 0 {
	162	+	panic("no return value specified for GetParent")
	163	+	}
	164	+
	165	+	var r0 layout.Widget
	166	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	167	+	r0 = returnFunc()
	168	+	} else {
	169	+	if ret.Get(0) != nil {
	170	+	r0 = ret.Get(0).(layout.Widget)
	171	+	}
	172	+	}
	173	+	return r0
	174	+	}
	175	+
	176	+	// MockImageWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	177	+	type MockImageWidget_GetParent_Call struct {
	178	+	*mock.Call
	179	+	}
	180	+
	181	+	// GetParent is a helper method to define mock.On call
	182	+	func (_e MockImageWidget_Expecter) GetParent() MockImageWidget_GetParent_Call {
	183	+	return &MockImageWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	184	+	}
	185	+
	186	+	func (_c MockImageWidget_GetParent_Call) Run(run func()) MockImageWidget_GetParent_Call {
	187	+	_c.Call.Run(func(args mock.Arguments) {
	188	+	run()
	189	+	})
	190	+	return _c
	191	+	}
	192	+
	193	+	func (_c MockImageWidget_GetParent_Call) Return(widget layout.Widget) MockImageWidget_GetParent_Call {
	194	+	_c.Call.Return(widget)
	195	+	return _c
	196	+	}
	197	+
	198	+	func (_c MockImageWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockImageWidget_GetParent_Call {
	199	+	_c.Call.Return(run)
	200	+	return _c
	201	+	}
	202	+
	203	+	// GetVexpand provides a mock function for the type MockImageWidget
	204	+	func (_mock *MockImageWidget) GetVexpand() bool {
	205	+	ret := _mock.Called()
	206	+
	207	+	if len(ret) == 0 {
	208	+	panic("no return value specified for GetVexpand")
	209	+	}
	210	+
	211	+	var r0 bool
	212	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	213	+	r0 = returnFunc()
	214	+	} else {
	215	+	r0 = ret.Get(0).(bool)
	216	+	}
	217	+	return r0
	218	+	}
	219	+
	220	+	// MockImageWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	221	+	type MockImageWidget_GetVexpand_Call struct {
	222	+	*mock.Call
	223	+	}
	224	+
	225	+	// GetVexpand is a helper method to define mock.On call
	226	+	func (_e MockImageWidget_Expecter) GetVexpand() MockImageWidget_GetVexpand_Call {
	227	+	return &MockImageWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	228	+	}
	229	+
	230	+	func (_c MockImageWidget_GetVexpand_Call) Run(run func()) MockImageWidget_GetVexpand_Call {
	231	+	_c.Call.Run(func(args mock.Arguments) {
	232	+	run()
	233	+	})
	234	+	return _c
	235	+	}
	236	+
	237	+	func (_c MockImageWidget_GetVexpand_Call) Return(b bool) MockImageWidget_GetVexpand_Call {
	238	+	_c.Call.Return(b)
	239	+	return _c
	240	+	}
	241	+
	242	+	func (_c MockImageWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockImageWidget_GetVexpand_Call {
	243	+	_c.Call.Return(run)
	244	+	return _c
	245	+	}
	246	+
	247	+	// GrabFocus provides a mock function for the type MockImageWidget
	248	+	func (_mock *MockImageWidget) GrabFocus() bool {
	249	+	ret := _mock.Called()
	250	+
	251	+	if len(ret) == 0 {
	252	+	panic("no return value specified for GrabFocus")
	253	+	}
	254	+
	255	+	var r0 bool
	256	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	257	+	r0 = returnFunc()
	258	+	} else {
	259	+	r0 = ret.Get(0).(bool)
	260	+	}
	261	+	return r0
	262	+	}
	263	+
	264	+	// MockImageWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	265	+	type MockImageWidget_GrabFocus_Call struct {
	266	+	*mock.Call
	267	+	}
	268	+
	269	+	// GrabFocus is a helper method to define mock.On call
	270	+	func (_e MockImageWidget_Expecter) GrabFocus() MockImageWidget_GrabFocus_Call {
	271	+	return &MockImageWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	272	+	}
	273	+
	274	+	func (_c MockImageWidget_GrabFocus_Call) Run(run func()) MockImageWidget_GrabFocus_Call {
	275	+	_c.Call.Run(func(args mock.Arguments) {
	276	+	run()
	277	+	})
	278	+	return _c
	279	+	}
	280	+
	281	+	func (_c MockImageWidget_GrabFocus_Call) Return(b bool) MockImageWidget_GrabFocus_Call {
	282	+	_c.Call.Return(b)
	283	+	return _c
	284	+	}
	285	+
	286	+	func (_c MockImageWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockImageWidget_GrabFocus_Call {
	287	+	_c.Call.Return(run)
	288	+	return _c
	289	+	}
	290	+
	291	+	// GtkWidget provides a mock function for the type MockImageWidget
	292	+	func (_mock MockImageWidget) GtkWidget() gtk.Widget {
	293	+	ret := _mock.Called()
	294	+
	295	+	if len(ret) == 0 {
	296	+	panic("no return value specified for GtkWidget")
	297	+	}
	298	+
	299	+	var r0 *gtk.Widget
	300	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	301	+	r0 = returnFunc()
	302	+	} else {
	303	+	if ret.Get(0) != nil {
	304	+	r0 = ret.Get(0).(*gtk.Widget)
	305	+	}
	306	+	}
	307	+	return r0
	308	+	}
	309	+
	310	+	// MockImageWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	311	+	type MockImageWidget_GtkWidget_Call struct {
	312	+	*mock.Call
	313	+	}
	314	+
	315	+	// GtkWidget is a helper method to define mock.On call
	316	+	func (_e MockImageWidget_Expecter) GtkWidget() MockImageWidget_GtkWidget_Call {
	317	+	return &MockImageWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	318	+	}
	319	+
	320	+	func (_c MockImageWidget_GtkWidget_Call) Run(run func()) MockImageWidget_GtkWidget_Call {
	321	+	_c.Call.Run(func(args mock.Arguments) {
	322	+	run()
	323	+	})
	324	+	return _c
	325	+	}
	326	+
	327	+	func (_c MockImageWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockImageWidget_GtkWidget_Call {
	328	+	_c.Call.Return(widget)
	329	+	return _c
	330	+	}
	331	+
	332	+	func (_c MockImageWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockImageWidget_GtkWidget_Call {
	333	+	_c.Call.Return(run)
	334	+	return _c
	335	+	}
	336	+
	337	+	// HasCssClass provides a mock function for the type MockImageWidget
	338	+	func (_mock *MockImageWidget) HasCssClass(cssClass string) bool {
	339	+	ret := _mock.Called(cssClass)
	340	+
	341	+	if len(ret) == 0 {
	342	+	panic("no return value specified for HasCssClass")
	343	+	}
	344	+
	345	+	var r0 bool
	346	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	347	+	r0 = returnFunc(cssClass)
	348	+	} else {
	349	+	r0 = ret.Get(0).(bool)
	350	+	}
	351	+	return r0
	352	+	}
	353	+
	354	+	// MockImageWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	355	+	type MockImageWidget_HasCssClass_Call struct {
	356	+	*mock.Call
	357	+	}
	358	+
	359	+	// HasCssClass is a helper method to define mock.On call
	360	+	// - cssClass string
	361	+	func (_e MockImageWidget_Expecter) HasCssClass(cssClass interface{}) MockImageWidget_HasCssClass_Call {
	362	+	return &MockImageWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	363	+	}
	364	+
	365	+	func (_c MockImageWidget_HasCssClass_Call) Run(run func(cssClass string)) MockImageWidget_HasCssClass_Call {
	366	+	_c.Call.Run(func(args mock.Arguments) {
	367	+	var arg0 string
	368	+	if args[0] != nil {
	369	+	arg0 = args[0].(string)
	370	+	}
	371	+	run(
	372	+	arg0,
	373	+	)
	374	+	})
	375	+	return _c
	376	+	}
	377	+
	378	+	func (_c MockImageWidget_HasCssClass_Call) Return(b bool) MockImageWidget_HasCssClass_Call {
	379	+	_c.Call.Return(b)
	380	+	return _c
	381	+	}
	382	+
	383	+	func (_c MockImageWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockImageWidget_HasCssClass_Call {
	384	+	_c.Call.Return(run)
	385	+	return _c
	386	+	}
	387	+
	388	+	// HasFocus provides a mock function for the type MockImageWidget
	389	+	func (_mock *MockImageWidget) HasFocus() bool {
	390	+	ret := _mock.Called()
	391	+
	392	+	if len(ret) == 0 {
	393	+	panic("no return value specified for HasFocus")
	394	+	}
	395	+
	396	+	var r0 bool
	397	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	398	+	r0 = returnFunc()
	399	+	} else {
	400	+	r0 = ret.Get(0).(bool)
	401	+	}
	402	+	return r0
	403	+	}
	404	+
	405	+	// MockImageWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	406	+	type MockImageWidget_HasFocus_Call struct {
	407	+	*mock.Call
	408	+	}
	409	+
	410	+	// HasFocus is a helper method to define mock.On call
	411	+	func (_e MockImageWidget_Expecter) HasFocus() MockImageWidget_HasFocus_Call {
	412	+	return &MockImageWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	413	+	}
	414	+
	415	+	func (_c MockImageWidget_HasFocus_Call) Run(run func()) MockImageWidget_HasFocus_Call {
	416	+	_c.Call.Run(func(args mock.Arguments) {
	417	+	run()
	418	+	})
	419	+	return _c
	420	+	}
	421	+
	422	+	func (_c MockImageWidget_HasFocus_Call) Return(b bool) MockImageWidget_HasFocus_Call {
	423	+	_c.Call.Return(b)
	424	+	return _c
	425	+	}
	426	+
	427	+	func (_c MockImageWidget_HasFocus_Call) RunAndReturn(run func() bool) MockImageWidget_HasFocus_Call {
	428	+	_c.Call.Return(run)
	429	+	return _c
	430	+	}
	431	+
	432	+	// Hide provides a mock function for the type MockImageWidget
	433	+	func (_mock *MockImageWidget) Hide() {
	434	+	_mock.Called()
	435	+	return
	436	+	}
	437	+
	438	+	// MockImageWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	439	+	type MockImageWidget_Hide_Call struct {
	440	+	*mock.Call
	441	+	}
	442	+
	443	+	// Hide is a helper method to define mock.On call
	444	+	func (_e MockImageWidget_Expecter) Hide() MockImageWidget_Hide_Call {
	445	+	return &MockImageWidget_Hide_Call{Call: _e.mock.On("Hide")}
	446	+	}
	447	+
	448	+	func (_c MockImageWidget_Hide_Call) Run(run func()) MockImageWidget_Hide_Call {
	449	+	_c.Call.Run(func(args mock.Arguments) {
	450	+	run()
	451	+	})
	452	+	return _c
	453	+	}
	454	+
	455	+	func (_c MockImageWidget_Hide_Call) Return() MockImageWidget_Hide_Call {
	456	+	_c.Call.Return()
	457	+	return _c
	458	+	}
	459	+
	460	+	func (_c MockImageWidget_Hide_Call) RunAndReturn(run func()) MockImageWidget_Hide_Call {
	461	+	_c.Run(run)
	462	+	return _c
	463	+	}
	464	+
	465	+	// IsVisible provides a mock function for the type MockImageWidget
	466	+	func (_mock *MockImageWidget) IsVisible() bool {
	467	+	ret := _mock.Called()
	468	+
	469	+	if len(ret) == 0 {
	470	+	panic("no return value specified for IsVisible")
	471	+	}
	472	+
	473	+	var r0 bool
	474	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	475	+	r0 = returnFunc()
	476	+	} else {
	477	+	r0 = ret.Get(0).(bool)
	478	+	}
	479	+	return r0
	480	+	}
	481	+
	482	+	// MockImageWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	483	+	type MockImageWidget_IsVisible_Call struct {
	484	+	*mock.Call
	485	+	}
	486	+
	487	+	// IsVisible is a helper method to define mock.On call
	488	+	func (_e MockImageWidget_Expecter) IsVisible() MockImageWidget_IsVisible_Call {
	489	+	return &MockImageWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	490	+	}
	491	+
	492	+	func (_c MockImageWidget_IsVisible_Call) Run(run func()) MockImageWidget_IsVisible_Call {
	493	+	_c.Call.Run(func(args mock.Arguments) {
	494	+	run()
	495	+	})
	496	+	return _c
	497	+	}
	498	+
	499	+	func (_c MockImageWidget_IsVisible_Call) Return(b bool) MockImageWidget_IsVisible_Call {
	500	+	_c.Call.Return(b)
	501	+	return _c
	502	+	}
	503	+
	504	+	func (_c MockImageWidget_IsVisible_Call) RunAndReturn(run func() bool) MockImageWidget_IsVisible_Call {
	505	+	_c.Call.Return(run)
	506	+	return _c
	507	+	}
	508	+
	509	+	// RemoveCssClass provides a mock function for the type MockImageWidget
	510	+	func (_mock *MockImageWidget) RemoveCssClass(cssClass string) {
	511	+	_mock.Called(cssClass)
	512	+	return
	513	+	}
	514	+
	515	+	// MockImageWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	516	+	type MockImageWidget_RemoveCssClass_Call struct {
	517	+	*mock.Call
	518	+	}
	519	+
	520	+	// RemoveCssClass is a helper method to define mock.On call
	521	+	// - cssClass string
	522	+	func (_e MockImageWidget_Expecter) RemoveCssClass(cssClass interface{}) MockImageWidget_RemoveCssClass_Call {
	523	+	return &MockImageWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	524	+	}
	525	+
	526	+	func (_c MockImageWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockImageWidget_RemoveCssClass_Call {
	527	+	_c.Call.Run(func(args mock.Arguments) {
	528	+	var arg0 string
	529	+	if args[0] != nil {
	530	+	arg0 = args[0].(string)
	531	+	}
	532	+	run(
	533	+	arg0,
	534	+	)
	535	+	})
	536	+	return _c
	537	+	}
	538	+
	539	+	func (_c MockImageWidget_RemoveCssClass_Call) Return() MockImageWidget_RemoveCssClass_Call {
	540	+	_c.Call.Return()
	541	+	return _c
	542	+	}
	543	+
	544	+	func (_c MockImageWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockImageWidget_RemoveCssClass_Call {
	545	+	_c.Run(run)
	546	+	return _c
	547	+	}
	548	+
	549	+	// SetCanFocus provides a mock function for the type MockImageWidget
	550	+	func (_mock *MockImageWidget) SetCanFocus(canFocus bool) {
	551	+	_mock.Called(canFocus)
	552	+	return
	553	+	}
	554	+
	555	+	// MockImageWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	556	+	type MockImageWidget_SetCanFocus_Call struct {
	557	+	*mock.Call
	558	+	}
	559	+
	560	+	// SetCanFocus is a helper method to define mock.On call
	561	+	// - canFocus bool
	562	+	func (_e MockImageWidget_Expecter) SetCanFocus(canFocus interface{}) MockImageWidget_SetCanFocus_Call {
	563	+	return &MockImageWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	564	+	}
	565	+
	566	+	func (_c MockImageWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockImageWidget_SetCanFocus_Call {
	567	+	_c.Call.Run(func(args mock.Arguments) {
	568	+	var arg0 bool
	569	+	if args[0] != nil {
	570	+	arg0 = args[0].(bool)
	571	+	}
	572	+	run(
	573	+	arg0,
	574	+	)
	575	+	})
	576	+	return _c
	577	+	}
	578	+
	579	+	func (_c MockImageWidget_SetCanFocus_Call) Return() MockImageWidget_SetCanFocus_Call {
	580	+	_c.Call.Return()
	581	+	return _c
	582	+	}
	583	+
	584	+	func (_c MockImageWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockImageWidget_SetCanFocus_Call {
	585	+	_c.Run(run)
	586	+	return _c
	587	+	}
	588	+
	589	+	// SetFocusOnClick provides a mock function for the type MockImageWidget
	590	+	func (_mock *MockImageWidget) SetFocusOnClick(focusOnClick bool) {
	591	+	_mock.Called(focusOnClick)
	592	+	return
	593	+	}
	594	+
	595	+	// MockImageWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	596	+	type MockImageWidget_SetFocusOnClick_Call struct {
	597	+	*mock.Call
	598	+	}
	599	+
	600	+	// SetFocusOnClick is a helper method to define mock.On call
	601	+	// - focusOnClick bool
	602	+	func (_e MockImageWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockImageWidget_SetFocusOnClick_Call {
	603	+	return &MockImageWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	604	+	}
	605	+
	606	+	func (_c MockImageWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockImageWidget_SetFocusOnClick_Call {
	607	+	_c.Call.Run(func(args mock.Arguments) {
	608	+	var arg0 bool
	609	+	if args[0] != nil {
	610	+	arg0 = args[0].(bool)
	611	+	}
	612	+	run(
	613	+	arg0,
	614	+	)
	615	+	})
	616	+	return _c
	617	+	}
	618	+
	619	+	func (_c MockImageWidget_SetFocusOnClick_Call) Return() MockImageWidget_SetFocusOnClick_Call {
	620	+	_c.Call.Return()
	621	+	return _c
	622	+	}
	623	+
	624	+	func (_c MockImageWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockImageWidget_SetFocusOnClick_Call {
	625	+	_c.Run(run)
	626	+	return _c
	627	+	}
	628	+
	629	+	// SetFromFile provides a mock function for the type MockImageWidget
	630	+	func (_mock *MockImageWidget) SetFromFile(filename string) {
	631	+	_mock.Called(filename)
	632	+	return
	633	+	}
	634	+
	635	+	// MockImageWidget_SetFromFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromFile'
	636	+	type MockImageWidget_SetFromFile_Call struct {
	637	+	*mock.Call
	638	+	}
	639	+
	640	+	// SetFromFile is a helper method to define mock.On call
	641	+	// - filename string
	642	+	func (_e MockImageWidget_Expecter) SetFromFile(filename interface{}) MockImageWidget_SetFromFile_Call {
	643	+	return &MockImageWidget_SetFromFile_Call{Call: _e.mock.On("SetFromFile", filename)}
	644	+	}
	645	+
	646	+	func (_c MockImageWidget_SetFromFile_Call) Run(run func(filename string)) MockImageWidget_SetFromFile_Call {
	647	+	_c.Call.Run(func(args mock.Arguments) {
	648	+	var arg0 string
	649	+	if args[0] != nil {
	650	+	arg0 = args[0].(string)
	651	+	}
	652	+	run(
	653	+	arg0,
	654	+	)
	655	+	})
	656	+	return _c
	657	+	}
	658	+
	659	+	func (_c MockImageWidget_SetFromFile_Call) Return() MockImageWidget_SetFromFile_Call {
	660	+	_c.Call.Return()
	661	+	return _c
	662	+	}
	663	+
	664	+	func (_c MockImageWidget_SetFromFile_Call) RunAndReturn(run func(filename string)) MockImageWidget_SetFromFile_Call {
	665	+	_c.Run(run)
	666	+	return _c
	667	+	}
	668	+
	669	+	// SetFromIconName provides a mock function for the type MockImageWidget
	670	+	func (_mock *MockImageWidget) SetFromIconName(iconName string) {
	671	+	_mock.Called(iconName)
	672	+	return
	673	+	}
	674	+
	675	+	// MockImageWidget_SetFromIconName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFromIconName'
	676	+	type MockImageWidget_SetFromIconName_Call struct {
	677	+	*mock.Call
	678	+	}
	679	+
	680	+	// SetFromIconName is a helper method to define mock.On call
	681	+	// - iconName string
	682	+	func (_e MockImageWidget_Expecter) SetFromIconName(iconName interface{}) MockImageWidget_SetFromIconName_Call {
	683	+	return &MockImageWidget_SetFromIconName_Call{Call: _e.mock.On("SetFromIconName", iconName)}
	684	+	}
	685	+
	686	+	func (_c MockImageWidget_SetFromIconName_Call) Run(run func(iconName string)) MockImageWidget_SetFromIconName_Call {
	687	+	_c.Call.Run(func(args mock.Arguments) {
	688	+	var arg0 string
	689	+	if args[0] != nil {
	690	+	arg0 = args[0].(string)
	691	+	}
	692	+	run(
	693	+	arg0,
	694	+	)
	695	+	})
	696	+	return _c
	697	+	}
	698	+
	699	+	func (_c MockImageWidget_SetFromIconName_Call) Return() MockImageWidget_SetFromIconName_Call {
	700	+	_c.Call.Return()
	701	+	return _c
	702	+	}
	703	+
	704	+	func (_c MockImageWidget_SetFromIconName_Call) RunAndReturn(run func(iconName string)) MockImageWidget_SetFromIconName_Call {
	705	+	_c.Run(run)
	706	+	return _c
	707	+	}
	708	+
	709	+	// SetHalign provides a mock function for the type MockImageWidget
	710	+	func (_mock *MockImageWidget) SetHalign(align gtk.Align) {
	711	+	_mock.Called(align)
	712	+	return
	713	+	}
	714	+
	715	+	// MockImageWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	716	+	type MockImageWidget_SetHalign_Call struct {
	717	+	*mock.Call
	718	+	}
	719	+
	720	+	// SetHalign is a helper method to define mock.On call
	721	+	// - align gtk.Align
	722	+	func (_e MockImageWidget_Expecter) SetHalign(align interface{}) MockImageWidget_SetHalign_Call {
	723	+	return &MockImageWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	724	+	}
	725	+
	726	+	func (_c MockImageWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockImageWidget_SetHalign_Call {
	727	+	_c.Call.Run(func(args mock.Arguments) {
	728	+	var arg0 gtk.Align
	729	+	if args[0] != nil {
	730	+	arg0 = args[0].(gtk.Align)
	731	+	}
	732	+	run(
	733	+	arg0,
	734	+	)
	735	+	})
	736	+	return _c
	737	+	}
	738	+
	739	+	func (_c MockImageWidget_SetHalign_Call) Return() MockImageWidget_SetHalign_Call {
	740	+	_c.Call.Return()
	741	+	return _c
	742	+	}
	743	+
	744	+	func (_c MockImageWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockImageWidget_SetHalign_Call {
	745	+	_c.Run(run)
	746	+	return _c
	747	+	}
	748	+
	749	+	// SetHexpand provides a mock function for the type MockImageWidget
	750	+	func (_mock *MockImageWidget) SetHexpand(expand bool) {
	751	+	_mock.Called(expand)
	752	+	return
	753	+	}
	754	+
	755	+	// MockImageWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	756	+	type MockImageWidget_SetHexpand_Call struct {
	757	+	*mock.Call
	758	+	}
	759	+
	760	+	// SetHexpand is a helper method to define mock.On call
	761	+	// - expand bool
	762	+	func (_e MockImageWidget_Expecter) SetHexpand(expand interface{}) MockImageWidget_SetHexpand_Call {
	763	+	return &MockImageWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	764	+	}
	765	+
	766	+	func (_c MockImageWidget_SetHexpand_Call) Run(run func(expand bool)) MockImageWidget_SetHexpand_Call {
	767	+	_c.Call.Run(func(args mock.Arguments) {
	768	+	var arg0 bool
	769	+	if args[0] != nil {
	770	+	arg0 = args[0].(bool)
	771	+	}
	772	+	run(
	773	+	arg0,
	774	+	)
	775	+	})
	776	+	return _c
	777	+	}
	778	+
	779	+	func (_c MockImageWidget_SetHexpand_Call) Return() MockImageWidget_SetHexpand_Call {
	780	+	_c.Call.Return()
	781	+	return _c
	782	+	}
	783	+
	784	+	func (_c MockImageWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockImageWidget_SetHexpand_Call {
	785	+	_c.Run(run)
	786	+	return _c
	787	+	}
	788	+
	789	+	// SetPixelSize provides a mock function for the type MockImageWidget
	790	+	func (_mock *MockImageWidget) SetPixelSize(pixelSize int) {
	791	+	_mock.Called(pixelSize)
	792	+	return
	793	+	}
	794	+
	795	+	// MockImageWidget_SetPixelSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPixelSize'
	796	+	type MockImageWidget_SetPixelSize_Call struct {
	797	+	*mock.Call
	798	+	}
	799	+
	800	+	// SetPixelSize is a helper method to define mock.On call
	801	+	// - pixelSize int
	802	+	func (_e MockImageWidget_Expecter) SetPixelSize(pixelSize interface{}) MockImageWidget_SetPixelSize_Call {
	803	+	return &MockImageWidget_SetPixelSize_Call{Call: _e.mock.On("SetPixelSize", pixelSize)}
	804	+	}
	805	+
	806	+	func (_c MockImageWidget_SetPixelSize_Call) Run(run func(pixelSize int)) MockImageWidget_SetPixelSize_Call {
	807	+	_c.Call.Run(func(args mock.Arguments) {
	808	+	var arg0 int
	809	+	if args[0] != nil {
	810	+	arg0 = args[0].(int)
	811	+	}
	812	+	run(
	813	+	arg0,
	814	+	)
	815	+	})
	816	+	return _c
	817	+	}
	818	+
	819	+	func (_c MockImageWidget_SetPixelSize_Call) Return() MockImageWidget_SetPixelSize_Call {
	820	+	_c.Call.Return()
	821	+	return _c
	822	+	}
	823	+
	824	+	func (_c MockImageWidget_SetPixelSize_Call) RunAndReturn(run func(pixelSize int)) MockImageWidget_SetPixelSize_Call {
	825	+	_c.Run(run)
	826	+	return _c
	827	+	}
	828	+
	829	+	// SetSizeRequest provides a mock function for the type MockImageWidget
	830	+	func (_mock *MockImageWidget) SetSizeRequest(width int, height int) {
	831	+	_mock.Called(width, height)
	832	+	return
	833	+	}
	834	+
	835	+	// MockImageWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	836	+	type MockImageWidget_SetSizeRequest_Call struct {
	837	+	*mock.Call
	838	+	}
	839	+
	840	+	// SetSizeRequest is a helper method to define mock.On call
	841	+	// - width int
	842	+	// - height int
	843	+	func (_e MockImageWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockImageWidget_SetSizeRequest_Call {
	844	+	return &MockImageWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	845	+	}
	846	+
	847	+	func (_c MockImageWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockImageWidget_SetSizeRequest_Call {
	848	+	_c.Call.Run(func(args mock.Arguments) {
	849	+	var arg0 int
	850	+	if args[0] != nil {
	851	+	arg0 = args[0].(int)
	852	+	}
	853	+	var arg1 int
	854	+	if args[1] != nil {
	855	+	arg1 = args[1].(int)
	856	+	}
	857	+	run(
	858	+	arg0,
	859	+	arg1,
	860	+	)
	861	+	})
	862	+	return _c
	863	+	}
	864	+
	865	+	func (_c MockImageWidget_SetSizeRequest_Call) Return() MockImageWidget_SetSizeRequest_Call {
	866	+	_c.Call.Return()
	867	+	return _c
	868	+	}
	869	+
	870	+	func (_c MockImageWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockImageWidget_SetSizeRequest_Call {
	871	+	_c.Run(run)
	872	+	return _c
	873	+	}
	874	+
	875	+	// SetValign provides a mock function for the type MockImageWidget
	876	+	func (_mock *MockImageWidget) SetValign(align gtk.Align) {
	877	+	_mock.Called(align)
	878	+	return
	879	+	}
	880	+
	881	+	// MockImageWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	882	+	type MockImageWidget_SetValign_Call struct {
	883	+	*mock.Call
	884	+	}
	885	+
	886	+	// SetValign is a helper method to define mock.On call
	887	+	// - align gtk.Align
	888	+	func (_e MockImageWidget_Expecter) SetValign(align interface{}) MockImageWidget_SetValign_Call {
	889	+	return &MockImageWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	890	+	}
	891	+
	892	+	func (_c MockImageWidget_SetValign_Call) Run(run func(align gtk.Align)) MockImageWidget_SetValign_Call {
	893	+	_c.Call.Run(func(args mock.Arguments) {
	894	+	var arg0 gtk.Align
	895	+	if args[0] != nil {
	896	+	arg0 = args[0].(gtk.Align)
	897	+	}
	898	+	run(
	899	+	arg0,
	900	+	)
	901	+	})
	902	+	return _c
	903	+	}
	904	+
	905	+	func (_c MockImageWidget_SetValign_Call) Return() MockImageWidget_SetValign_Call {
	906	+	_c.Call.Return()
	907	+	return _c
	908	+	}
	909	+
	910	+	func (_c MockImageWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockImageWidget_SetValign_Call {
	911	+	_c.Run(run)
	912	+	return _c
	913	+	}
	914	+
	915	+	// SetVexpand provides a mock function for the type MockImageWidget
	916	+	func (_mock *MockImageWidget) SetVexpand(expand bool) {
	917	+	_mock.Called(expand)
	918	+	return
	919	+	}
	920	+
	921	+	// MockImageWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	922	+	type MockImageWidget_SetVexpand_Call struct {
	923	+	*mock.Call
	924	+	}
	925	+
	926	+	// SetVexpand is a helper method to define mock.On call
	927	+	// - expand bool
	928	+	func (_e MockImageWidget_Expecter) SetVexpand(expand interface{}) MockImageWidget_SetVexpand_Call {
	929	+	return &MockImageWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	930	+	}
	931	+
	932	+	func (_c MockImageWidget_SetVexpand_Call) Run(run func(expand bool)) MockImageWidget_SetVexpand_Call {
	933	+	_c.Call.Run(func(args mock.Arguments) {
	934	+	var arg0 bool
	935	+	if args[0] != nil {
	936	+	arg0 = args[0].(bool)
	937	+	}
	938	+	run(
	939	+	arg0,
	940	+	)
	941	+	})
	942	+	return _c
	943	+	}
	944	+
	945	+	func (_c MockImageWidget_SetVexpand_Call) Return() MockImageWidget_SetVexpand_Call {
	946	+	_c.Call.Return()
	947	+	return _c
	948	+	}
	949	+
	950	+	func (_c MockImageWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockImageWidget_SetVexpand_Call {
	951	+	_c.Run(run)
	952	+	return _c
	953	+	}
	954	+
	955	+	// SetVisible provides a mock function for the type MockImageWidget
	956	+	func (_mock *MockImageWidget) SetVisible(visible bool) {
	957	+	_mock.Called(visible)
	958	+	return
	959	+	}
	960	+
	961	+	// MockImageWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	962	+	type MockImageWidget_SetVisible_Call struct {
	963	+	*mock.Call
	964	+	}
	965	+
	966	+	// SetVisible is a helper method to define mock.On call
	967	+	// - visible bool
	968	+	func (_e MockImageWidget_Expecter) SetVisible(visible interface{}) MockImageWidget_SetVisible_Call {
	969	+	return &MockImageWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	970	+	}
	971	+
	972	+	func (_c MockImageWidget_SetVisible_Call) Run(run func(visible bool)) MockImageWidget_SetVisible_Call {
	973	+	_c.Call.Run(func(args mock.Arguments) {
	974	+	var arg0 bool
	975	+	if args[0] != nil {
	976	+	arg0 = args[0].(bool)
	977	+	}
	978	+	run(
	979	+	arg0,
	980	+	)
	981	+	})
	982	+	return _c
	983	+	}
	984	+
	985	+	func (_c MockImageWidget_SetVisible_Call) Return() MockImageWidget_SetVisible_Call {
	986	+	_c.Call.Return()
	987	+	return _c
	988	+	}
	989	+
	990	+	func (_c MockImageWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockImageWidget_SetVisible_Call {
	991	+	_c.Run(run)
	992	+	return _c
	993	+	}
	994	+
	995	+	// Show provides a mock function for the type MockImageWidget
	996	+	func (_mock *MockImageWidget) Show() {
	997	+	_mock.Called()
	998	+	return
	999	+	}
	1000	+
	1001	+	// MockImageWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	1002	+	type MockImageWidget_Show_Call struct {
	1003	+	*mock.Call
	1004	+	}
	1005	+
	1006	+	// Show is a helper method to define mock.On call
	1007	+	func (_e MockImageWidget_Expecter) Show() MockImageWidget_Show_Call {
	1008	+	return &MockImageWidget_Show_Call{Call: _e.mock.On("Show")}
	1009	+	}
	1010	+
	1011	+	func (_c MockImageWidget_Show_Call) Run(run func()) MockImageWidget_Show_Call {
	1012	+	_c.Call.Run(func(args mock.Arguments) {
	1013	+	run()
	1014	+	})
	1015	+	return _c
	1016	+	}
	1017	+
	1018	+	func (_c MockImageWidget_Show_Call) Return() MockImageWidget_Show_Call {
	1019	+	_c.Call.Return()
	1020	+	return _c
	1021	+	}
	1022	+
	1023	+	func (_c MockImageWidget_Show_Call) RunAndReturn(run func()) MockImageWidget_Show_Call {
	1024	+	_c.Run(run)
	1025	+	return _c
	1026	+	}
	1027	+
	1028	+	// Unparent provides a mock function for the type MockImageWidget
	1029	+	func (_mock *MockImageWidget) Unparent() {
	1030	+	_mock.Called()
	1031	+	return
	1032	+	}
	1033	+
	1034	+	// MockImageWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	1035	+	type MockImageWidget_Unparent_Call struct {
	1036	+	*mock.Call
	1037	+	}
	1038	+
	1039	+	// Unparent is a helper method to define mock.On call
	1040	+	func (_e MockImageWidget_Expecter) Unparent() MockImageWidget_Unparent_Call {
	1041	+	return &MockImageWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	1042	+	}
	1043	+
	1044	+	func (_c MockImageWidget_Unparent_Call) Run(run func()) MockImageWidget_Unparent_Call {
	1045	+	_c.Call.Run(func(args mock.Arguments) {
	1046	+	run()
	1047	+	})
	1048	+	return _c
	1049	+	}
	1050	+
	1051	+	func (_c MockImageWidget_Unparent_Call) Return() MockImageWidget_Unparent_Call {
	1052	+	_c.Call.Return()
	1053	+	return _c
	1054	+	}
	1055	+
	1056	+	func (_c MockImageWidget_Unparent_Call) RunAndReturn(run func()) MockImageWidget_Unparent_Call {
	1057	+	_c.Run(run)
	1058	+	return _c
	1059	+	}

A internal/ui/layout/mocks/mock_label_widget.go +1150 -0

@@ -0,0 +1,1150 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockLabelWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockLabelWidget {
	19	+	mock := &MockLabelWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockLabelWidget is an autogenerated mock type for the LabelWidget type
	28	+	type MockLabelWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockLabelWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockLabelWidget) EXPECT() MockLabelWidget_Expecter {
	37	+	return &MockLabelWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockLabelWidget
	41	+	func (_mock *MockLabelWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockLabelWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockLabelWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockLabelWidget_Expecter) AddCssClass(cssClass interface{}) MockLabelWidget_AddCssClass_Call {
	54	+	return &MockLabelWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockLabelWidget_AddCssClass_Call) Run(run func(cssClass string)) MockLabelWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockLabelWidget_AddCssClass_Call) Return() MockLabelWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockLabelWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockLabelWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// GetHexpand provides a mock function for the type MockLabelWidget
	81	+	func (_mock *MockLabelWidget) GetHexpand() bool {
	82	+	ret := _mock.Called()
	83	+
	84	+	if len(ret) == 0 {
	85	+	panic("no return value specified for GetHexpand")
	86	+	}
	87	+
	88	+	var r0 bool
	89	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	90	+	r0 = returnFunc()
	91	+	} else {
	92	+	r0 = ret.Get(0).(bool)
	93	+	}
	94	+	return r0
	95	+	}
	96	+
	97	+	// MockLabelWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	98	+	type MockLabelWidget_GetHexpand_Call struct {
	99	+	*mock.Call
	100	+	}
	101	+
	102	+	// GetHexpand is a helper method to define mock.On call
	103	+	func (_e MockLabelWidget_Expecter) GetHexpand() MockLabelWidget_GetHexpand_Call {
	104	+	return &MockLabelWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	105	+	}
	106	+
	107	+	func (_c MockLabelWidget_GetHexpand_Call) Run(run func()) MockLabelWidget_GetHexpand_Call {
	108	+	_c.Call.Run(func(args mock.Arguments) {
	109	+	run()
	110	+	})
	111	+	return _c
	112	+	}
	113	+
	114	+	func (_c MockLabelWidget_GetHexpand_Call) Return(b bool) MockLabelWidget_GetHexpand_Call {
	115	+	_c.Call.Return(b)
	116	+	return _c
	117	+	}
	118	+
	119	+	func (_c MockLabelWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockLabelWidget_GetHexpand_Call {
	120	+	_c.Call.Return(run)
	121	+	return _c
	122	+	}
	123	+
	124	+	// GetParent provides a mock function for the type MockLabelWidget
	125	+	func (_mock *MockLabelWidget) GetParent() layout.Widget {
	126	+	ret := _mock.Called()
	127	+
	128	+	if len(ret) == 0 {
	129	+	panic("no return value specified for GetParent")
	130	+	}
	131	+
	132	+	var r0 layout.Widget
	133	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	134	+	r0 = returnFunc()
	135	+	} else {
	136	+	if ret.Get(0) != nil {
	137	+	r0 = ret.Get(0).(layout.Widget)
	138	+	}
	139	+	}
	140	+	return r0
	141	+	}
	142	+
	143	+	// MockLabelWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	144	+	type MockLabelWidget_GetParent_Call struct {
	145	+	*mock.Call
	146	+	}
	147	+
	148	+	// GetParent is a helper method to define mock.On call
	149	+	func (_e MockLabelWidget_Expecter) GetParent() MockLabelWidget_GetParent_Call {
	150	+	return &MockLabelWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	151	+	}
	152	+
	153	+	func (_c MockLabelWidget_GetParent_Call) Run(run func()) MockLabelWidget_GetParent_Call {
	154	+	_c.Call.Run(func(args mock.Arguments) {
	155	+	run()
	156	+	})
	157	+	return _c
	158	+	}
	159	+
	160	+	func (_c MockLabelWidget_GetParent_Call) Return(widget layout.Widget) MockLabelWidget_GetParent_Call {
	161	+	_c.Call.Return(widget)
	162	+	return _c
	163	+	}
	164	+
	165	+	func (_c MockLabelWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockLabelWidget_GetParent_Call {
	166	+	_c.Call.Return(run)
	167	+	return _c
	168	+	}
	169	+
	170	+	// GetText provides a mock function for the type MockLabelWidget
	171	+	func (_mock *MockLabelWidget) GetText() string {
	172	+	ret := _mock.Called()
	173	+
	174	+	if len(ret) == 0 {
	175	+	panic("no return value specified for GetText")
	176	+	}
	177	+
	178	+	var r0 string
	179	+	if returnFunc, ok := ret.Get(0).(func() string); ok {
	180	+	r0 = returnFunc()
	181	+	} else {
	182	+	r0 = ret.Get(0).(string)
	183	+	}
	184	+	return r0
	185	+	}
	186	+
	187	+	// MockLabelWidget_GetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetText'
	188	+	type MockLabelWidget_GetText_Call struct {
	189	+	*mock.Call
	190	+	}
	191	+
	192	+	// GetText is a helper method to define mock.On call
	193	+	func (_e MockLabelWidget_Expecter) GetText() MockLabelWidget_GetText_Call {
	194	+	return &MockLabelWidget_GetText_Call{Call: _e.mock.On("GetText")}
	195	+	}
	196	+
	197	+	func (_c MockLabelWidget_GetText_Call) Run(run func()) MockLabelWidget_GetText_Call {
	198	+	_c.Call.Run(func(args mock.Arguments) {
	199	+	run()
	200	+	})
	201	+	return _c
	202	+	}
	203	+
	204	+	func (_c MockLabelWidget_GetText_Call) Return(s string) MockLabelWidget_GetText_Call {
	205	+	_c.Call.Return(s)
	206	+	return _c
	207	+	}
	208	+
	209	+	func (_c MockLabelWidget_GetText_Call) RunAndReturn(run func() string) MockLabelWidget_GetText_Call {
	210	+	_c.Call.Return(run)
	211	+	return _c
	212	+	}
	213	+
	214	+	// GetVexpand provides a mock function for the type MockLabelWidget
	215	+	func (_mock *MockLabelWidget) GetVexpand() bool {
	216	+	ret := _mock.Called()
	217	+
	218	+	if len(ret) == 0 {
	219	+	panic("no return value specified for GetVexpand")
	220	+	}
	221	+
	222	+	var r0 bool
	223	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	224	+	r0 = returnFunc()
	225	+	} else {
	226	+	r0 = ret.Get(0).(bool)
	227	+	}
	228	+	return r0
	229	+	}
	230	+
	231	+	// MockLabelWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	232	+	type MockLabelWidget_GetVexpand_Call struct {
	233	+	*mock.Call
	234	+	}
	235	+
	236	+	// GetVexpand is a helper method to define mock.On call
	237	+	func (_e MockLabelWidget_Expecter) GetVexpand() MockLabelWidget_GetVexpand_Call {
	238	+	return &MockLabelWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	239	+	}
	240	+
	241	+	func (_c MockLabelWidget_GetVexpand_Call) Run(run func()) MockLabelWidget_GetVexpand_Call {
	242	+	_c.Call.Run(func(args mock.Arguments) {
	243	+	run()
	244	+	})
	245	+	return _c
	246	+	}
	247	+
	248	+	func (_c MockLabelWidget_GetVexpand_Call) Return(b bool) MockLabelWidget_GetVexpand_Call {
	249	+	_c.Call.Return(b)
	250	+	return _c
	251	+	}
	252	+
	253	+	func (_c MockLabelWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockLabelWidget_GetVexpand_Call {
	254	+	_c.Call.Return(run)
	255	+	return _c
	256	+	}
	257	+
	258	+	// GrabFocus provides a mock function for the type MockLabelWidget
	259	+	func (_mock *MockLabelWidget) GrabFocus() bool {
	260	+	ret := _mock.Called()
	261	+
	262	+	if len(ret) == 0 {
	263	+	panic("no return value specified for GrabFocus")
	264	+	}
	265	+
	266	+	var r0 bool
	267	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	268	+	r0 = returnFunc()
	269	+	} else {
	270	+	r0 = ret.Get(0).(bool)
	271	+	}
	272	+	return r0
	273	+	}
	274	+
	275	+	// MockLabelWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	276	+	type MockLabelWidget_GrabFocus_Call struct {
	277	+	*mock.Call
	278	+	}
	279	+
	280	+	// GrabFocus is a helper method to define mock.On call
	281	+	func (_e MockLabelWidget_Expecter) GrabFocus() MockLabelWidget_GrabFocus_Call {
	282	+	return &MockLabelWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	283	+	}
	284	+
	285	+	func (_c MockLabelWidget_GrabFocus_Call) Run(run func()) MockLabelWidget_GrabFocus_Call {
	286	+	_c.Call.Run(func(args mock.Arguments) {
	287	+	run()
	288	+	})
	289	+	return _c
	290	+	}
	291	+
	292	+	func (_c MockLabelWidget_GrabFocus_Call) Return(b bool) MockLabelWidget_GrabFocus_Call {
	293	+	_c.Call.Return(b)
	294	+	return _c
	295	+	}
	296	+
	297	+	func (_c MockLabelWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockLabelWidget_GrabFocus_Call {
	298	+	_c.Call.Return(run)
	299	+	return _c
	300	+	}
	301	+
	302	+	// GtkWidget provides a mock function for the type MockLabelWidget
	303	+	func (_mock MockLabelWidget) GtkWidget() gtk.Widget {
	304	+	ret := _mock.Called()
	305	+
	306	+	if len(ret) == 0 {
	307	+	panic("no return value specified for GtkWidget")
	308	+	}
	309	+
	310	+	var r0 *gtk.Widget
	311	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	312	+	r0 = returnFunc()
	313	+	} else {
	314	+	if ret.Get(0) != nil {
	315	+	r0 = ret.Get(0).(*gtk.Widget)
	316	+	}
	317	+	}
	318	+	return r0
	319	+	}
	320	+
	321	+	// MockLabelWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	322	+	type MockLabelWidget_GtkWidget_Call struct {
	323	+	*mock.Call
	324	+	}
	325	+
	326	+	// GtkWidget is a helper method to define mock.On call
	327	+	func (_e MockLabelWidget_Expecter) GtkWidget() MockLabelWidget_GtkWidget_Call {
	328	+	return &MockLabelWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	329	+	}
	330	+
	331	+	func (_c MockLabelWidget_GtkWidget_Call) Run(run func()) MockLabelWidget_GtkWidget_Call {
	332	+	_c.Call.Run(func(args mock.Arguments) {
	333	+	run()
	334	+	})
	335	+	return _c
	336	+	}
	337	+
	338	+	func (_c MockLabelWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockLabelWidget_GtkWidget_Call {
	339	+	_c.Call.Return(widget)
	340	+	return _c
	341	+	}
	342	+
	343	+	func (_c MockLabelWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockLabelWidget_GtkWidget_Call {
	344	+	_c.Call.Return(run)
	345	+	return _c
	346	+	}
	347	+
	348	+	// HasCssClass provides a mock function for the type MockLabelWidget
	349	+	func (_mock *MockLabelWidget) HasCssClass(cssClass string) bool {
	350	+	ret := _mock.Called(cssClass)
	351	+
	352	+	if len(ret) == 0 {
	353	+	panic("no return value specified for HasCssClass")
	354	+	}
	355	+
	356	+	var r0 bool
	357	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	358	+	r0 = returnFunc(cssClass)
	359	+	} else {
	360	+	r0 = ret.Get(0).(bool)
	361	+	}
	362	+	return r0
	363	+	}
	364	+
	365	+	// MockLabelWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	366	+	type MockLabelWidget_HasCssClass_Call struct {
	367	+	*mock.Call
	368	+	}
	369	+
	370	+	// HasCssClass is a helper method to define mock.On call
	371	+	// - cssClass string
	372	+	func (_e MockLabelWidget_Expecter) HasCssClass(cssClass interface{}) MockLabelWidget_HasCssClass_Call {
	373	+	return &MockLabelWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	374	+	}
	375	+
	376	+	func (_c MockLabelWidget_HasCssClass_Call) Run(run func(cssClass string)) MockLabelWidget_HasCssClass_Call {
	377	+	_c.Call.Run(func(args mock.Arguments) {
	378	+	var arg0 string
	379	+	if args[0] != nil {
	380	+	arg0 = args[0].(string)
	381	+	}
	382	+	run(
	383	+	arg0,
	384	+	)
	385	+	})
	386	+	return _c
	387	+	}
	388	+
	389	+	func (_c MockLabelWidget_HasCssClass_Call) Return(b bool) MockLabelWidget_HasCssClass_Call {
	390	+	_c.Call.Return(b)
	391	+	return _c
	392	+	}
	393	+
	394	+	func (_c MockLabelWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockLabelWidget_HasCssClass_Call {
	395	+	_c.Call.Return(run)
	396	+	return _c
	397	+	}
	398	+
	399	+	// HasFocus provides a mock function for the type MockLabelWidget
	400	+	func (_mock *MockLabelWidget) HasFocus() bool {
	401	+	ret := _mock.Called()
	402	+
	403	+	if len(ret) == 0 {
	404	+	panic("no return value specified for HasFocus")
	405	+	}
	406	+
	407	+	var r0 bool
	408	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	409	+	r0 = returnFunc()
	410	+	} else {
	411	+	r0 = ret.Get(0).(bool)
	412	+	}
	413	+	return r0
	414	+	}
	415	+
	416	+	// MockLabelWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	417	+	type MockLabelWidget_HasFocus_Call struct {
	418	+	*mock.Call
	419	+	}
	420	+
	421	+	// HasFocus is a helper method to define mock.On call
	422	+	func (_e MockLabelWidget_Expecter) HasFocus() MockLabelWidget_HasFocus_Call {
	423	+	return &MockLabelWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	424	+	}
	425	+
	426	+	func (_c MockLabelWidget_HasFocus_Call) Run(run func()) MockLabelWidget_HasFocus_Call {
	427	+	_c.Call.Run(func(args mock.Arguments) {
	428	+	run()
	429	+	})
	430	+	return _c
	431	+	}
	432	+
	433	+	func (_c MockLabelWidget_HasFocus_Call) Return(b bool) MockLabelWidget_HasFocus_Call {
	434	+	_c.Call.Return(b)
	435	+	return _c
	436	+	}
	437	+
	438	+	func (_c MockLabelWidget_HasFocus_Call) RunAndReturn(run func() bool) MockLabelWidget_HasFocus_Call {
	439	+	_c.Call.Return(run)
	440	+	return _c
	441	+	}
	442	+
	443	+	// Hide provides a mock function for the type MockLabelWidget
	444	+	func (_mock *MockLabelWidget) Hide() {
	445	+	_mock.Called()
	446	+	return
	447	+	}
	448	+
	449	+	// MockLabelWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	450	+	type MockLabelWidget_Hide_Call struct {
	451	+	*mock.Call
	452	+	}
	453	+
	454	+	// Hide is a helper method to define mock.On call
	455	+	func (_e MockLabelWidget_Expecter) Hide() MockLabelWidget_Hide_Call {
	456	+	return &MockLabelWidget_Hide_Call{Call: _e.mock.On("Hide")}
	457	+	}
	458	+
	459	+	func (_c MockLabelWidget_Hide_Call) Run(run func()) MockLabelWidget_Hide_Call {
	460	+	_c.Call.Run(func(args mock.Arguments) {
	461	+	run()
	462	+	})
	463	+	return _c
	464	+	}
	465	+
	466	+	func (_c MockLabelWidget_Hide_Call) Return() MockLabelWidget_Hide_Call {
	467	+	_c.Call.Return()
	468	+	return _c
	469	+	}
	470	+
	471	+	func (_c MockLabelWidget_Hide_Call) RunAndReturn(run func()) MockLabelWidget_Hide_Call {
	472	+	_c.Run(run)
	473	+	return _c
	474	+	}
	475	+
	476	+	// IsVisible provides a mock function for the type MockLabelWidget
	477	+	func (_mock *MockLabelWidget) IsVisible() bool {
	478	+	ret := _mock.Called()
	479	+
	480	+	if len(ret) == 0 {
	481	+	panic("no return value specified for IsVisible")
	482	+	}
	483	+
	484	+	var r0 bool
	485	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	486	+	r0 = returnFunc()
	487	+	} else {
	488	+	r0 = ret.Get(0).(bool)
	489	+	}
	490	+	return r0
	491	+	}
	492	+
	493	+	// MockLabelWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	494	+	type MockLabelWidget_IsVisible_Call struct {
	495	+	*mock.Call
	496	+	}
	497	+
	498	+	// IsVisible is a helper method to define mock.On call
	499	+	func (_e MockLabelWidget_Expecter) IsVisible() MockLabelWidget_IsVisible_Call {
	500	+	return &MockLabelWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	501	+	}
	502	+
	503	+	func (_c MockLabelWidget_IsVisible_Call) Run(run func()) MockLabelWidget_IsVisible_Call {
	504	+	_c.Call.Run(func(args mock.Arguments) {
	505	+	run()
	506	+	})
	507	+	return _c
	508	+	}
	509	+
	510	+	func (_c MockLabelWidget_IsVisible_Call) Return(b bool) MockLabelWidget_IsVisible_Call {
	511	+	_c.Call.Return(b)
	512	+	return _c
	513	+	}
	514	+
	515	+	func (_c MockLabelWidget_IsVisible_Call) RunAndReturn(run func() bool) MockLabelWidget_IsVisible_Call {
	516	+	_c.Call.Return(run)
	517	+	return _c
	518	+	}
	519	+
	520	+	// RemoveCssClass provides a mock function for the type MockLabelWidget
	521	+	func (_mock *MockLabelWidget) RemoveCssClass(cssClass string) {
	522	+	_mock.Called(cssClass)
	523	+	return
	524	+	}
	525	+
	526	+	// MockLabelWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	527	+	type MockLabelWidget_RemoveCssClass_Call struct {
	528	+	*mock.Call
	529	+	}
	530	+
	531	+	// RemoveCssClass is a helper method to define mock.On call
	532	+	// - cssClass string
	533	+	func (_e MockLabelWidget_Expecter) RemoveCssClass(cssClass interface{}) MockLabelWidget_RemoveCssClass_Call {
	534	+	return &MockLabelWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	535	+	}
	536	+
	537	+	func (_c MockLabelWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockLabelWidget_RemoveCssClass_Call {
	538	+	_c.Call.Run(func(args mock.Arguments) {
	539	+	var arg0 string
	540	+	if args[0] != nil {
	541	+	arg0 = args[0].(string)
	542	+	}
	543	+	run(
	544	+	arg0,
	545	+	)
	546	+	})
	547	+	return _c
	548	+	}
	549	+
	550	+	func (_c MockLabelWidget_RemoveCssClass_Call) Return() MockLabelWidget_RemoveCssClass_Call {
	551	+	_c.Call.Return()
	552	+	return _c
	553	+	}
	554	+
	555	+	func (_c MockLabelWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockLabelWidget_RemoveCssClass_Call {
	556	+	_c.Run(run)
	557	+	return _c
	558	+	}
	559	+
	560	+	// SetCanFocus provides a mock function for the type MockLabelWidget
	561	+	func (_mock *MockLabelWidget) SetCanFocus(canFocus bool) {
	562	+	_mock.Called(canFocus)
	563	+	return
	564	+	}
	565	+
	566	+	// MockLabelWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	567	+	type MockLabelWidget_SetCanFocus_Call struct {
	568	+	*mock.Call
	569	+	}
	570	+
	571	+	// SetCanFocus is a helper method to define mock.On call
	572	+	// - canFocus bool
	573	+	func (_e MockLabelWidget_Expecter) SetCanFocus(canFocus interface{}) MockLabelWidget_SetCanFocus_Call {
	574	+	return &MockLabelWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	575	+	}
	576	+
	577	+	func (_c MockLabelWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockLabelWidget_SetCanFocus_Call {
	578	+	_c.Call.Run(func(args mock.Arguments) {
	579	+	var arg0 bool
	580	+	if args[0] != nil {
	581	+	arg0 = args[0].(bool)
	582	+	}
	583	+	run(
	584	+	arg0,
	585	+	)
	586	+	})
	587	+	return _c
	588	+	}
	589	+
	590	+	func (_c MockLabelWidget_SetCanFocus_Call) Return() MockLabelWidget_SetCanFocus_Call {
	591	+	_c.Call.Return()
	592	+	return _c
	593	+	}
	594	+
	595	+	func (_c MockLabelWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockLabelWidget_SetCanFocus_Call {
	596	+	_c.Run(run)
	597	+	return _c
	598	+	}
	599	+
	600	+	// SetEllipsize provides a mock function for the type MockLabelWidget
	601	+	func (_mock *MockLabelWidget) SetEllipsize(mode layout.EllipsizeMode) {
	602	+	_mock.Called(mode)
	603	+	return
	604	+	}
	605	+
	606	+	// MockLabelWidget_SetEllipsize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEllipsize'
	607	+	type MockLabelWidget_SetEllipsize_Call struct {
	608	+	*mock.Call
	609	+	}
	610	+
	611	+	// SetEllipsize is a helper method to define mock.On call
	612	+	// - mode layout.EllipsizeMode
	613	+	func (_e MockLabelWidget_Expecter) SetEllipsize(mode interface{}) MockLabelWidget_SetEllipsize_Call {
	614	+	return &MockLabelWidget_SetEllipsize_Call{Call: _e.mock.On("SetEllipsize", mode)}
	615	+	}
	616	+
	617	+	func (_c MockLabelWidget_SetEllipsize_Call) Run(run func(mode layout.EllipsizeMode)) MockLabelWidget_SetEllipsize_Call {
	618	+	_c.Call.Run(func(args mock.Arguments) {
	619	+	var arg0 layout.EllipsizeMode
	620	+	if args[0] != nil {
	621	+	arg0 = args[0].(layout.EllipsizeMode)
	622	+	}
	623	+	run(
	624	+	arg0,
	625	+	)
	626	+	})
	627	+	return _c
	628	+	}
	629	+
	630	+	func (_c MockLabelWidget_SetEllipsize_Call) Return() MockLabelWidget_SetEllipsize_Call {
	631	+	_c.Call.Return()
	632	+	return _c
	633	+	}
	634	+
	635	+	func (_c MockLabelWidget_SetEllipsize_Call) RunAndReturn(run func(mode layout.EllipsizeMode)) MockLabelWidget_SetEllipsize_Call {
	636	+	_c.Run(run)
	637	+	return _c
	638	+	}
	639	+
	640	+	// SetFocusOnClick provides a mock function for the type MockLabelWidget
	641	+	func (_mock *MockLabelWidget) SetFocusOnClick(focusOnClick bool) {
	642	+	_mock.Called(focusOnClick)
	643	+	return
	644	+	}
	645	+
	646	+	// MockLabelWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	647	+	type MockLabelWidget_SetFocusOnClick_Call struct {
	648	+	*mock.Call
	649	+	}
	650	+
	651	+	// SetFocusOnClick is a helper method to define mock.On call
	652	+	// - focusOnClick bool
	653	+	func (_e MockLabelWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockLabelWidget_SetFocusOnClick_Call {
	654	+	return &MockLabelWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	655	+	}
	656	+
	657	+	func (_c MockLabelWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockLabelWidget_SetFocusOnClick_Call {
	658	+	_c.Call.Run(func(args mock.Arguments) {
	659	+	var arg0 bool
	660	+	if args[0] != nil {
	661	+	arg0 = args[0].(bool)
	662	+	}
	663	+	run(
	664	+	arg0,
	665	+	)
	666	+	})
	667	+	return _c
	668	+	}
	669	+
	670	+	func (_c MockLabelWidget_SetFocusOnClick_Call) Return() MockLabelWidget_SetFocusOnClick_Call {
	671	+	_c.Call.Return()
	672	+	return _c
	673	+	}
	674	+
	675	+	func (_c MockLabelWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockLabelWidget_SetFocusOnClick_Call {
	676	+	_c.Run(run)
	677	+	return _c
	678	+	}
	679	+
	680	+	// SetHalign provides a mock function for the type MockLabelWidget
	681	+	func (_mock *MockLabelWidget) SetHalign(align gtk.Align) {
	682	+	_mock.Called(align)
	683	+	return
	684	+	}
	685	+
	686	+	// MockLabelWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	687	+	type MockLabelWidget_SetHalign_Call struct {
	688	+	*mock.Call
	689	+	}
	690	+
	691	+	// SetHalign is a helper method to define mock.On call
	692	+	// - align gtk.Align
	693	+	func (_e MockLabelWidget_Expecter) SetHalign(align interface{}) MockLabelWidget_SetHalign_Call {
	694	+	return &MockLabelWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	695	+	}
	696	+
	697	+	func (_c MockLabelWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockLabelWidget_SetHalign_Call {
	698	+	_c.Call.Run(func(args mock.Arguments) {
	699	+	var arg0 gtk.Align
	700	+	if args[0] != nil {
	701	+	arg0 = args[0].(gtk.Align)
	702	+	}
	703	+	run(
	704	+	arg0,
	705	+	)
	706	+	})
	707	+	return _c
	708	+	}
	709	+
	710	+	func (_c MockLabelWidget_SetHalign_Call) Return() MockLabelWidget_SetHalign_Call {
	711	+	_c.Call.Return()
	712	+	return _c
	713	+	}
	714	+
	715	+	func (_c MockLabelWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockLabelWidget_SetHalign_Call {
	716	+	_c.Run(run)
	717	+	return _c
	718	+	}
	719	+
	720	+	// SetHexpand provides a mock function for the type MockLabelWidget
	721	+	func (_mock *MockLabelWidget) SetHexpand(expand bool) {
	722	+	_mock.Called(expand)
	723	+	return
	724	+	}
	725	+
	726	+	// MockLabelWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	727	+	type MockLabelWidget_SetHexpand_Call struct {
	728	+	*mock.Call
	729	+	}
	730	+
	731	+	// SetHexpand is a helper method to define mock.On call
	732	+	// - expand bool
	733	+	func (_e MockLabelWidget_Expecter) SetHexpand(expand interface{}) MockLabelWidget_SetHexpand_Call {
	734	+	return &MockLabelWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	735	+	}
	736	+
	737	+	func (_c MockLabelWidget_SetHexpand_Call) Run(run func(expand bool)) MockLabelWidget_SetHexpand_Call {
	738	+	_c.Call.Run(func(args mock.Arguments) {
	739	+	var arg0 bool
	740	+	if args[0] != nil {
	741	+	arg0 = args[0].(bool)
	742	+	}
	743	+	run(
	744	+	arg0,
	745	+	)
	746	+	})
	747	+	return _c
	748	+	}
	749	+
	750	+	func (_c MockLabelWidget_SetHexpand_Call) Return() MockLabelWidget_SetHexpand_Call {
	751	+	_c.Call.Return()
	752	+	return _c
	753	+	}
	754	+
	755	+	func (_c MockLabelWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockLabelWidget_SetHexpand_Call {
	756	+	_c.Run(run)
	757	+	return _c
	758	+	}
	759	+
	760	+	// SetMarkup provides a mock function for the type MockLabelWidget
	761	+	func (_mock *MockLabelWidget) SetMarkup(markup string) {
	762	+	_mock.Called(markup)
	763	+	return
	764	+	}
	765	+
	766	+	// MockLabelWidget_SetMarkup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMarkup'
	767	+	type MockLabelWidget_SetMarkup_Call struct {
	768	+	*mock.Call
	769	+	}
	770	+
	771	+	// SetMarkup is a helper method to define mock.On call
	772	+	// - markup string
	773	+	func (_e MockLabelWidget_Expecter) SetMarkup(markup interface{}) MockLabelWidget_SetMarkup_Call {
	774	+	return &MockLabelWidget_SetMarkup_Call{Call: _e.mock.On("SetMarkup", markup)}
	775	+	}
	776	+
	777	+	func (_c MockLabelWidget_SetMarkup_Call) Run(run func(markup string)) MockLabelWidget_SetMarkup_Call {
	778	+	_c.Call.Run(func(args mock.Arguments) {
	779	+	var arg0 string
	780	+	if args[0] != nil {
	781	+	arg0 = args[0].(string)
	782	+	}
	783	+	run(
	784	+	arg0,
	785	+	)
	786	+	})
	787	+	return _c
	788	+	}
	789	+
	790	+	func (_c MockLabelWidget_SetMarkup_Call) Return() MockLabelWidget_SetMarkup_Call {
	791	+	_c.Call.Return()
	792	+	return _c
	793	+	}
	794	+
	795	+	func (_c MockLabelWidget_SetMarkup_Call) RunAndReturn(run func(markup string)) MockLabelWidget_SetMarkup_Call {
	796	+	_c.Run(run)
	797	+	return _c
	798	+	}
	799	+
	800	+	// SetMaxWidthChars provides a mock function for the type MockLabelWidget
	801	+	func (_mock *MockLabelWidget) SetMaxWidthChars(nChars int) {
	802	+	_mock.Called(nChars)
	803	+	return
	804	+	}
	805	+
	806	+	// MockLabelWidget_SetMaxWidthChars_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMaxWidthChars'
	807	+	type MockLabelWidget_SetMaxWidthChars_Call struct {
	808	+	*mock.Call
	809	+	}
	810	+
	811	+	// SetMaxWidthChars is a helper method to define mock.On call
	812	+	// - nChars int
	813	+	func (_e MockLabelWidget_Expecter) SetMaxWidthChars(nChars interface{}) MockLabelWidget_SetMaxWidthChars_Call {
	814	+	return &MockLabelWidget_SetMaxWidthChars_Call{Call: _e.mock.On("SetMaxWidthChars", nChars)}
	815	+	}
	816	+
	817	+	func (_c MockLabelWidget_SetMaxWidthChars_Call) Run(run func(nChars int)) MockLabelWidget_SetMaxWidthChars_Call {
	818	+	_c.Call.Run(func(args mock.Arguments) {
	819	+	var arg0 int
	820	+	if args[0] != nil {
	821	+	arg0 = args[0].(int)
	822	+	}
	823	+	run(
	824	+	arg0,
	825	+	)
	826	+	})
	827	+	return _c
	828	+	}
	829	+
	830	+	func (_c MockLabelWidget_SetMaxWidthChars_Call) Return() MockLabelWidget_SetMaxWidthChars_Call {
	831	+	_c.Call.Return()
	832	+	return _c
	833	+	}
	834	+
	835	+	func (_c MockLabelWidget_SetMaxWidthChars_Call) RunAndReturn(run func(nChars int)) MockLabelWidget_SetMaxWidthChars_Call {
	836	+	_c.Run(run)
	837	+	return _c
	838	+	}
	839	+
	840	+	// SetSizeRequest provides a mock function for the type MockLabelWidget
	841	+	func (_mock *MockLabelWidget) SetSizeRequest(width int, height int) {
	842	+	_mock.Called(width, height)
	843	+	return
	844	+	}
	845	+
	846	+	// MockLabelWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	847	+	type MockLabelWidget_SetSizeRequest_Call struct {
	848	+	*mock.Call
	849	+	}
	850	+
	851	+	// SetSizeRequest is a helper method to define mock.On call
	852	+	// - width int
	853	+	// - height int
	854	+	func (_e MockLabelWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockLabelWidget_SetSizeRequest_Call {
	855	+	return &MockLabelWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	856	+	}
	857	+
	858	+	func (_c MockLabelWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockLabelWidget_SetSizeRequest_Call {
	859	+	_c.Call.Run(func(args mock.Arguments) {
	860	+	var arg0 int
	861	+	if args[0] != nil {
	862	+	arg0 = args[0].(int)
	863	+	}
	864	+	var arg1 int
	865	+	if args[1] != nil {
	866	+	arg1 = args[1].(int)
	867	+	}
	868	+	run(
	869	+	arg0,
	870	+	arg1,
	871	+	)
	872	+	})
	873	+	return _c
	874	+	}
	875	+
	876	+	func (_c MockLabelWidget_SetSizeRequest_Call) Return() MockLabelWidget_SetSizeRequest_Call {
	877	+	_c.Call.Return()
	878	+	return _c
	879	+	}
	880	+
	881	+	func (_c MockLabelWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockLabelWidget_SetSizeRequest_Call {
	882	+	_c.Run(run)
	883	+	return _c
	884	+	}
	885	+
	886	+	// SetText provides a mock function for the type MockLabelWidget
	887	+	func (_mock *MockLabelWidget) SetText(text string) {
	888	+	_mock.Called(text)
	889	+	return
	890	+	}
	891	+
	892	+	// MockLabelWidget_SetText_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetText'
	893	+	type MockLabelWidget_SetText_Call struct {
	894	+	*mock.Call
	895	+	}
	896	+
	897	+	// SetText is a helper method to define mock.On call
	898	+	// - text string
	899	+	func (_e MockLabelWidget_Expecter) SetText(text interface{}) MockLabelWidget_SetText_Call {
	900	+	return &MockLabelWidget_SetText_Call{Call: _e.mock.On("SetText", text)}
	901	+	}
	902	+
	903	+	func (_c MockLabelWidget_SetText_Call) Run(run func(text string)) MockLabelWidget_SetText_Call {
	904	+	_c.Call.Run(func(args mock.Arguments) {
	905	+	var arg0 string
	906	+	if args[0] != nil {
	907	+	arg0 = args[0].(string)
	908	+	}
	909	+	run(
	910	+	arg0,
	911	+	)
	912	+	})
	913	+	return _c
	914	+	}
	915	+
	916	+	func (_c MockLabelWidget_SetText_Call) Return() MockLabelWidget_SetText_Call {
	917	+	_c.Call.Return()
	918	+	return _c
	919	+	}
	920	+
	921	+	func (_c MockLabelWidget_SetText_Call) RunAndReturn(run func(text string)) MockLabelWidget_SetText_Call {
	922	+	_c.Run(run)
	923	+	return _c
	924	+	}
	925	+
	926	+	// SetValign provides a mock function for the type MockLabelWidget
	927	+	func (_mock *MockLabelWidget) SetValign(align gtk.Align) {
	928	+	_mock.Called(align)
	929	+	return
	930	+	}
	931	+
	932	+	// MockLabelWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	933	+	type MockLabelWidget_SetValign_Call struct {
	934	+	*mock.Call
	935	+	}
	936	+
	937	+	// SetValign is a helper method to define mock.On call
	938	+	// - align gtk.Align
	939	+	func (_e MockLabelWidget_Expecter) SetValign(align interface{}) MockLabelWidget_SetValign_Call {
	940	+	return &MockLabelWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	941	+	}
	942	+
	943	+	func (_c MockLabelWidget_SetValign_Call) Run(run func(align gtk.Align)) MockLabelWidget_SetValign_Call {
	944	+	_c.Call.Run(func(args mock.Arguments) {
	945	+	var arg0 gtk.Align
	946	+	if args[0] != nil {
	947	+	arg0 = args[0].(gtk.Align)
	948	+	}
	949	+	run(
	950	+	arg0,
	951	+	)
	952	+	})
	953	+	return _c
	954	+	}
	955	+
	956	+	func (_c MockLabelWidget_SetValign_Call) Return() MockLabelWidget_SetValign_Call {
	957	+	_c.Call.Return()
	958	+	return _c
	959	+	}
	960	+
	961	+	func (_c MockLabelWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockLabelWidget_SetValign_Call {
	962	+	_c.Run(run)
	963	+	return _c
	964	+	}
	965	+
	966	+	// SetVexpand provides a mock function for the type MockLabelWidget
	967	+	func (_mock *MockLabelWidget) SetVexpand(expand bool) {
	968	+	_mock.Called(expand)
	969	+	return
	970	+	}
	971	+
	972	+	// MockLabelWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	973	+	type MockLabelWidget_SetVexpand_Call struct {
	974	+	*mock.Call
	975	+	}
	976	+
	977	+	// SetVexpand is a helper method to define mock.On call
	978	+	// - expand bool
	979	+	func (_e MockLabelWidget_Expecter) SetVexpand(expand interface{}) MockLabelWidget_SetVexpand_Call {
	980	+	return &MockLabelWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	981	+	}
	982	+
	983	+	func (_c MockLabelWidget_SetVexpand_Call) Run(run func(expand bool)) MockLabelWidget_SetVexpand_Call {
	984	+	_c.Call.Run(func(args mock.Arguments) {
	985	+	var arg0 bool
	986	+	if args[0] != nil {
	987	+	arg0 = args[0].(bool)
	988	+	}
	989	+	run(
	990	+	arg0,
	991	+	)
	992	+	})
	993	+	return _c
	994	+	}
	995	+
	996	+	func (_c MockLabelWidget_SetVexpand_Call) Return() MockLabelWidget_SetVexpand_Call {
	997	+	_c.Call.Return()
	998	+	return _c
	999	+	}
	1000	+
	1001	+	func (_c MockLabelWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockLabelWidget_SetVexpand_Call {
	1002	+	_c.Run(run)
	1003	+	return _c
	1004	+	}
	1005	+
	1006	+	// SetVisible provides a mock function for the type MockLabelWidget
	1007	+	func (_mock *MockLabelWidget) SetVisible(visible bool) {
	1008	+	_mock.Called(visible)
	1009	+	return
	1010	+	}
	1011	+
	1012	+	// MockLabelWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	1013	+	type MockLabelWidget_SetVisible_Call struct {
	1014	+	*mock.Call
	1015	+	}
	1016	+
	1017	+	// SetVisible is a helper method to define mock.On call
	1018	+	// - visible bool
	1019	+	func (_e MockLabelWidget_Expecter) SetVisible(visible interface{}) MockLabelWidget_SetVisible_Call {
	1020	+	return &MockLabelWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	1021	+	}
	1022	+
	1023	+	func (_c MockLabelWidget_SetVisible_Call) Run(run func(visible bool)) MockLabelWidget_SetVisible_Call {
	1024	+	_c.Call.Run(func(args mock.Arguments) {
	1025	+	var arg0 bool
	1026	+	if args[0] != nil {
	1027	+	arg0 = args[0].(bool)
	1028	+	}
	1029	+	run(
	1030	+	arg0,
	1031	+	)
	1032	+	})
	1033	+	return _c
	1034	+	}
	1035	+
	1036	+	func (_c MockLabelWidget_SetVisible_Call) Return() MockLabelWidget_SetVisible_Call {
	1037	+	_c.Call.Return()
	1038	+	return _c
	1039	+	}
	1040	+
	1041	+	func (_c MockLabelWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockLabelWidget_SetVisible_Call {
	1042	+	_c.Run(run)
	1043	+	return _c
	1044	+	}
	1045	+
	1046	+	// SetXalign provides a mock function for the type MockLabelWidget
	1047	+	func (_mock *MockLabelWidget) SetXalign(xalign float32) {
	1048	+	_mock.Called(xalign)
	1049	+	return
	1050	+	}
	1051	+
	1052	+	// MockLabelWidget_SetXalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetXalign'
	1053	+	type MockLabelWidget_SetXalign_Call struct {
	1054	+	*mock.Call
	1055	+	}
	1056	+
	1057	+	// SetXalign is a helper method to define mock.On call
	1058	+	// - xalign float32
	1059	+	func (_e MockLabelWidget_Expecter) SetXalign(xalign interface{}) MockLabelWidget_SetXalign_Call {
	1060	+	return &MockLabelWidget_SetXalign_Call{Call: _e.mock.On("SetXalign", xalign)}
	1061	+	}
	1062	+
	1063	+	func (_c MockLabelWidget_SetXalign_Call) Run(run func(xalign float32)) MockLabelWidget_SetXalign_Call {
	1064	+	_c.Call.Run(func(args mock.Arguments) {
	1065	+	var arg0 float32
	1066	+	if args[0] != nil {
	1067	+	arg0 = args[0].(float32)
	1068	+	}
	1069	+	run(
	1070	+	arg0,
	1071	+	)
	1072	+	})
	1073	+	return _c
	1074	+	}
	1075	+
	1076	+	func (_c MockLabelWidget_SetXalign_Call) Return() MockLabelWidget_SetXalign_Call {
	1077	+	_c.Call.Return()
	1078	+	return _c
	1079	+	}
	1080	+
	1081	+	func (_c MockLabelWidget_SetXalign_Call) RunAndReturn(run func(xalign float32)) MockLabelWidget_SetXalign_Call {
	1082	+	_c.Run(run)
	1083	+	return _c
	1084	+	}
	1085	+
	1086	+	// Show provides a mock function for the type MockLabelWidget
	1087	+	func (_mock *MockLabelWidget) Show() {
	1088	+	_mock.Called()
	1089	+	return
	1090	+	}
	1091	+
	1092	+	// MockLabelWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	1093	+	type MockLabelWidget_Show_Call struct {
	1094	+	*mock.Call
	1095	+	}
	1096	+
	1097	+	// Show is a helper method to define mock.On call
	1098	+	func (_e MockLabelWidget_Expecter) Show() MockLabelWidget_Show_Call {
	1099	+	return &MockLabelWidget_Show_Call{Call: _e.mock.On("Show")}
	1100	+	}
	1101	+
	1102	+	func (_c MockLabelWidget_Show_Call) Run(run func()) MockLabelWidget_Show_Call {
	1103	+	_c.Call.Run(func(args mock.Arguments) {
	1104	+	run()
	1105	+	})
	1106	+	return _c
	1107	+	}
	1108	+
	1109	+	func (_c MockLabelWidget_Show_Call) Return() MockLabelWidget_Show_Call {
	1110	+	_c.Call.Return()
	1111	+	return _c
	1112	+	}
	1113	+
	1114	+	func (_c MockLabelWidget_Show_Call) RunAndReturn(run func()) MockLabelWidget_Show_Call {
	1115	+	_c.Run(run)
	1116	+	return _c
	1117	+	}
	1118	+
	1119	+	// Unparent provides a mock function for the type MockLabelWidget
	1120	+	func (_mock *MockLabelWidget) Unparent() {
	1121	+	_mock.Called()
	1122	+	return
	1123	+	}
	1124	+
	1125	+	// MockLabelWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	1126	+	type MockLabelWidget_Unparent_Call struct {
	1127	+	*mock.Call
	1128	+	}
	1129	+
	1130	+	// Unparent is a helper method to define mock.On call
	1131	+	func (_e MockLabelWidget_Expecter) Unparent() MockLabelWidget_Unparent_Call {
	1132	+	return &MockLabelWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	1133	+	}
	1134	+
	1135	+	func (_c MockLabelWidget_Unparent_Call) Run(run func()) MockLabelWidget_Unparent_Call {
	1136	+	_c.Call.Run(func(args mock.Arguments) {
	1137	+	run()
	1138	+	})
	1139	+	return _c
	1140	+	}
	1141	+
	1142	+	func (_c MockLabelWidget_Unparent_Call) Return() MockLabelWidget_Unparent_Call {
	1143	+	_c.Call.Return()
	1144	+	return _c
	1145	+	}
	1146	+
	1147	+	func (_c MockLabelWidget_Unparent_Call) RunAndReturn(run func()) MockLabelWidget_Unparent_Call {
	1148	+	_c.Run(run)
	1149	+	return _c
	1150	+	}

A internal/ui/layout/mocks/mock_overlay_widget.go +1266 -0

@@ -0,0 +1,1266 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockOverlayWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockOverlayWidget {
	19	+	mock := &MockOverlayWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockOverlayWidget is an autogenerated mock type for the OverlayWidget type
	28	+	type MockOverlayWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockOverlayWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockOverlayWidget) EXPECT() MockOverlayWidget_Expecter {
	37	+	return &MockOverlayWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockOverlayWidget
	41	+	func (_mock *MockOverlayWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockOverlayWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockOverlayWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockOverlayWidget_Expecter) AddCssClass(cssClass interface{}) MockOverlayWidget_AddCssClass_Call {
	54	+	return &MockOverlayWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockOverlayWidget_AddCssClass_Call) Run(run func(cssClass string)) MockOverlayWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockOverlayWidget_AddCssClass_Call) Return() MockOverlayWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockOverlayWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockOverlayWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// AddOverlay provides a mock function for the type MockOverlayWidget
	81	+	func (_mock *MockOverlayWidget) AddOverlay(overlay layout.Widget) {
	82	+	_mock.Called(overlay)
	83	+	return
	84	+	}
	85	+
	86	+	// MockOverlayWidget_AddOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddOverlay'
	87	+	type MockOverlayWidget_AddOverlay_Call struct {
	88	+	*mock.Call
	89	+	}
	90	+
	91	+	// AddOverlay is a helper method to define mock.On call
	92	+	// - overlay layout.Widget
	93	+	func (_e MockOverlayWidget_Expecter) AddOverlay(overlay interface{}) MockOverlayWidget_AddOverlay_Call {
	94	+	return &MockOverlayWidget_AddOverlay_Call{Call: _e.mock.On("AddOverlay", overlay)}
	95	+	}
	96	+
	97	+	func (_c MockOverlayWidget_AddOverlay_Call) Run(run func(overlay layout.Widget)) MockOverlayWidget_AddOverlay_Call {
	98	+	_c.Call.Run(func(args mock.Arguments) {
	99	+	var arg0 layout.Widget
	100	+	if args[0] != nil {
	101	+	arg0 = args[0].(layout.Widget)
	102	+	}
	103	+	run(
	104	+	arg0,
	105	+	)
	106	+	})
	107	+	return _c
	108	+	}
	109	+
	110	+	func (_c MockOverlayWidget_AddOverlay_Call) Return() MockOverlayWidget_AddOverlay_Call {
	111	+	_c.Call.Return()
	112	+	return _c
	113	+	}
	114	+
	115	+	func (_c MockOverlayWidget_AddOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) MockOverlayWidget_AddOverlay_Call {
	116	+	_c.Run(run)
	117	+	return _c
	118	+	}
	119	+
	120	+	// GetChild provides a mock function for the type MockOverlayWidget
	121	+	func (_mock *MockOverlayWidget) GetChild() layout.Widget {
	122	+	ret := _mock.Called()
	123	+
	124	+	if len(ret) == 0 {
	125	+	panic("no return value specified for GetChild")
	126	+	}
	127	+
	128	+	var r0 layout.Widget
	129	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	130	+	r0 = returnFunc()
	131	+	} else {
	132	+	if ret.Get(0) != nil {
	133	+	r0 = ret.Get(0).(layout.Widget)
	134	+	}
	135	+	}
	136	+	return r0
	137	+	}
	138	+
	139	+	// MockOverlayWidget_GetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChild'
	140	+	type MockOverlayWidget_GetChild_Call struct {
	141	+	*mock.Call
	142	+	}
	143	+
	144	+	// GetChild is a helper method to define mock.On call
	145	+	func (_e MockOverlayWidget_Expecter) GetChild() MockOverlayWidget_GetChild_Call {
	146	+	return &MockOverlayWidget_GetChild_Call{Call: _e.mock.On("GetChild")}
	147	+	}
	148	+
	149	+	func (_c MockOverlayWidget_GetChild_Call) Run(run func()) MockOverlayWidget_GetChild_Call {
	150	+	_c.Call.Run(func(args mock.Arguments) {
	151	+	run()
	152	+	})
	153	+	return _c
	154	+	}
	155	+
	156	+	func (_c MockOverlayWidget_GetChild_Call) Return(widget layout.Widget) MockOverlayWidget_GetChild_Call {
	157	+	_c.Call.Return(widget)
	158	+	return _c
	159	+	}
	160	+
	161	+	func (_c MockOverlayWidget_GetChild_Call) RunAndReturn(run func() layout.Widget) MockOverlayWidget_GetChild_Call {
	162	+	_c.Call.Return(run)
	163	+	return _c
	164	+	}
	165	+
	166	+	// GetClipOverlay provides a mock function for the type MockOverlayWidget
	167	+	func (_mock *MockOverlayWidget) GetClipOverlay(overlay layout.Widget) bool {
	168	+	ret := _mock.Called(overlay)
	169	+
	170	+	if len(ret) == 0 {
	171	+	panic("no return value specified for GetClipOverlay")
	172	+	}
	173	+
	174	+	var r0 bool
	175	+	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
	176	+	r0 = returnFunc(overlay)
	177	+	} else {
	178	+	r0 = ret.Get(0).(bool)
	179	+	}
	180	+	return r0
	181	+	}
	182	+
	183	+	// MockOverlayWidget_GetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClipOverlay'
	184	+	type MockOverlayWidget_GetClipOverlay_Call struct {
	185	+	*mock.Call
	186	+	}
	187	+
	188	+	// GetClipOverlay is a helper method to define mock.On call
	189	+	// - overlay layout.Widget
	190	+	func (_e MockOverlayWidget_Expecter) GetClipOverlay(overlay interface{}) MockOverlayWidget_GetClipOverlay_Call {
	191	+	return &MockOverlayWidget_GetClipOverlay_Call{Call: _e.mock.On("GetClipOverlay", overlay)}
	192	+	}
	193	+
	194	+	func (_c MockOverlayWidget_GetClipOverlay_Call) Run(run func(overlay layout.Widget)) MockOverlayWidget_GetClipOverlay_Call {
	195	+	_c.Call.Run(func(args mock.Arguments) {
	196	+	var arg0 layout.Widget
	197	+	if args[0] != nil {
	198	+	arg0 = args[0].(layout.Widget)
	199	+	}
	200	+	run(
	201	+	arg0,
	202	+	)
	203	+	})
	204	+	return _c
	205	+	}
	206	+
	207	+	func (_c MockOverlayWidget_GetClipOverlay_Call) Return(b bool) MockOverlayWidget_GetClipOverlay_Call {
	208	+	_c.Call.Return(b)
	209	+	return _c
	210	+	}
	211	+
	212	+	func (_c MockOverlayWidget_GetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) MockOverlayWidget_GetClipOverlay_Call {
	213	+	_c.Call.Return(run)
	214	+	return _c
	215	+	}
	216	+
	217	+	// GetHexpand provides a mock function for the type MockOverlayWidget
	218	+	func (_mock *MockOverlayWidget) GetHexpand() bool {
	219	+	ret := _mock.Called()
	220	+
	221	+	if len(ret) == 0 {
	222	+	panic("no return value specified for GetHexpand")
	223	+	}
	224	+
	225	+	var r0 bool
	226	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	227	+	r0 = returnFunc()
	228	+	} else {
	229	+	r0 = ret.Get(0).(bool)
	230	+	}
	231	+	return r0
	232	+	}
	233	+
	234	+	// MockOverlayWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	235	+	type MockOverlayWidget_GetHexpand_Call struct {
	236	+	*mock.Call
	237	+	}
	238	+
	239	+	// GetHexpand is a helper method to define mock.On call
	240	+	func (_e MockOverlayWidget_Expecter) GetHexpand() MockOverlayWidget_GetHexpand_Call {
	241	+	return &MockOverlayWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	242	+	}
	243	+
	244	+	func (_c MockOverlayWidget_GetHexpand_Call) Run(run func()) MockOverlayWidget_GetHexpand_Call {
	245	+	_c.Call.Run(func(args mock.Arguments) {
	246	+	run()
	247	+	})
	248	+	return _c
	249	+	}
	250	+
	251	+	func (_c MockOverlayWidget_GetHexpand_Call) Return(b bool) MockOverlayWidget_GetHexpand_Call {
	252	+	_c.Call.Return(b)
	253	+	return _c
	254	+	}
	255	+
	256	+	func (_c MockOverlayWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockOverlayWidget_GetHexpand_Call {
	257	+	_c.Call.Return(run)
	258	+	return _c
	259	+	}
	260	+
	261	+	// GetMeasureOverlay provides a mock function for the type MockOverlayWidget
	262	+	func (_mock *MockOverlayWidget) GetMeasureOverlay(overlay layout.Widget) bool {
	263	+	ret := _mock.Called(overlay)
	264	+
	265	+	if len(ret) == 0 {
	266	+	panic("no return value specified for GetMeasureOverlay")
	267	+	}
	268	+
	269	+	var r0 bool
	270	+	if returnFunc, ok := ret.Get(0).(func(layout.Widget) bool); ok {
	271	+	r0 = returnFunc(overlay)
	272	+	} else {
	273	+	r0 = ret.Get(0).(bool)
	274	+	}
	275	+	return r0
	276	+	}
	277	+
	278	+	// MockOverlayWidget_GetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMeasureOverlay'
	279	+	type MockOverlayWidget_GetMeasureOverlay_Call struct {
	280	+	*mock.Call
	281	+	}
	282	+
	283	+	// GetMeasureOverlay is a helper method to define mock.On call
	284	+	// - overlay layout.Widget
	285	+	func (_e MockOverlayWidget_Expecter) GetMeasureOverlay(overlay interface{}) MockOverlayWidget_GetMeasureOverlay_Call {
	286	+	return &MockOverlayWidget_GetMeasureOverlay_Call{Call: _e.mock.On("GetMeasureOverlay", overlay)}
	287	+	}
	288	+
	289	+	func (_c MockOverlayWidget_GetMeasureOverlay_Call) Run(run func(overlay layout.Widget)) MockOverlayWidget_GetMeasureOverlay_Call {
	290	+	_c.Call.Run(func(args mock.Arguments) {
	291	+	var arg0 layout.Widget
	292	+	if args[0] != nil {
	293	+	arg0 = args[0].(layout.Widget)
	294	+	}
	295	+	run(
	296	+	arg0,
	297	+	)
	298	+	})
	299	+	return _c
	300	+	}
	301	+
	302	+	func (_c MockOverlayWidget_GetMeasureOverlay_Call) Return(b bool) MockOverlayWidget_GetMeasureOverlay_Call {
	303	+	_c.Call.Return(b)
	304	+	return _c
	305	+	}
	306	+
	307	+	func (_c MockOverlayWidget_GetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget) bool) MockOverlayWidget_GetMeasureOverlay_Call {
	308	+	_c.Call.Return(run)
	309	+	return _c
	310	+	}
	311	+
	312	+	// GetParent provides a mock function for the type MockOverlayWidget
	313	+	func (_mock *MockOverlayWidget) GetParent() layout.Widget {
	314	+	ret := _mock.Called()
	315	+
	316	+	if len(ret) == 0 {
	317	+	panic("no return value specified for GetParent")
	318	+	}
	319	+
	320	+	var r0 layout.Widget
	321	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	322	+	r0 = returnFunc()
	323	+	} else {
	324	+	if ret.Get(0) != nil {
	325	+	r0 = ret.Get(0).(layout.Widget)
	326	+	}
	327	+	}
	328	+	return r0
	329	+	}
	330	+
	331	+	// MockOverlayWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	332	+	type MockOverlayWidget_GetParent_Call struct {
	333	+	*mock.Call
	334	+	}
	335	+
	336	+	// GetParent is a helper method to define mock.On call
	337	+	func (_e MockOverlayWidget_Expecter) GetParent() MockOverlayWidget_GetParent_Call {
	338	+	return &MockOverlayWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	339	+	}
	340	+
	341	+	func (_c MockOverlayWidget_GetParent_Call) Run(run func()) MockOverlayWidget_GetParent_Call {
	342	+	_c.Call.Run(func(args mock.Arguments) {
	343	+	run()
	344	+	})
	345	+	return _c
	346	+	}
	347	+
	348	+	func (_c MockOverlayWidget_GetParent_Call) Return(widget layout.Widget) MockOverlayWidget_GetParent_Call {
	349	+	_c.Call.Return(widget)
	350	+	return _c
	351	+	}
	352	+
	353	+	func (_c MockOverlayWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockOverlayWidget_GetParent_Call {
	354	+	_c.Call.Return(run)
	355	+	return _c
	356	+	}
	357	+
	358	+	// GetVexpand provides a mock function for the type MockOverlayWidget
	359	+	func (_mock *MockOverlayWidget) GetVexpand() bool {
	360	+	ret := _mock.Called()
	361	+
	362	+	if len(ret) == 0 {
	363	+	panic("no return value specified for GetVexpand")
	364	+	}
	365	+
	366	+	var r0 bool
	367	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	368	+	r0 = returnFunc()
	369	+	} else {
	370	+	r0 = ret.Get(0).(bool)
	371	+	}
	372	+	return r0
	373	+	}
	374	+
	375	+	// MockOverlayWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	376	+	type MockOverlayWidget_GetVexpand_Call struct {
	377	+	*mock.Call
	378	+	}
	379	+
	380	+	// GetVexpand is a helper method to define mock.On call
	381	+	func (_e MockOverlayWidget_Expecter) GetVexpand() MockOverlayWidget_GetVexpand_Call {
	382	+	return &MockOverlayWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	383	+	}
	384	+
	385	+	func (_c MockOverlayWidget_GetVexpand_Call) Run(run func()) MockOverlayWidget_GetVexpand_Call {
	386	+	_c.Call.Run(func(args mock.Arguments) {
	387	+	run()
	388	+	})
	389	+	return _c
	390	+	}
	391	+
	392	+	func (_c MockOverlayWidget_GetVexpand_Call) Return(b bool) MockOverlayWidget_GetVexpand_Call {
	393	+	_c.Call.Return(b)
	394	+	return _c
	395	+	}
	396	+
	397	+	func (_c MockOverlayWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockOverlayWidget_GetVexpand_Call {
	398	+	_c.Call.Return(run)
	399	+	return _c
	400	+	}
	401	+
	402	+	// GrabFocus provides a mock function for the type MockOverlayWidget
	403	+	func (_mock *MockOverlayWidget) GrabFocus() bool {
	404	+	ret := _mock.Called()
	405	+
	406	+	if len(ret) == 0 {
	407	+	panic("no return value specified for GrabFocus")
	408	+	}
	409	+
	410	+	var r0 bool
	411	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	412	+	r0 = returnFunc()
	413	+	} else {
	414	+	r0 = ret.Get(0).(bool)
	415	+	}
	416	+	return r0
	417	+	}
	418	+
	419	+	// MockOverlayWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	420	+	type MockOverlayWidget_GrabFocus_Call struct {
	421	+	*mock.Call
	422	+	}
	423	+
	424	+	// GrabFocus is a helper method to define mock.On call
	425	+	func (_e MockOverlayWidget_Expecter) GrabFocus() MockOverlayWidget_GrabFocus_Call {
	426	+	return &MockOverlayWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	427	+	}
	428	+
	429	+	func (_c MockOverlayWidget_GrabFocus_Call) Run(run func()) MockOverlayWidget_GrabFocus_Call {
	430	+	_c.Call.Run(func(args mock.Arguments) {
	431	+	run()
	432	+	})
	433	+	return _c
	434	+	}
	435	+
	436	+	func (_c MockOverlayWidget_GrabFocus_Call) Return(b bool) MockOverlayWidget_GrabFocus_Call {
	437	+	_c.Call.Return(b)
	438	+	return _c
	439	+	}
	440	+
	441	+	func (_c MockOverlayWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockOverlayWidget_GrabFocus_Call {
	442	+	_c.Call.Return(run)
	443	+	return _c
	444	+	}
	445	+
	446	+	// GtkWidget provides a mock function for the type MockOverlayWidget
	447	+	func (_mock MockOverlayWidget) GtkWidget() gtk.Widget {
	448	+	ret := _mock.Called()
	449	+
	450	+	if len(ret) == 0 {
	451	+	panic("no return value specified for GtkWidget")
	452	+	}
	453	+
	454	+	var r0 *gtk.Widget
	455	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	456	+	r0 = returnFunc()
	457	+	} else {
	458	+	if ret.Get(0) != nil {
	459	+	r0 = ret.Get(0).(*gtk.Widget)
	460	+	}
	461	+	}
	462	+	return r0
	463	+	}
	464	+
	465	+	// MockOverlayWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	466	+	type MockOverlayWidget_GtkWidget_Call struct {
	467	+	*mock.Call
	468	+	}
	469	+
	470	+	// GtkWidget is a helper method to define mock.On call
	471	+	func (_e MockOverlayWidget_Expecter) GtkWidget() MockOverlayWidget_GtkWidget_Call {
	472	+	return &MockOverlayWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	473	+	}
	474	+
	475	+	func (_c MockOverlayWidget_GtkWidget_Call) Run(run func()) MockOverlayWidget_GtkWidget_Call {
	476	+	_c.Call.Run(func(args mock.Arguments) {
	477	+	run()
	478	+	})
	479	+	return _c
	480	+	}
	481	+
	482	+	func (_c MockOverlayWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
	483	+	_c.Call.Return(widget)
	484	+	return _c
	485	+	}
	486	+
	487	+	func (_c MockOverlayWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockOverlayWidget_GtkWidget_Call {
	488	+	_c.Call.Return(run)
	489	+	return _c
	490	+	}
	491	+
	492	+	// HasCssClass provides a mock function for the type MockOverlayWidget
	493	+	func (_mock *MockOverlayWidget) HasCssClass(cssClass string) bool {
	494	+	ret := _mock.Called(cssClass)
	495	+
	496	+	if len(ret) == 0 {
	497	+	panic("no return value specified for HasCssClass")
	498	+	}
	499	+
	500	+	var r0 bool
	501	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	502	+	r0 = returnFunc(cssClass)
	503	+	} else {
	504	+	r0 = ret.Get(0).(bool)
	505	+	}
	506	+	return r0
	507	+	}
	508	+
	509	+	// MockOverlayWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	510	+	type MockOverlayWidget_HasCssClass_Call struct {
	511	+	*mock.Call
	512	+	}
	513	+
	514	+	// HasCssClass is a helper method to define mock.On call
	515	+	// - cssClass string
	516	+	func (_e MockOverlayWidget_Expecter) HasCssClass(cssClass interface{}) MockOverlayWidget_HasCssClass_Call {
	517	+	return &MockOverlayWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	518	+	}
	519	+
	520	+	func (_c MockOverlayWidget_HasCssClass_Call) Run(run func(cssClass string)) MockOverlayWidget_HasCssClass_Call {
	521	+	_c.Call.Run(func(args mock.Arguments) {
	522	+	var arg0 string
	523	+	if args[0] != nil {
	524	+	arg0 = args[0].(string)
	525	+	}
	526	+	run(
	527	+	arg0,
	528	+	)
	529	+	})
	530	+	return _c
	531	+	}
	532	+
	533	+	func (_c MockOverlayWidget_HasCssClass_Call) Return(b bool) MockOverlayWidget_HasCssClass_Call {
	534	+	_c.Call.Return(b)
	535	+	return _c
	536	+	}
	537	+
	538	+	func (_c MockOverlayWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockOverlayWidget_HasCssClass_Call {
	539	+	_c.Call.Return(run)
	540	+	return _c
	541	+	}
	542	+
	543	+	// HasFocus provides a mock function for the type MockOverlayWidget
	544	+	func (_mock *MockOverlayWidget) HasFocus() bool {
	545	+	ret := _mock.Called()
	546	+
	547	+	if len(ret) == 0 {
	548	+	panic("no return value specified for HasFocus")
	549	+	}
	550	+
	551	+	var r0 bool
	552	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	553	+	r0 = returnFunc()
	554	+	} else {
	555	+	r0 = ret.Get(0).(bool)
	556	+	}
	557	+	return r0
	558	+	}
	559	+
	560	+	// MockOverlayWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	561	+	type MockOverlayWidget_HasFocus_Call struct {
	562	+	*mock.Call
	563	+	}
	564	+
	565	+	// HasFocus is a helper method to define mock.On call
	566	+	func (_e MockOverlayWidget_Expecter) HasFocus() MockOverlayWidget_HasFocus_Call {
	567	+	return &MockOverlayWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	568	+	}
	569	+
	570	+	func (_c MockOverlayWidget_HasFocus_Call) Run(run func()) MockOverlayWidget_HasFocus_Call {
	571	+	_c.Call.Run(func(args mock.Arguments) {
	572	+	run()
	573	+	})
	574	+	return _c
	575	+	}
	576	+
	577	+	func (_c MockOverlayWidget_HasFocus_Call) Return(b bool) MockOverlayWidget_HasFocus_Call {
	578	+	_c.Call.Return(b)
	579	+	return _c
	580	+	}
	581	+
	582	+	func (_c MockOverlayWidget_HasFocus_Call) RunAndReturn(run func() bool) MockOverlayWidget_HasFocus_Call {
	583	+	_c.Call.Return(run)
	584	+	return _c
	585	+	}
	586	+
	587	+	// Hide provides a mock function for the type MockOverlayWidget
	588	+	func (_mock *MockOverlayWidget) Hide() {
	589	+	_mock.Called()
	590	+	return
	591	+	}
	592	+
	593	+	// MockOverlayWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	594	+	type MockOverlayWidget_Hide_Call struct {
	595	+	*mock.Call
	596	+	}
	597	+
	598	+	// Hide is a helper method to define mock.On call
	599	+	func (_e MockOverlayWidget_Expecter) Hide() MockOverlayWidget_Hide_Call {
	600	+	return &MockOverlayWidget_Hide_Call{Call: _e.mock.On("Hide")}
	601	+	}
	602	+
	603	+	func (_c MockOverlayWidget_Hide_Call) Run(run func()) MockOverlayWidget_Hide_Call {
	604	+	_c.Call.Run(func(args mock.Arguments) {
	605	+	run()
	606	+	})
	607	+	return _c
	608	+	}
	609	+
	610	+	func (_c MockOverlayWidget_Hide_Call) Return() MockOverlayWidget_Hide_Call {
	611	+	_c.Call.Return()
	612	+	return _c
	613	+	}
	614	+
	615	+	func (_c MockOverlayWidget_Hide_Call) RunAndReturn(run func()) MockOverlayWidget_Hide_Call {
	616	+	_c.Run(run)
	617	+	return _c
	618	+	}
	619	+
	620	+	// IsVisible provides a mock function for the type MockOverlayWidget
	621	+	func (_mock *MockOverlayWidget) IsVisible() bool {
	622	+	ret := _mock.Called()
	623	+
	624	+	if len(ret) == 0 {
	625	+	panic("no return value specified for IsVisible")
	626	+	}
	627	+
	628	+	var r0 bool
	629	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	630	+	r0 = returnFunc()
	631	+	} else {
	632	+	r0 = ret.Get(0).(bool)
	633	+	}
	634	+	return r0
	635	+	}
	636	+
	637	+	// MockOverlayWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	638	+	type MockOverlayWidget_IsVisible_Call struct {
	639	+	*mock.Call
	640	+	}
	641	+
	642	+	// IsVisible is a helper method to define mock.On call
	643	+	func (_e MockOverlayWidget_Expecter) IsVisible() MockOverlayWidget_IsVisible_Call {
	644	+	return &MockOverlayWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	645	+	}
	646	+
	647	+	func (_c MockOverlayWidget_IsVisible_Call) Run(run func()) MockOverlayWidget_IsVisible_Call {
	648	+	_c.Call.Run(func(args mock.Arguments) {
	649	+	run()
	650	+	})
	651	+	return _c
	652	+	}
	653	+
	654	+	func (_c MockOverlayWidget_IsVisible_Call) Return(b bool) MockOverlayWidget_IsVisible_Call {
	655	+	_c.Call.Return(b)
	656	+	return _c
	657	+	}
	658	+
	659	+	func (_c MockOverlayWidget_IsVisible_Call) RunAndReturn(run func() bool) MockOverlayWidget_IsVisible_Call {
	660	+	_c.Call.Return(run)
	661	+	return _c
	662	+	}
	663	+
	664	+	// RemoveCssClass provides a mock function for the type MockOverlayWidget
	665	+	func (_mock *MockOverlayWidget) RemoveCssClass(cssClass string) {
	666	+	_mock.Called(cssClass)
	667	+	return
	668	+	}
	669	+
	670	+	// MockOverlayWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	671	+	type MockOverlayWidget_RemoveCssClass_Call struct {
	672	+	*mock.Call
	673	+	}
	674	+
	675	+	// RemoveCssClass is a helper method to define mock.On call
	676	+	// - cssClass string
	677	+	func (_e MockOverlayWidget_Expecter) RemoveCssClass(cssClass interface{}) MockOverlayWidget_RemoveCssClass_Call {
	678	+	return &MockOverlayWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	679	+	}
	680	+
	681	+	func (_c MockOverlayWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockOverlayWidget_RemoveCssClass_Call {
	682	+	_c.Call.Run(func(args mock.Arguments) {
	683	+	var arg0 string
	684	+	if args[0] != nil {
	685	+	arg0 = args[0].(string)
	686	+	}
	687	+	run(
	688	+	arg0,
	689	+	)
	690	+	})
	691	+	return _c
	692	+	}
	693	+
	694	+	func (_c MockOverlayWidget_RemoveCssClass_Call) Return() MockOverlayWidget_RemoveCssClass_Call {
	695	+	_c.Call.Return()
	696	+	return _c
	697	+	}
	698	+
	699	+	func (_c MockOverlayWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockOverlayWidget_RemoveCssClass_Call {
	700	+	_c.Run(run)
	701	+	return _c
	702	+	}
	703	+
	704	+	// RemoveOverlay provides a mock function for the type MockOverlayWidget
	705	+	func (_mock *MockOverlayWidget) RemoveOverlay(overlay layout.Widget) {
	706	+	_mock.Called(overlay)
	707	+	return
	708	+	}
	709	+
	710	+	// MockOverlayWidget_RemoveOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOverlay'
	711	+	type MockOverlayWidget_RemoveOverlay_Call struct {
	712	+	*mock.Call
	713	+	}
	714	+
	715	+	// RemoveOverlay is a helper method to define mock.On call
	716	+	// - overlay layout.Widget
	717	+	func (_e MockOverlayWidget_Expecter) RemoveOverlay(overlay interface{}) MockOverlayWidget_RemoveOverlay_Call {
	718	+	return &MockOverlayWidget_RemoveOverlay_Call{Call: _e.mock.On("RemoveOverlay", overlay)}
	719	+	}
	720	+
	721	+	func (_c MockOverlayWidget_RemoveOverlay_Call) Run(run func(overlay layout.Widget)) MockOverlayWidget_RemoveOverlay_Call {
	722	+	_c.Call.Run(func(args mock.Arguments) {
	723	+	var arg0 layout.Widget
	724	+	if args[0] != nil {
	725	+	arg0 = args[0].(layout.Widget)
	726	+	}
	727	+	run(
	728	+	arg0,
	729	+	)
	730	+	})
	731	+	return _c
	732	+	}
	733	+
	734	+	func (_c MockOverlayWidget_RemoveOverlay_Call) Return() MockOverlayWidget_RemoveOverlay_Call {
	735	+	_c.Call.Return()
	736	+	return _c
	737	+	}
	738	+
	739	+	func (_c MockOverlayWidget_RemoveOverlay_Call) RunAndReturn(run func(overlay layout.Widget)) MockOverlayWidget_RemoveOverlay_Call {
	740	+	_c.Run(run)
	741	+	return _c
	742	+	}
	743	+
	744	+	// SetCanFocus provides a mock function for the type MockOverlayWidget
	745	+	func (_mock *MockOverlayWidget) SetCanFocus(canFocus bool) {
	746	+	_mock.Called(canFocus)
	747	+	return
	748	+	}
	749	+
	750	+	// MockOverlayWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	751	+	type MockOverlayWidget_SetCanFocus_Call struct {
	752	+	*mock.Call
	753	+	}
	754	+
	755	+	// SetCanFocus is a helper method to define mock.On call
	756	+	// - canFocus bool
	757	+	func (_e MockOverlayWidget_Expecter) SetCanFocus(canFocus interface{}) MockOverlayWidget_SetCanFocus_Call {
	758	+	return &MockOverlayWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	759	+	}
	760	+
	761	+	func (_c MockOverlayWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockOverlayWidget_SetCanFocus_Call {
	762	+	_c.Call.Run(func(args mock.Arguments) {
	763	+	var arg0 bool
	764	+	if args[0] != nil {
	765	+	arg0 = args[0].(bool)
	766	+	}
	767	+	run(
	768	+	arg0,
	769	+	)
	770	+	})
	771	+	return _c
	772	+	}
	773	+
	774	+	func (_c MockOverlayWidget_SetCanFocus_Call) Return() MockOverlayWidget_SetCanFocus_Call {
	775	+	_c.Call.Return()
	776	+	return _c
	777	+	}
	778	+
	779	+	func (_c MockOverlayWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockOverlayWidget_SetCanFocus_Call {
	780	+	_c.Run(run)
	781	+	return _c
	782	+	}
	783	+
	784	+	// SetChild provides a mock function for the type MockOverlayWidget
	785	+	func (_mock *MockOverlayWidget) SetChild(child layout.Widget) {
	786	+	_mock.Called(child)
	787	+	return
	788	+	}
	789	+
	790	+	// MockOverlayWidget_SetChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetChild'
	791	+	type MockOverlayWidget_SetChild_Call struct {
	792	+	*mock.Call
	793	+	}
	794	+
	795	+	// SetChild is a helper method to define mock.On call
	796	+	// - child layout.Widget
	797	+	func (_e MockOverlayWidget_Expecter) SetChild(child interface{}) MockOverlayWidget_SetChild_Call {
	798	+	return &MockOverlayWidget_SetChild_Call{Call: _e.mock.On("SetChild", child)}
	799	+	}
	800	+
	801	+	func (_c MockOverlayWidget_SetChild_Call) Run(run func(child layout.Widget)) MockOverlayWidget_SetChild_Call {
	802	+	_c.Call.Run(func(args mock.Arguments) {
	803	+	var arg0 layout.Widget
	804	+	if args[0] != nil {
	805	+	arg0 = args[0].(layout.Widget)
	806	+	}
	807	+	run(
	808	+	arg0,
	809	+	)
	810	+	})
	811	+	return _c
	812	+	}
	813	+
	814	+	func (_c MockOverlayWidget_SetChild_Call) Return() MockOverlayWidget_SetChild_Call {
	815	+	_c.Call.Return()
	816	+	return _c
	817	+	}
	818	+
	819	+	func (_c MockOverlayWidget_SetChild_Call) RunAndReturn(run func(child layout.Widget)) MockOverlayWidget_SetChild_Call {
	820	+	_c.Run(run)
	821	+	return _c
	822	+	}
	823	+
	824	+	// SetClipOverlay provides a mock function for the type MockOverlayWidget
	825	+	func (_mock *MockOverlayWidget) SetClipOverlay(overlay layout.Widget, clip bool) {
	826	+	_mock.Called(overlay, clip)
	827	+	return
	828	+	}
	829	+
	830	+	// MockOverlayWidget_SetClipOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetClipOverlay'
	831	+	type MockOverlayWidget_SetClipOverlay_Call struct {
	832	+	*mock.Call
	833	+	}
	834	+
	835	+	// SetClipOverlay is a helper method to define mock.On call
	836	+	// - overlay layout.Widget
	837	+	// - clip bool
	838	+	func (_e MockOverlayWidget_Expecter) SetClipOverlay(overlay interface{}, clip interface{}) MockOverlayWidget_SetClipOverlay_Call {
	839	+	return &MockOverlayWidget_SetClipOverlay_Call{Call: _e.mock.On("SetClipOverlay", overlay, clip)}
	840	+	}
	841	+
	842	+	func (_c MockOverlayWidget_SetClipOverlay_Call) Run(run func(overlay layout.Widget, clip bool)) MockOverlayWidget_SetClipOverlay_Call {
	843	+	_c.Call.Run(func(args mock.Arguments) {
	844	+	var arg0 layout.Widget
	845	+	if args[0] != nil {
	846	+	arg0 = args[0].(layout.Widget)
	847	+	}
	848	+	var arg1 bool
	849	+	if args[1] != nil {
	850	+	arg1 = args[1].(bool)
	851	+	}
	852	+	run(
	853	+	arg0,
	854	+	arg1,
	855	+	)
	856	+	})
	857	+	return _c
	858	+	}
	859	+
	860	+	func (_c MockOverlayWidget_SetClipOverlay_Call) Return() MockOverlayWidget_SetClipOverlay_Call {
	861	+	_c.Call.Return()
	862	+	return _c
	863	+	}
	864	+
	865	+	func (_c MockOverlayWidget_SetClipOverlay_Call) RunAndReturn(run func(overlay layout.Widget, clip bool)) MockOverlayWidget_SetClipOverlay_Call {
	866	+	_c.Run(run)
	867	+	return _c
	868	+	}
	869	+
	870	+	// SetFocusOnClick provides a mock function for the type MockOverlayWidget
	871	+	func (_mock *MockOverlayWidget) SetFocusOnClick(focusOnClick bool) {
	872	+	_mock.Called(focusOnClick)
	873	+	return
	874	+	}
	875	+
	876	+	// MockOverlayWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	877	+	type MockOverlayWidget_SetFocusOnClick_Call struct {
	878	+	*mock.Call
	879	+	}
	880	+
	881	+	// SetFocusOnClick is a helper method to define mock.On call
	882	+	// - focusOnClick bool
	883	+	func (_e MockOverlayWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockOverlayWidget_SetFocusOnClick_Call {
	884	+	return &MockOverlayWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	885	+	}
	886	+
	887	+	func (_c MockOverlayWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockOverlayWidget_SetFocusOnClick_Call {
	888	+	_c.Call.Run(func(args mock.Arguments) {
	889	+	var arg0 bool
	890	+	if args[0] != nil {
	891	+	arg0 = args[0].(bool)
	892	+	}
	893	+	run(
	894	+	arg0,
	895	+	)
	896	+	})
	897	+	return _c
	898	+	}
	899	+
	900	+	func (_c MockOverlayWidget_SetFocusOnClick_Call) Return() MockOverlayWidget_SetFocusOnClick_Call {
	901	+	_c.Call.Return()
	902	+	return _c
	903	+	}
	904	+
	905	+	func (_c MockOverlayWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockOverlayWidget_SetFocusOnClick_Call {
	906	+	_c.Run(run)
	907	+	return _c
	908	+	}
	909	+
	910	+	// SetHalign provides a mock function for the type MockOverlayWidget
	911	+	func (_mock *MockOverlayWidget) SetHalign(align gtk.Align) {
	912	+	_mock.Called(align)
	913	+	return
	914	+	}
	915	+
	916	+	// MockOverlayWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	917	+	type MockOverlayWidget_SetHalign_Call struct {
	918	+	*mock.Call
	919	+	}
	920	+
	921	+	// SetHalign is a helper method to define mock.On call
	922	+	// - align gtk.Align
	923	+	func (_e MockOverlayWidget_Expecter) SetHalign(align interface{}) MockOverlayWidget_SetHalign_Call {
	924	+	return &MockOverlayWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	925	+	}
	926	+
	927	+	func (_c MockOverlayWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockOverlayWidget_SetHalign_Call {
	928	+	_c.Call.Run(func(args mock.Arguments) {
	929	+	var arg0 gtk.Align
	930	+	if args[0] != nil {
	931	+	arg0 = args[0].(gtk.Align)
	932	+	}
	933	+	run(
	934	+	arg0,
	935	+	)
	936	+	})
	937	+	return _c
	938	+	}
	939	+
	940	+	func (_c MockOverlayWidget_SetHalign_Call) Return() MockOverlayWidget_SetHalign_Call {
	941	+	_c.Call.Return()
	942	+	return _c
	943	+	}
	944	+
	945	+	func (_c MockOverlayWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockOverlayWidget_SetHalign_Call {
	946	+	_c.Run(run)
	947	+	return _c
	948	+	}
	949	+
	950	+	// SetHexpand provides a mock function for the type MockOverlayWidget
	951	+	func (_mock *MockOverlayWidget) SetHexpand(expand bool) {
	952	+	_mock.Called(expand)
	953	+	return
	954	+	}
	955	+
	956	+	// MockOverlayWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	957	+	type MockOverlayWidget_SetHexpand_Call struct {
	958	+	*mock.Call
	959	+	}
	960	+
	961	+	// SetHexpand is a helper method to define mock.On call
	962	+	// - expand bool
	963	+	func (_e MockOverlayWidget_Expecter) SetHexpand(expand interface{}) MockOverlayWidget_SetHexpand_Call {
	964	+	return &MockOverlayWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	965	+	}
	966	+
	967	+	func (_c MockOverlayWidget_SetHexpand_Call) Run(run func(expand bool)) MockOverlayWidget_SetHexpand_Call {
	968	+	_c.Call.Run(func(args mock.Arguments) {
	969	+	var arg0 bool
	970	+	if args[0] != nil {
	971	+	arg0 = args[0].(bool)
	972	+	}
	973	+	run(
	974	+	arg0,
	975	+	)
	976	+	})
	977	+	return _c
	978	+	}
	979	+
	980	+	func (_c MockOverlayWidget_SetHexpand_Call) Return() MockOverlayWidget_SetHexpand_Call {
	981	+	_c.Call.Return()
	982	+	return _c
	983	+	}
	984	+
	985	+	func (_c MockOverlayWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockOverlayWidget_SetHexpand_Call {
	986	+	_c.Run(run)
	987	+	return _c
	988	+	}
	989	+
	990	+	// SetMeasureOverlay provides a mock function for the type MockOverlayWidget
	991	+	func (_mock *MockOverlayWidget) SetMeasureOverlay(overlay layout.Widget, measure bool) {
	992	+	_mock.Called(overlay, measure)
	993	+	return
	994	+	}
	995	+
	996	+	// MockOverlayWidget_SetMeasureOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMeasureOverlay'
	997	+	type MockOverlayWidget_SetMeasureOverlay_Call struct {
	998	+	*mock.Call
	999	+	}
	1000	+
	1001	+	// SetMeasureOverlay is a helper method to define mock.On call
	1002	+	// - overlay layout.Widget
	1003	+	// - measure bool
	1004	+	func (_e MockOverlayWidget_Expecter) SetMeasureOverlay(overlay interface{}, measure interface{}) MockOverlayWidget_SetMeasureOverlay_Call {
	1005	+	return &MockOverlayWidget_SetMeasureOverlay_Call{Call: _e.mock.On("SetMeasureOverlay", overlay, measure)}
	1006	+	}
	1007	+
	1008	+	func (_c MockOverlayWidget_SetMeasureOverlay_Call) Run(run func(overlay layout.Widget, measure bool)) MockOverlayWidget_SetMeasureOverlay_Call {
	1009	+	_c.Call.Run(func(args mock.Arguments) {
	1010	+	var arg0 layout.Widget
	1011	+	if args[0] != nil {
	1012	+	arg0 = args[0].(layout.Widget)
	1013	+	}
	1014	+	var arg1 bool
	1015	+	if args[1] != nil {
	1016	+	arg1 = args[1].(bool)
	1017	+	}
	1018	+	run(
	1019	+	arg0,
	1020	+	arg1,
	1021	+	)
	1022	+	})
	1023	+	return _c
	1024	+	}
	1025	+
	1026	+	func (_c MockOverlayWidget_SetMeasureOverlay_Call) Return() MockOverlayWidget_SetMeasureOverlay_Call {
	1027	+	_c.Call.Return()
	1028	+	return _c
	1029	+	}
	1030	+
	1031	+	func (_c MockOverlayWidget_SetMeasureOverlay_Call) RunAndReturn(run func(overlay layout.Widget, measure bool)) MockOverlayWidget_SetMeasureOverlay_Call {
	1032	+	_c.Run(run)
	1033	+	return _c
	1034	+	}
	1035	+
	1036	+	// SetSizeRequest provides a mock function for the type MockOverlayWidget
	1037	+	func (_mock *MockOverlayWidget) SetSizeRequest(width int, height int) {
	1038	+	_mock.Called(width, height)
	1039	+	return
	1040	+	}
	1041	+
	1042	+	// MockOverlayWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	1043	+	type MockOverlayWidget_SetSizeRequest_Call struct {
	1044	+	*mock.Call
	1045	+	}
	1046	+
	1047	+	// SetSizeRequest is a helper method to define mock.On call
	1048	+	// - width int
	1049	+	// - height int
	1050	+	func (_e MockOverlayWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockOverlayWidget_SetSizeRequest_Call {
	1051	+	return &MockOverlayWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	1052	+	}
	1053	+
	1054	+	func (_c MockOverlayWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockOverlayWidget_SetSizeRequest_Call {
	1055	+	_c.Call.Run(func(args mock.Arguments) {
	1056	+	var arg0 int
	1057	+	if args[0] != nil {
	1058	+	arg0 = args[0].(int)
	1059	+	}
	1060	+	var arg1 int
	1061	+	if args[1] != nil {
	1062	+	arg1 = args[1].(int)
	1063	+	}
	1064	+	run(
	1065	+	arg0,
	1066	+	arg1,
	1067	+	)
	1068	+	})
	1069	+	return _c
	1070	+	}
	1071	+
	1072	+	func (_c MockOverlayWidget_SetSizeRequest_Call) Return() MockOverlayWidget_SetSizeRequest_Call {
	1073	+	_c.Call.Return()
	1074	+	return _c
	1075	+	}
	1076	+
	1077	+	func (_c MockOverlayWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockOverlayWidget_SetSizeRequest_Call {
	1078	+	_c.Run(run)
	1079	+	return _c
	1080	+	}
	1081	+
	1082	+	// SetValign provides a mock function for the type MockOverlayWidget
	1083	+	func (_mock *MockOverlayWidget) SetValign(align gtk.Align) {
	1084	+	_mock.Called(align)
	1085	+	return
	1086	+	}
	1087	+
	1088	+	// MockOverlayWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	1089	+	type MockOverlayWidget_SetValign_Call struct {
	1090	+	*mock.Call
	1091	+	}
	1092	+
	1093	+	// SetValign is a helper method to define mock.On call
	1094	+	// - align gtk.Align
	1095	+	func (_e MockOverlayWidget_Expecter) SetValign(align interface{}) MockOverlayWidget_SetValign_Call {
	1096	+	return &MockOverlayWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	1097	+	}
	1098	+
	1099	+	func (_c MockOverlayWidget_SetValign_Call) Run(run func(align gtk.Align)) MockOverlayWidget_SetValign_Call {
	1100	+	_c.Call.Run(func(args mock.Arguments) {
	1101	+	var arg0 gtk.Align
	1102	+	if args[0] != nil {
	1103	+	arg0 = args[0].(gtk.Align)
	1104	+	}
	1105	+	run(
	1106	+	arg0,
	1107	+	)
	1108	+	})
	1109	+	return _c
	1110	+	}
	1111	+
	1112	+	func (_c MockOverlayWidget_SetValign_Call) Return() MockOverlayWidget_SetValign_Call {
	1113	+	_c.Call.Return()
	1114	+	return _c
	1115	+	}
	1116	+
	1117	+	func (_c MockOverlayWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockOverlayWidget_SetValign_Call {
	1118	+	_c.Run(run)
	1119	+	return _c
	1120	+	}
	1121	+
	1122	+	// SetVexpand provides a mock function for the type MockOverlayWidget
	1123	+	func (_mock *MockOverlayWidget) SetVexpand(expand bool) {
	1124	+	_mock.Called(expand)
	1125	+	return
	1126	+	}
	1127	+
	1128	+	// MockOverlayWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	1129	+	type MockOverlayWidget_SetVexpand_Call struct {
	1130	+	*mock.Call
	1131	+	}
	1132	+
	1133	+	// SetVexpand is a helper method to define mock.On call
	1134	+	// - expand bool
	1135	+	func (_e MockOverlayWidget_Expecter) SetVexpand(expand interface{}) MockOverlayWidget_SetVexpand_Call {
	1136	+	return &MockOverlayWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	1137	+	}
	1138	+
	1139	+	func (_c MockOverlayWidget_SetVexpand_Call) Run(run func(expand bool)) MockOverlayWidget_SetVexpand_Call {
	1140	+	_c.Call.Run(func(args mock.Arguments) {
	1141	+	var arg0 bool
	1142	+	if args[0] != nil {
	1143	+	arg0 = args[0].(bool)
	1144	+	}
	1145	+	run(
	1146	+	arg0,
	1147	+	)
	1148	+	})
	1149	+	return _c
	1150	+	}
	1151	+
	1152	+	func (_c MockOverlayWidget_SetVexpand_Call) Return() MockOverlayWidget_SetVexpand_Call {
	1153	+	_c.Call.Return()
	1154	+	return _c
	1155	+	}
	1156	+
	1157	+	func (_c MockOverlayWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockOverlayWidget_SetVexpand_Call {
	1158	+	_c.Run(run)
	1159	+	return _c
	1160	+	}
	1161	+
	1162	+	// SetVisible provides a mock function for the type MockOverlayWidget
	1163	+	func (_mock *MockOverlayWidget) SetVisible(visible bool) {
	1164	+	_mock.Called(visible)
	1165	+	return
	1166	+	}
	1167	+
	1168	+	// MockOverlayWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	1169	+	type MockOverlayWidget_SetVisible_Call struct {
	1170	+	*mock.Call
	1171	+	}
	1172	+
	1173	+	// SetVisible is a helper method to define mock.On call
	1174	+	// - visible bool
	1175	+	func (_e MockOverlayWidget_Expecter) SetVisible(visible interface{}) MockOverlayWidget_SetVisible_Call {
	1176	+	return &MockOverlayWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	1177	+	}
	1178	+
	1179	+	func (_c MockOverlayWidget_SetVisible_Call) Run(run func(visible bool)) MockOverlayWidget_SetVisible_Call {
	1180	+	_c.Call.Run(func(args mock.Arguments) {
	1181	+	var arg0 bool
	1182	+	if args[0] != nil {
	1183	+	arg0 = args[0].(bool)
	1184	+	}
	1185	+	run(
	1186	+	arg0,
	1187	+	)
	1188	+	})
	1189	+	return _c
	1190	+	}
	1191	+
	1192	+	func (_c MockOverlayWidget_SetVisible_Call) Return() MockOverlayWidget_SetVisible_Call {
	1193	+	_c.Call.Return()
	1194	+	return _c
	1195	+	}
	1196	+
	1197	+	func (_c MockOverlayWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockOverlayWidget_SetVisible_Call {
	1198	+	_c.Run(run)
	1199	+	return _c
	1200	+	}
	1201	+
	1202	+	// Show provides a mock function for the type MockOverlayWidget
	1203	+	func (_mock *MockOverlayWidget) Show() {
	1204	+	_mock.Called()
	1205	+	return
	1206	+	}
	1207	+
	1208	+	// MockOverlayWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	1209	+	type MockOverlayWidget_Show_Call struct {
	1210	+	*mock.Call
	1211	+	}
	1212	+
	1213	+	// Show is a helper method to define mock.On call
	1214	+	func (_e MockOverlayWidget_Expecter) Show() MockOverlayWidget_Show_Call {
	1215	+	return &MockOverlayWidget_Show_Call{Call: _e.mock.On("Show")}
	1216	+	}
	1217	+
	1218	+	func (_c MockOverlayWidget_Show_Call) Run(run func()) MockOverlayWidget_Show_Call {
	1219	+	_c.Call.Run(func(args mock.Arguments) {
	1220	+	run()
	1221	+	})
	1222	+	return _c
	1223	+	}
	1224	+
	1225	+	func (_c MockOverlayWidget_Show_Call) Return() MockOverlayWidget_Show_Call {
	1226	+	_c.Call.Return()
	1227	+	return _c
	1228	+	}
	1229	+
	1230	+	func (_c MockOverlayWidget_Show_Call) RunAndReturn(run func()) MockOverlayWidget_Show_Call {
	1231	+	_c.Run(run)
	1232	+	return _c
	1233	+	}
	1234	+
	1235	+	// Unparent provides a mock function for the type MockOverlayWidget
	1236	+	func (_mock *MockOverlayWidget) Unparent() {
	1237	+	_mock.Called()
	1238	+	return
	1239	+	}
	1240	+
	1241	+	// MockOverlayWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	1242	+	type MockOverlayWidget_Unparent_Call struct {
	1243	+	*mock.Call
	1244	+	}
	1245	+
	1246	+	// Unparent is a helper method to define mock.On call
	1247	+	func (_e MockOverlayWidget_Expecter) Unparent() MockOverlayWidget_Unparent_Call {
	1248	+	return &MockOverlayWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	1249	+	}
	1250	+
	1251	+	func (_c MockOverlayWidget_Unparent_Call) Run(run func()) MockOverlayWidget_Unparent_Call {
	1252	+	_c.Call.Run(func(args mock.Arguments) {
	1253	+	run()
	1254	+	})
	1255	+	return _c
	1256	+	}
	1257	+
	1258	+	func (_c MockOverlayWidget_Unparent_Call) Return() MockOverlayWidget_Unparent_Call {
	1259	+	_c.Call.Return()
	1260	+	return _c
	1261	+	}
	1262	+
	1263	+	func (_c MockOverlayWidget_Unparent_Call) RunAndReturn(run func()) MockOverlayWidget_Unparent_Call {
	1264	+	_c.Run(run)
	1265	+	return _c
	1266	+	}

A internal/ui/layout/mocks/mock_pane_renderer.go +96 -0

@@ -0,0 +1,96 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	mock "github.com/stretchr/testify/mock"
	10	+	)
	11	+
	12	+	// 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.
	13	+	// The first argument is typically a *testing.T value.
	14	+	func NewMockPaneRenderer(t interface {
	15	+	mock.TestingT
	16	+	Cleanup(func())
	17	+	}) *MockPaneRenderer {
	18	+	mock := &MockPaneRenderer{}
	19	+	mock.Mock.Test(t)
	20	+
	21	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	22	+
	23	+	return mock
	24	+	}
	25	+
	26	+	// MockPaneRenderer is an autogenerated mock type for the PaneRenderer type
	27	+	type MockPaneRenderer struct {
	28	+	mock.Mock
	29	+	}
	30	+
	31	+	type MockPaneRenderer_Expecter struct {
	32	+	mock *mock.Mock
	33	+	}
	34	+
	35	+	func (_m MockPaneRenderer) EXPECT() MockPaneRenderer_Expecter {
	36	+	return &MockPaneRenderer_Expecter{mock: &_m.Mock}
	37	+	}
	38	+
	39	+	// RenderPane provides a mock function for the type MockPaneRenderer
	40	+	func (_mock *MockPaneRenderer) RenderPane(paneID string, webViewWidget layout.Widget) layout.Widget {
	41	+	ret := _mock.Called(paneID, webViewWidget)
	42	+
	43	+	if len(ret) == 0 {
	44	+	panic("no return value specified for RenderPane")
	45	+	}
	46	+
	47	+	var r0 layout.Widget
	48	+	if returnFunc, ok := ret.Get(0).(func(string, layout.Widget) layout.Widget); ok {
	49	+	r0 = returnFunc(paneID, webViewWidget)
	50	+	} else {
	51	+	if ret.Get(0) != nil {
	52	+	r0 = ret.Get(0).(layout.Widget)
	53	+	}
	54	+	}
	55	+	return r0
	56	+	}
	57	+
	58	+	// MockPaneRenderer_RenderPane_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RenderPane'
	59	+	type MockPaneRenderer_RenderPane_Call struct {
	60	+	*mock.Call
	61	+	}
	62	+
	63	+	// RenderPane is a helper method to define mock.On call
	64	+	// - paneID string
	65	+	// - webViewWidget layout.Widget
	66	+	func (_e MockPaneRenderer_Expecter) RenderPane(paneID interface{}, webViewWidget interface{}) MockPaneRenderer_RenderPane_Call {
	67	+	return &MockPaneRenderer_RenderPane_Call{Call: _e.mock.On("RenderPane", paneID, webViewWidget)}
	68	+	}
	69	+
	70	+	func (_c MockPaneRenderer_RenderPane_Call) Run(run func(paneID string, webViewWidget layout.Widget)) MockPaneRenderer_RenderPane_Call {
	71	+	_c.Call.Run(func(args mock.Arguments) {
	72	+	var arg0 string
	73	+	if args[0] != nil {
	74	+	arg0 = args[0].(string)
	75	+	}
	76	+	var arg1 layout.Widget
	77	+	if args[1] != nil {
	78	+	arg1 = args[1].(layout.Widget)
	79	+	}
	80	+	run(
	81	+	arg0,
	82	+	arg1,
	83	+	)
	84	+	})
	85	+	return _c
	86	+	}
	87	+
	88	+	func (_c MockPaneRenderer_RenderPane_Call) Return(widget layout.Widget) MockPaneRenderer_RenderPane_Call {
	89	+	_c.Call.Return(widget)
	90	+	return _c
	91	+	}
	92	+
	93	+	func (_c MockPaneRenderer_RenderPane_Call) RunAndReturn(run func(paneID string, webViewWidget layout.Widget) layout.Widget) MockPaneRenderer_RenderPane_Call {
	94	+	_c.Call.Return(run)
	95	+	return _c
	96	+	}

A internal/ui/layout/mocks/mock_pane_view_factory.go +91 -0

@@ -0,0 +1,91 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/domain/entity"
	9	+	"github.com/bnema/dumber/internal/ui/layout"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockPaneViewFactory(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockPaneViewFactory {
	19	+	mock := &MockPaneViewFactory{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockPaneViewFactory is an autogenerated mock type for the PaneViewFactory type
	28	+	type MockPaneViewFactory struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockPaneViewFactory_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockPaneViewFactory) EXPECT() MockPaneViewFactory_Expecter {
	37	+	return &MockPaneViewFactory_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// CreatePaneView provides a mock function for the type MockPaneViewFactory
	41	+	func (_mock MockPaneViewFactory) CreatePaneView(node entity.PaneNode) layout.Widget {
	42	+	ret := _mock.Called(node)
	43	+
	44	+	if len(ret) == 0 {
	45	+	panic("no return value specified for CreatePaneView")
	46	+	}
	47	+
	48	+	var r0 layout.Widget
	49	+	if returnFunc, ok := ret.Get(0).(func(*entity.PaneNode) layout.Widget); ok {
	50	+	r0 = returnFunc(node)
	51	+	} else {
	52	+	if ret.Get(0) != nil {
	53	+	r0 = ret.Get(0).(layout.Widget)
	54	+	}
	55	+	}
	56	+	return r0
	57	+	}
	58	+
	59	+	// MockPaneViewFactory_CreatePaneView_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePaneView'
	60	+	type MockPaneViewFactory_CreatePaneView_Call struct {
	61	+	*mock.Call
	62	+	}
	63	+
	64	+	// CreatePaneView is a helper method to define mock.On call
	65	+	// - node *entity.PaneNode
	66	+	func (_e MockPaneViewFactory_Expecter) CreatePaneView(node interface{}) MockPaneViewFactory_CreatePaneView_Call {
	67	+	return &MockPaneViewFactory_CreatePaneView_Call{Call: _e.mock.On("CreatePaneView", node)}
	68	+	}
	69	+
	70	+	func (_c MockPaneViewFactory_CreatePaneView_Call) Run(run func(node entity.PaneNode)) *MockPaneViewFactory_CreatePaneView_Call {
	71	+	_c.Call.Run(func(args mock.Arguments) {
	72	+	var arg0 *entity.PaneNode
	73	+	if args[0] != nil {
	74	+	arg0 = args[0].(*entity.PaneNode)
	75	+	}
	76	+	run(
	77	+	arg0,
	78	+	)
	79	+	})
	80	+	return _c
	81	+	}
	82	+
	83	+	func (_c MockPaneViewFactory_CreatePaneView_Call) Return(widget layout.Widget) MockPaneViewFactory_CreatePaneView_Call {
	84	+	_c.Call.Return(widget)
	85	+	return _c
	86	+	}
	87	+
	88	+	func (_c MockPaneViewFactory_CreatePaneView_Call) RunAndReturn(run func(node entity.PaneNode) layout.Widget) *MockPaneViewFactory_CreatePaneView_Call {
	89	+	_c.Call.Return(run)
	90	+	return _c
	91	+	}

A internal/ui/layout/mocks/mock_paned_widget.go +1721 -0

@@ -0,0 +1,1721 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockPanedWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockPanedWidget {
	19	+	mock := &MockPanedWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockPanedWidget is an autogenerated mock type for the PanedWidget type
	28	+	type MockPanedWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockPanedWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockPanedWidget) EXPECT() MockPanedWidget_Expecter {
	37	+	return &MockPanedWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockPanedWidget
	41	+	func (_mock *MockPanedWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockPanedWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockPanedWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockPanedWidget_Expecter) AddCssClass(cssClass interface{}) MockPanedWidget_AddCssClass_Call {
	54	+	return &MockPanedWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockPanedWidget_AddCssClass_Call) Run(run func(cssClass string)) MockPanedWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockPanedWidget_AddCssClass_Call) Return() MockPanedWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockPanedWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockPanedWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// ConnectMap provides a mock function for the type MockPanedWidget
	81	+	func (_mock *MockPanedWidget) ConnectMap(callback func()) uint32 {
	82	+	ret := _mock.Called(callback)
	83	+
	84	+	if len(ret) == 0 {
	85	+	panic("no return value specified for ConnectMap")
	86	+	}
	87	+
	88	+	var r0 uint32
	89	+	if returnFunc, ok := ret.Get(0).(func(func()) uint32); ok {
	90	+	r0 = returnFunc(callback)
	91	+	} else {
	92	+	r0 = ret.Get(0).(uint32)
	93	+	}
	94	+	return r0
	95	+	}
	96	+
	97	+	// MockPanedWidget_ConnectMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectMap'
	98	+	type MockPanedWidget_ConnectMap_Call struct {
	99	+	*mock.Call
	100	+	}
	101	+
	102	+	// ConnectMap is a helper method to define mock.On call
	103	+	// - callback func()
	104	+	func (_e MockPanedWidget_Expecter) ConnectMap(callback interface{}) MockPanedWidget_ConnectMap_Call {
	105	+	return &MockPanedWidget_ConnectMap_Call{Call: _e.mock.On("ConnectMap", callback)}
	106	+	}
	107	+
	108	+	func (_c MockPanedWidget_ConnectMap_Call) Run(run func(callback func())) MockPanedWidget_ConnectMap_Call {
	109	+	_c.Call.Run(func(args mock.Arguments) {
	110	+	var arg0 func()
	111	+	if args[0] != nil {
	112	+	arg0 = args[0].(func())
	113	+	}
	114	+	run(
	115	+	arg0,
	116	+	)
	117	+	})
	118	+	return _c
	119	+	}
	120	+
	121	+	func (_c MockPanedWidget_ConnectMap_Call) Return(v uint32) MockPanedWidget_ConnectMap_Call {
	122	+	_c.Call.Return(v)
	123	+	return _c
	124	+	}
	125	+
	126	+	func (_c MockPanedWidget_ConnectMap_Call) RunAndReturn(run func(callback func()) uint32) MockPanedWidget_ConnectMap_Call {
	127	+	_c.Call.Return(run)
	128	+	return _c
	129	+	}
	130	+
	131	+	// GetAllocatedHeight provides a mock function for the type MockPanedWidget
	132	+	func (_mock *MockPanedWidget) GetAllocatedHeight() int {
	133	+	ret := _mock.Called()
	134	+
	135	+	if len(ret) == 0 {
	136	+	panic("no return value specified for GetAllocatedHeight")
	137	+	}
	138	+
	139	+	var r0 int
	140	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	141	+	r0 = returnFunc()
	142	+	} else {
	143	+	r0 = ret.Get(0).(int)
	144	+	}
	145	+	return r0
	146	+	}
	147	+
	148	+	// MockPanedWidget_GetAllocatedHeight_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedHeight'
	149	+	type MockPanedWidget_GetAllocatedHeight_Call struct {
	150	+	*mock.Call
	151	+	}
	152	+
	153	+	// GetAllocatedHeight is a helper method to define mock.On call
	154	+	func (_e MockPanedWidget_Expecter) GetAllocatedHeight() MockPanedWidget_GetAllocatedHeight_Call {
	155	+	return &MockPanedWidget_GetAllocatedHeight_Call{Call: _e.mock.On("GetAllocatedHeight")}
	156	+	}
	157	+
	158	+	func (_c MockPanedWidget_GetAllocatedHeight_Call) Run(run func()) MockPanedWidget_GetAllocatedHeight_Call {
	159	+	_c.Call.Run(func(args mock.Arguments) {
	160	+	run()
	161	+	})
	162	+	return _c
	163	+	}
	164	+
	165	+	func (_c MockPanedWidget_GetAllocatedHeight_Call) Return(n int) MockPanedWidget_GetAllocatedHeight_Call {
	166	+	_c.Call.Return(n)
	167	+	return _c
	168	+	}
	169	+
	170	+	func (_c MockPanedWidget_GetAllocatedHeight_Call) RunAndReturn(run func() int) MockPanedWidget_GetAllocatedHeight_Call {
	171	+	_c.Call.Return(run)
	172	+	return _c
	173	+	}
	174	+
	175	+	// GetAllocatedWidth provides a mock function for the type MockPanedWidget
	176	+	func (_mock *MockPanedWidget) GetAllocatedWidth() int {
	177	+	ret := _mock.Called()
	178	+
	179	+	if len(ret) == 0 {
	180	+	panic("no return value specified for GetAllocatedWidth")
	181	+	}
	182	+
	183	+	var r0 int
	184	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	185	+	r0 = returnFunc()
	186	+	} else {
	187	+	r0 = ret.Get(0).(int)
	188	+	}
	189	+	return r0
	190	+	}
	191	+
	192	+	// MockPanedWidget_GetAllocatedWidth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllocatedWidth'
	193	+	type MockPanedWidget_GetAllocatedWidth_Call struct {
	194	+	*mock.Call
	195	+	}
	196	+
	197	+	// GetAllocatedWidth is a helper method to define mock.On call
	198	+	func (_e MockPanedWidget_Expecter) GetAllocatedWidth() MockPanedWidget_GetAllocatedWidth_Call {
	199	+	return &MockPanedWidget_GetAllocatedWidth_Call{Call: _e.mock.On("GetAllocatedWidth")}
	200	+	}
	201	+
	202	+	func (_c MockPanedWidget_GetAllocatedWidth_Call) Run(run func()) MockPanedWidget_GetAllocatedWidth_Call {
	203	+	_c.Call.Run(func(args mock.Arguments) {
	204	+	run()
	205	+	})
	206	+	return _c
	207	+	}
	208	+
	209	+	func (_c MockPanedWidget_GetAllocatedWidth_Call) Return(n int) MockPanedWidget_GetAllocatedWidth_Call {
	210	+	_c.Call.Return(n)
	211	+	return _c
	212	+	}
	213	+
	214	+	func (_c MockPanedWidget_GetAllocatedWidth_Call) RunAndReturn(run func() int) MockPanedWidget_GetAllocatedWidth_Call {
	215	+	_c.Call.Return(run)
	216	+	return _c
	217	+	}
	218	+
	219	+	// GetEndChild provides a mock function for the type MockPanedWidget
	220	+	func (_mock *MockPanedWidget) GetEndChild() layout.Widget {
	221	+	ret := _mock.Called()
	222	+
	223	+	if len(ret) == 0 {
	224	+	panic("no return value specified for GetEndChild")
	225	+	}
	226	+
	227	+	var r0 layout.Widget
	228	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	229	+	r0 = returnFunc()
	230	+	} else {
	231	+	if ret.Get(0) != nil {
	232	+	r0 = ret.Get(0).(layout.Widget)
	233	+	}
	234	+	}
	235	+	return r0
	236	+	}
	237	+
	238	+	// MockPanedWidget_GetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEndChild'
	239	+	type MockPanedWidget_GetEndChild_Call struct {
	240	+	*mock.Call
	241	+	}
	242	+
	243	+	// GetEndChild is a helper method to define mock.On call
	244	+	func (_e MockPanedWidget_Expecter) GetEndChild() MockPanedWidget_GetEndChild_Call {
	245	+	return &MockPanedWidget_GetEndChild_Call{Call: _e.mock.On("GetEndChild")}
	246	+	}
	247	+
	248	+	func (_c MockPanedWidget_GetEndChild_Call) Run(run func()) MockPanedWidget_GetEndChild_Call {
	249	+	_c.Call.Run(func(args mock.Arguments) {
	250	+	run()
	251	+	})
	252	+	return _c
	253	+	}
	254	+
	255	+	func (_c MockPanedWidget_GetEndChild_Call) Return(widget layout.Widget) MockPanedWidget_GetEndChild_Call {
	256	+	_c.Call.Return(widget)
	257	+	return _c
	258	+	}
	259	+
	260	+	func (_c MockPanedWidget_GetEndChild_Call) RunAndReturn(run func() layout.Widget) MockPanedWidget_GetEndChild_Call {
	261	+	_c.Call.Return(run)
	262	+	return _c
	263	+	}
	264	+
	265	+	// GetHexpand provides a mock function for the type MockPanedWidget
	266	+	func (_mock *MockPanedWidget) GetHexpand() bool {
	267	+	ret := _mock.Called()
	268	+
	269	+	if len(ret) == 0 {
	270	+	panic("no return value specified for GetHexpand")
	271	+	}
	272	+
	273	+	var r0 bool
	274	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	275	+	r0 = returnFunc()
	276	+	} else {
	277	+	r0 = ret.Get(0).(bool)
	278	+	}
	279	+	return r0
	280	+	}
	281	+
	282	+	// MockPanedWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	283	+	type MockPanedWidget_GetHexpand_Call struct {
	284	+	*mock.Call
	285	+	}
	286	+
	287	+	// GetHexpand is a helper method to define mock.On call
	288	+	func (_e MockPanedWidget_Expecter) GetHexpand() MockPanedWidget_GetHexpand_Call {
	289	+	return &MockPanedWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	290	+	}
	291	+
	292	+	func (_c MockPanedWidget_GetHexpand_Call) Run(run func()) MockPanedWidget_GetHexpand_Call {
	293	+	_c.Call.Run(func(args mock.Arguments) {
	294	+	run()
	295	+	})
	296	+	return _c
	297	+	}
	298	+
	299	+	func (_c MockPanedWidget_GetHexpand_Call) Return(b bool) MockPanedWidget_GetHexpand_Call {
	300	+	_c.Call.Return(b)
	301	+	return _c
	302	+	}
	303	+
	304	+	func (_c MockPanedWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockPanedWidget_GetHexpand_Call {
	305	+	_c.Call.Return(run)
	306	+	return _c
	307	+	}
	308	+
	309	+	// GetParent provides a mock function for the type MockPanedWidget
	310	+	func (_mock *MockPanedWidget) GetParent() layout.Widget {
	311	+	ret := _mock.Called()
	312	+
	313	+	if len(ret) == 0 {
	314	+	panic("no return value specified for GetParent")
	315	+	}
	316	+
	317	+	var r0 layout.Widget
	318	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	319	+	r0 = returnFunc()
	320	+	} else {
	321	+	if ret.Get(0) != nil {
	322	+	r0 = ret.Get(0).(layout.Widget)
	323	+	}
	324	+	}
	325	+	return r0
	326	+	}
	327	+
	328	+	// MockPanedWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	329	+	type MockPanedWidget_GetParent_Call struct {
	330	+	*mock.Call
	331	+	}
	332	+
	333	+	// GetParent is a helper method to define mock.On call
	334	+	func (_e MockPanedWidget_Expecter) GetParent() MockPanedWidget_GetParent_Call {
	335	+	return &MockPanedWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	336	+	}
	337	+
	338	+	func (_c MockPanedWidget_GetParent_Call) Run(run func()) MockPanedWidget_GetParent_Call {
	339	+	_c.Call.Run(func(args mock.Arguments) {
	340	+	run()
	341	+	})
	342	+	return _c
	343	+	}
	344	+
	345	+	func (_c MockPanedWidget_GetParent_Call) Return(widget layout.Widget) MockPanedWidget_GetParent_Call {
	346	+	_c.Call.Return(widget)
	347	+	return _c
	348	+	}
	349	+
	350	+	func (_c MockPanedWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockPanedWidget_GetParent_Call {
	351	+	_c.Call.Return(run)
	352	+	return _c
	353	+	}
	354	+
	355	+	// GetPosition provides a mock function for the type MockPanedWidget
	356	+	func (_mock *MockPanedWidget) GetPosition() int {
	357	+	ret := _mock.Called()
	358	+
	359	+	if len(ret) == 0 {
	360	+	panic("no return value specified for GetPosition")
	361	+	}
	362	+
	363	+	var r0 int
	364	+	if returnFunc, ok := ret.Get(0).(func() int); ok {
	365	+	r0 = returnFunc()
	366	+	} else {
	367	+	r0 = ret.Get(0).(int)
	368	+	}
	369	+	return r0
	370	+	}
	371	+
	372	+	// MockPanedWidget_GetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPosition'
	373	+	type MockPanedWidget_GetPosition_Call struct {
	374	+	*mock.Call
	375	+	}
	376	+
	377	+	// GetPosition is a helper method to define mock.On call
	378	+	func (_e MockPanedWidget_Expecter) GetPosition() MockPanedWidget_GetPosition_Call {
	379	+	return &MockPanedWidget_GetPosition_Call{Call: _e.mock.On("GetPosition")}
	380	+	}
	381	+
	382	+	func (_c MockPanedWidget_GetPosition_Call) Run(run func()) MockPanedWidget_GetPosition_Call {
	383	+	_c.Call.Run(func(args mock.Arguments) {
	384	+	run()
	385	+	})
	386	+	return _c
	387	+	}
	388	+
	389	+	func (_c MockPanedWidget_GetPosition_Call) Return(n int) MockPanedWidget_GetPosition_Call {
	390	+	_c.Call.Return(n)
	391	+	return _c
	392	+	}
	393	+
	394	+	func (_c MockPanedWidget_GetPosition_Call) RunAndReturn(run func() int) MockPanedWidget_GetPosition_Call {
	395	+	_c.Call.Return(run)
	396	+	return _c
	397	+	}
	398	+
	399	+	// GetResizeEndChild provides a mock function for the type MockPanedWidget
	400	+	func (_mock *MockPanedWidget) GetResizeEndChild() bool {
	401	+	ret := _mock.Called()
	402	+
	403	+	if len(ret) == 0 {
	404	+	panic("no return value specified for GetResizeEndChild")
	405	+	}
	406	+
	407	+	var r0 bool
	408	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	409	+	r0 = returnFunc()
	410	+	} else {
	411	+	r0 = ret.Get(0).(bool)
	412	+	}
	413	+	return r0
	414	+	}
	415	+
	416	+	// MockPanedWidget_GetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeEndChild'
	417	+	type MockPanedWidget_GetResizeEndChild_Call struct {
	418	+	*mock.Call
	419	+	}
	420	+
	421	+	// GetResizeEndChild is a helper method to define mock.On call
	422	+	func (_e MockPanedWidget_Expecter) GetResizeEndChild() MockPanedWidget_GetResizeEndChild_Call {
	423	+	return &MockPanedWidget_GetResizeEndChild_Call{Call: _e.mock.On("GetResizeEndChild")}
	424	+	}
	425	+
	426	+	func (_c MockPanedWidget_GetResizeEndChild_Call) Run(run func()) MockPanedWidget_GetResizeEndChild_Call {
	427	+	_c.Call.Run(func(args mock.Arguments) {
	428	+	run()
	429	+	})
	430	+	return _c
	431	+	}
	432	+
	433	+	func (_c MockPanedWidget_GetResizeEndChild_Call) Return(b bool) MockPanedWidget_GetResizeEndChild_Call {
	434	+	_c.Call.Return(b)
	435	+	return _c
	436	+	}
	437	+
	438	+	func (_c MockPanedWidget_GetResizeEndChild_Call) RunAndReturn(run func() bool) MockPanedWidget_GetResizeEndChild_Call {
	439	+	_c.Call.Return(run)
	440	+	return _c
	441	+	}
	442	+
	443	+	// GetResizeStartChild provides a mock function for the type MockPanedWidget
	444	+	func (_mock *MockPanedWidget) GetResizeStartChild() bool {
	445	+	ret := _mock.Called()
	446	+
	447	+	if len(ret) == 0 {
	448	+	panic("no return value specified for GetResizeStartChild")
	449	+	}
	450	+
	451	+	var r0 bool
	452	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	453	+	r0 = returnFunc()
	454	+	} else {
	455	+	r0 = ret.Get(0).(bool)
	456	+	}
	457	+	return r0
	458	+	}
	459	+
	460	+	// MockPanedWidget_GetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResizeStartChild'
	461	+	type MockPanedWidget_GetResizeStartChild_Call struct {
	462	+	*mock.Call
	463	+	}
	464	+
	465	+	// GetResizeStartChild is a helper method to define mock.On call
	466	+	func (_e MockPanedWidget_Expecter) GetResizeStartChild() MockPanedWidget_GetResizeStartChild_Call {
	467	+	return &MockPanedWidget_GetResizeStartChild_Call{Call: _e.mock.On("GetResizeStartChild")}
	468	+	}
	469	+
	470	+	func (_c MockPanedWidget_GetResizeStartChild_Call) Run(run func()) MockPanedWidget_GetResizeStartChild_Call {
	471	+	_c.Call.Run(func(args mock.Arguments) {
	472	+	run()
	473	+	})
	474	+	return _c
	475	+	}
	476	+
	477	+	func (_c MockPanedWidget_GetResizeStartChild_Call) Return(b bool) MockPanedWidget_GetResizeStartChild_Call {
	478	+	_c.Call.Return(b)
	479	+	return _c
	480	+	}
	481	+
	482	+	func (_c MockPanedWidget_GetResizeStartChild_Call) RunAndReturn(run func() bool) MockPanedWidget_GetResizeStartChild_Call {
	483	+	_c.Call.Return(run)
	484	+	return _c
	485	+	}
	486	+
	487	+	// GetShrinkEndChild provides a mock function for the type MockPanedWidget
	488	+	func (_mock *MockPanedWidget) GetShrinkEndChild() bool {
	489	+	ret := _mock.Called()
	490	+
	491	+	if len(ret) == 0 {
	492	+	panic("no return value specified for GetShrinkEndChild")
	493	+	}
	494	+
	495	+	var r0 bool
	496	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	497	+	r0 = returnFunc()
	498	+	} else {
	499	+	r0 = ret.Get(0).(bool)
	500	+	}
	501	+	return r0
	502	+	}
	503	+
	504	+	// MockPanedWidget_GetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkEndChild'
	505	+	type MockPanedWidget_GetShrinkEndChild_Call struct {
	506	+	*mock.Call
	507	+	}
	508	+
	509	+	// GetShrinkEndChild is a helper method to define mock.On call
	510	+	func (_e MockPanedWidget_Expecter) GetShrinkEndChild() MockPanedWidget_GetShrinkEndChild_Call {
	511	+	return &MockPanedWidget_GetShrinkEndChild_Call{Call: _e.mock.On("GetShrinkEndChild")}
	512	+	}
	513	+
	514	+	func (_c MockPanedWidget_GetShrinkEndChild_Call) Run(run func()) MockPanedWidget_GetShrinkEndChild_Call {
	515	+	_c.Call.Run(func(args mock.Arguments) {
	516	+	run()
	517	+	})
	518	+	return _c
	519	+	}
	520	+
	521	+	func (_c MockPanedWidget_GetShrinkEndChild_Call) Return(b bool) MockPanedWidget_GetShrinkEndChild_Call {
	522	+	_c.Call.Return(b)
	523	+	return _c
	524	+	}
	525	+
	526	+	func (_c MockPanedWidget_GetShrinkEndChild_Call) RunAndReturn(run func() bool) MockPanedWidget_GetShrinkEndChild_Call {
	527	+	_c.Call.Return(run)
	528	+	return _c
	529	+	}
	530	+
	531	+	// GetShrinkStartChild provides a mock function for the type MockPanedWidget
	532	+	func (_mock *MockPanedWidget) GetShrinkStartChild() bool {
	533	+	ret := _mock.Called()
	534	+
	535	+	if len(ret) == 0 {
	536	+	panic("no return value specified for GetShrinkStartChild")
	537	+	}
	538	+
	539	+	var r0 bool
	540	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	541	+	r0 = returnFunc()
	542	+	} else {
	543	+	r0 = ret.Get(0).(bool)
	544	+	}
	545	+	return r0
	546	+	}
	547	+
	548	+	// MockPanedWidget_GetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShrinkStartChild'
	549	+	type MockPanedWidget_GetShrinkStartChild_Call struct {
	550	+	*mock.Call
	551	+	}
	552	+
	553	+	// GetShrinkStartChild is a helper method to define mock.On call
	554	+	func (_e MockPanedWidget_Expecter) GetShrinkStartChild() MockPanedWidget_GetShrinkStartChild_Call {
	555	+	return &MockPanedWidget_GetShrinkStartChild_Call{Call: _e.mock.On("GetShrinkStartChild")}
	556	+	}
	557	+
	558	+	func (_c MockPanedWidget_GetShrinkStartChild_Call) Run(run func()) MockPanedWidget_GetShrinkStartChild_Call {
	559	+	_c.Call.Run(func(args mock.Arguments) {
	560	+	run()
	561	+	})
	562	+	return _c
	563	+	}
	564	+
	565	+	func (_c MockPanedWidget_GetShrinkStartChild_Call) Return(b bool) MockPanedWidget_GetShrinkStartChild_Call {
	566	+	_c.Call.Return(b)
	567	+	return _c
	568	+	}
	569	+
	570	+	func (_c MockPanedWidget_GetShrinkStartChild_Call) RunAndReturn(run func() bool) MockPanedWidget_GetShrinkStartChild_Call {
	571	+	_c.Call.Return(run)
	572	+	return _c
	573	+	}
	574	+
	575	+	// GetStartChild provides a mock function for the type MockPanedWidget
	576	+	func (_mock *MockPanedWidget) GetStartChild() layout.Widget {
	577	+	ret := _mock.Called()
	578	+
	579	+	if len(ret) == 0 {
	580	+	panic("no return value specified for GetStartChild")
	581	+	}
	582	+
	583	+	var r0 layout.Widget
	584	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	585	+	r0 = returnFunc()
	586	+	} else {
	587	+	if ret.Get(0) != nil {
	588	+	r0 = ret.Get(0).(layout.Widget)
	589	+	}
	590	+	}
	591	+	return r0
	592	+	}
	593	+
	594	+	// MockPanedWidget_GetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStartChild'
	595	+	type MockPanedWidget_GetStartChild_Call struct {
	596	+	*mock.Call
	597	+	}
	598	+
	599	+	// GetStartChild is a helper method to define mock.On call
	600	+	func (_e MockPanedWidget_Expecter) GetStartChild() MockPanedWidget_GetStartChild_Call {
	601	+	return &MockPanedWidget_GetStartChild_Call{Call: _e.mock.On("GetStartChild")}
	602	+	}
	603	+
	604	+	func (_c MockPanedWidget_GetStartChild_Call) Run(run func()) MockPanedWidget_GetStartChild_Call {
	605	+	_c.Call.Run(func(args mock.Arguments) {
	606	+	run()
	607	+	})
	608	+	return _c
	609	+	}
	610	+
	611	+	func (_c MockPanedWidget_GetStartChild_Call) Return(widget layout.Widget) MockPanedWidget_GetStartChild_Call {
	612	+	_c.Call.Return(widget)
	613	+	return _c
	614	+	}
	615	+
	616	+	func (_c MockPanedWidget_GetStartChild_Call) RunAndReturn(run func() layout.Widget) MockPanedWidget_GetStartChild_Call {
	617	+	_c.Call.Return(run)
	618	+	return _c
	619	+	}
	620	+
	621	+	// GetVexpand provides a mock function for the type MockPanedWidget
	622	+	func (_mock *MockPanedWidget) GetVexpand() bool {
	623	+	ret := _mock.Called()
	624	+
	625	+	if len(ret) == 0 {
	626	+	panic("no return value specified for GetVexpand")
	627	+	}
	628	+
	629	+	var r0 bool
	630	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	631	+	r0 = returnFunc()
	632	+	} else {
	633	+	r0 = ret.Get(0).(bool)
	634	+	}
	635	+	return r0
	636	+	}
	637	+
	638	+	// MockPanedWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	639	+	type MockPanedWidget_GetVexpand_Call struct {
	640	+	*mock.Call
	641	+	}
	642	+
	643	+	// GetVexpand is a helper method to define mock.On call
	644	+	func (_e MockPanedWidget_Expecter) GetVexpand() MockPanedWidget_GetVexpand_Call {
	645	+	return &MockPanedWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	646	+	}
	647	+
	648	+	func (_c MockPanedWidget_GetVexpand_Call) Run(run func()) MockPanedWidget_GetVexpand_Call {
	649	+	_c.Call.Run(func(args mock.Arguments) {
	650	+	run()
	651	+	})
	652	+	return _c
	653	+	}
	654	+
	655	+	func (_c MockPanedWidget_GetVexpand_Call) Return(b bool) MockPanedWidget_GetVexpand_Call {
	656	+	_c.Call.Return(b)
	657	+	return _c
	658	+	}
	659	+
	660	+	func (_c MockPanedWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockPanedWidget_GetVexpand_Call {
	661	+	_c.Call.Return(run)
	662	+	return _c
	663	+	}
	664	+
	665	+	// GetWideHandle provides a mock function for the type MockPanedWidget
	666	+	func (_mock *MockPanedWidget) GetWideHandle() bool {
	667	+	ret := _mock.Called()
	668	+
	669	+	if len(ret) == 0 {
	670	+	panic("no return value specified for GetWideHandle")
	671	+	}
	672	+
	673	+	var r0 bool
	674	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	675	+	r0 = returnFunc()
	676	+	} else {
	677	+	r0 = ret.Get(0).(bool)
	678	+	}
	679	+	return r0
	680	+	}
	681	+
	682	+	// MockPanedWidget_GetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWideHandle'
	683	+	type MockPanedWidget_GetWideHandle_Call struct {
	684	+	*mock.Call
	685	+	}
	686	+
	687	+	// GetWideHandle is a helper method to define mock.On call
	688	+	func (_e MockPanedWidget_Expecter) GetWideHandle() MockPanedWidget_GetWideHandle_Call {
	689	+	return &MockPanedWidget_GetWideHandle_Call{Call: _e.mock.On("GetWideHandle")}
	690	+	}
	691	+
	692	+	func (_c MockPanedWidget_GetWideHandle_Call) Run(run func()) MockPanedWidget_GetWideHandle_Call {
	693	+	_c.Call.Run(func(args mock.Arguments) {
	694	+	run()
	695	+	})
	696	+	return _c
	697	+	}
	698	+
	699	+	func (_c MockPanedWidget_GetWideHandle_Call) Return(b bool) MockPanedWidget_GetWideHandle_Call {
	700	+	_c.Call.Return(b)
	701	+	return _c
	702	+	}
	703	+
	704	+	func (_c MockPanedWidget_GetWideHandle_Call) RunAndReturn(run func() bool) MockPanedWidget_GetWideHandle_Call {
	705	+	_c.Call.Return(run)
	706	+	return _c
	707	+	}
	708	+
	709	+	// GrabFocus provides a mock function for the type MockPanedWidget
	710	+	func (_mock *MockPanedWidget) GrabFocus() bool {
	711	+	ret := _mock.Called()
	712	+
	713	+	if len(ret) == 0 {
	714	+	panic("no return value specified for GrabFocus")
	715	+	}
	716	+
	717	+	var r0 bool
	718	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	719	+	r0 = returnFunc()
	720	+	} else {
	721	+	r0 = ret.Get(0).(bool)
	722	+	}
	723	+	return r0
	724	+	}
	725	+
	726	+	// MockPanedWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	727	+	type MockPanedWidget_GrabFocus_Call struct {
	728	+	*mock.Call
	729	+	}
	730	+
	731	+	// GrabFocus is a helper method to define mock.On call
	732	+	func (_e MockPanedWidget_Expecter) GrabFocus() MockPanedWidget_GrabFocus_Call {
	733	+	return &MockPanedWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	734	+	}
	735	+
	736	+	func (_c MockPanedWidget_GrabFocus_Call) Run(run func()) MockPanedWidget_GrabFocus_Call {
	737	+	_c.Call.Run(func(args mock.Arguments) {
	738	+	run()
	739	+	})
	740	+	return _c
	741	+	}
	742	+
	743	+	func (_c MockPanedWidget_GrabFocus_Call) Return(b bool) MockPanedWidget_GrabFocus_Call {
	744	+	_c.Call.Return(b)
	745	+	return _c
	746	+	}
	747	+
	748	+	func (_c MockPanedWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockPanedWidget_GrabFocus_Call {
	749	+	_c.Call.Return(run)
	750	+	return _c
	751	+	}
	752	+
	753	+	// GtkWidget provides a mock function for the type MockPanedWidget
	754	+	func (_mock MockPanedWidget) GtkWidget() gtk.Widget {
	755	+	ret := _mock.Called()
	756	+
	757	+	if len(ret) == 0 {
	758	+	panic("no return value specified for GtkWidget")
	759	+	}
	760	+
	761	+	var r0 *gtk.Widget
	762	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	763	+	r0 = returnFunc()
	764	+	} else {
	765	+	if ret.Get(0) != nil {
	766	+	r0 = ret.Get(0).(*gtk.Widget)
	767	+	}
	768	+	}
	769	+	return r0
	770	+	}
	771	+
	772	+	// MockPanedWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	773	+	type MockPanedWidget_GtkWidget_Call struct {
	774	+	*mock.Call
	775	+	}
	776	+
	777	+	// GtkWidget is a helper method to define mock.On call
	778	+	func (_e MockPanedWidget_Expecter) GtkWidget() MockPanedWidget_GtkWidget_Call {
	779	+	return &MockPanedWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	780	+	}
	781	+
	782	+	func (_c MockPanedWidget_GtkWidget_Call) Run(run func()) MockPanedWidget_GtkWidget_Call {
	783	+	_c.Call.Run(func(args mock.Arguments) {
	784	+	run()
	785	+	})
	786	+	return _c
	787	+	}
	788	+
	789	+	func (_c MockPanedWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockPanedWidget_GtkWidget_Call {
	790	+	_c.Call.Return(widget)
	791	+	return _c
	792	+	}
	793	+
	794	+	func (_c MockPanedWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockPanedWidget_GtkWidget_Call {
	795	+	_c.Call.Return(run)
	796	+	return _c
	797	+	}
	798	+
	799	+	// HasCssClass provides a mock function for the type MockPanedWidget
	800	+	func (_mock *MockPanedWidget) HasCssClass(cssClass string) bool {
	801	+	ret := _mock.Called(cssClass)
	802	+
	803	+	if len(ret) == 0 {
	804	+	panic("no return value specified for HasCssClass")
	805	+	}
	806	+
	807	+	var r0 bool
	808	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	809	+	r0 = returnFunc(cssClass)
	810	+	} else {
	811	+	r0 = ret.Get(0).(bool)
	812	+	}
	813	+	return r0
	814	+	}
	815	+
	816	+	// MockPanedWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	817	+	type MockPanedWidget_HasCssClass_Call struct {
	818	+	*mock.Call
	819	+	}
	820	+
	821	+	// HasCssClass is a helper method to define mock.On call
	822	+	// - cssClass string
	823	+	func (_e MockPanedWidget_Expecter) HasCssClass(cssClass interface{}) MockPanedWidget_HasCssClass_Call {
	824	+	return &MockPanedWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	825	+	}
	826	+
	827	+	func (_c MockPanedWidget_HasCssClass_Call) Run(run func(cssClass string)) MockPanedWidget_HasCssClass_Call {
	828	+	_c.Call.Run(func(args mock.Arguments) {
	829	+	var arg0 string
	830	+	if args[0] != nil {
	831	+	arg0 = args[0].(string)
	832	+	}
	833	+	run(
	834	+	arg0,
	835	+	)
	836	+	})
	837	+	return _c
	838	+	}
	839	+
	840	+	func (_c MockPanedWidget_HasCssClass_Call) Return(b bool) MockPanedWidget_HasCssClass_Call {
	841	+	_c.Call.Return(b)
	842	+	return _c
	843	+	}
	844	+
	845	+	func (_c MockPanedWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockPanedWidget_HasCssClass_Call {
	846	+	_c.Call.Return(run)
	847	+	return _c
	848	+	}
	849	+
	850	+	// HasFocus provides a mock function for the type MockPanedWidget
	851	+	func (_mock *MockPanedWidget) HasFocus() bool {
	852	+	ret := _mock.Called()
	853	+
	854	+	if len(ret) == 0 {
	855	+	panic("no return value specified for HasFocus")
	856	+	}
	857	+
	858	+	var r0 bool
	859	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	860	+	r0 = returnFunc()
	861	+	} else {
	862	+	r0 = ret.Get(0).(bool)
	863	+	}
	864	+	return r0
	865	+	}
	866	+
	867	+	// MockPanedWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	868	+	type MockPanedWidget_HasFocus_Call struct {
	869	+	*mock.Call
	870	+	}
	871	+
	872	+	// HasFocus is a helper method to define mock.On call
	873	+	func (_e MockPanedWidget_Expecter) HasFocus() MockPanedWidget_HasFocus_Call {
	874	+	return &MockPanedWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	875	+	}
	876	+
	877	+	func (_c MockPanedWidget_HasFocus_Call) Run(run func()) MockPanedWidget_HasFocus_Call {
	878	+	_c.Call.Run(func(args mock.Arguments) {
	879	+	run()
	880	+	})
	881	+	return _c
	882	+	}
	883	+
	884	+	func (_c MockPanedWidget_HasFocus_Call) Return(b bool) MockPanedWidget_HasFocus_Call {
	885	+	_c.Call.Return(b)
	886	+	return _c
	887	+	}
	888	+
	889	+	func (_c MockPanedWidget_HasFocus_Call) RunAndReturn(run func() bool) MockPanedWidget_HasFocus_Call {
	890	+	_c.Call.Return(run)
	891	+	return _c
	892	+	}
	893	+
	894	+	// Hide provides a mock function for the type MockPanedWidget
	895	+	func (_mock *MockPanedWidget) Hide() {
	896	+	_mock.Called()
	897	+	return
	898	+	}
	899	+
	900	+	// MockPanedWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	901	+	type MockPanedWidget_Hide_Call struct {
	902	+	*mock.Call
	903	+	}
	904	+
	905	+	// Hide is a helper method to define mock.On call
	906	+	func (_e MockPanedWidget_Expecter) Hide() MockPanedWidget_Hide_Call {
	907	+	return &MockPanedWidget_Hide_Call{Call: _e.mock.On("Hide")}
	908	+	}
	909	+
	910	+	func (_c MockPanedWidget_Hide_Call) Run(run func()) MockPanedWidget_Hide_Call {
	911	+	_c.Call.Run(func(args mock.Arguments) {
	912	+	run()
	913	+	})
	914	+	return _c
	915	+	}
	916	+
	917	+	func (_c MockPanedWidget_Hide_Call) Return() MockPanedWidget_Hide_Call {
	918	+	_c.Call.Return()
	919	+	return _c
	920	+	}
	921	+
	922	+	func (_c MockPanedWidget_Hide_Call) RunAndReturn(run func()) MockPanedWidget_Hide_Call {
	923	+	_c.Run(run)
	924	+	return _c
	925	+	}
	926	+
	927	+	// IsVisible provides a mock function for the type MockPanedWidget
	928	+	func (_mock *MockPanedWidget) IsVisible() bool {
	929	+	ret := _mock.Called()
	930	+
	931	+	if len(ret) == 0 {
	932	+	panic("no return value specified for IsVisible")
	933	+	}
	934	+
	935	+	var r0 bool
	936	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	937	+	r0 = returnFunc()
	938	+	} else {
	939	+	r0 = ret.Get(0).(bool)
	940	+	}
	941	+	return r0
	942	+	}
	943	+
	944	+	// MockPanedWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	945	+	type MockPanedWidget_IsVisible_Call struct {
	946	+	*mock.Call
	947	+	}
	948	+
	949	+	// IsVisible is a helper method to define mock.On call
	950	+	func (_e MockPanedWidget_Expecter) IsVisible() MockPanedWidget_IsVisible_Call {
	951	+	return &MockPanedWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	952	+	}
	953	+
	954	+	func (_c MockPanedWidget_IsVisible_Call) Run(run func()) MockPanedWidget_IsVisible_Call {
	955	+	_c.Call.Run(func(args mock.Arguments) {
	956	+	run()
	957	+	})
	958	+	return _c
	959	+	}
	960	+
	961	+	func (_c MockPanedWidget_IsVisible_Call) Return(b bool) MockPanedWidget_IsVisible_Call {
	962	+	_c.Call.Return(b)
	963	+	return _c
	964	+	}
	965	+
	966	+	func (_c MockPanedWidget_IsVisible_Call) RunAndReturn(run func() bool) MockPanedWidget_IsVisible_Call {
	967	+	_c.Call.Return(run)
	968	+	return _c
	969	+	}
	970	+
	971	+	// RemoveCssClass provides a mock function for the type MockPanedWidget
	972	+	func (_mock *MockPanedWidget) RemoveCssClass(cssClass string) {
	973	+	_mock.Called(cssClass)
	974	+	return
	975	+	}
	976	+
	977	+	// MockPanedWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	978	+	type MockPanedWidget_RemoveCssClass_Call struct {
	979	+	*mock.Call
	980	+	}
	981	+
	982	+	// RemoveCssClass is a helper method to define mock.On call
	983	+	// - cssClass string
	984	+	func (_e MockPanedWidget_Expecter) RemoveCssClass(cssClass interface{}) MockPanedWidget_RemoveCssClass_Call {
	985	+	return &MockPanedWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	986	+	}
	987	+
	988	+	func (_c MockPanedWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockPanedWidget_RemoveCssClass_Call {
	989	+	_c.Call.Run(func(args mock.Arguments) {
	990	+	var arg0 string
	991	+	if args[0] != nil {
	992	+	arg0 = args[0].(string)
	993	+	}
	994	+	run(
	995	+	arg0,
	996	+	)
	997	+	})
	998	+	return _c
	999	+	}
	1000	+
	1001	+	func (_c MockPanedWidget_RemoveCssClass_Call) Return() MockPanedWidget_RemoveCssClass_Call {
	1002	+	_c.Call.Return()
	1003	+	return _c
	1004	+	}
	1005	+
	1006	+	func (_c MockPanedWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockPanedWidget_RemoveCssClass_Call {
	1007	+	_c.Run(run)
	1008	+	return _c
	1009	+	}
	1010	+
	1011	+	// SetCanFocus provides a mock function for the type MockPanedWidget
	1012	+	func (_mock *MockPanedWidget) SetCanFocus(canFocus bool) {
	1013	+	_mock.Called(canFocus)
	1014	+	return
	1015	+	}
	1016	+
	1017	+	// MockPanedWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	1018	+	type MockPanedWidget_SetCanFocus_Call struct {
	1019	+	*mock.Call
	1020	+	}
	1021	+
	1022	+	// SetCanFocus is a helper method to define mock.On call
	1023	+	// - canFocus bool
	1024	+	func (_e MockPanedWidget_Expecter) SetCanFocus(canFocus interface{}) MockPanedWidget_SetCanFocus_Call {
	1025	+	return &MockPanedWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	1026	+	}
	1027	+
	1028	+	func (_c MockPanedWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockPanedWidget_SetCanFocus_Call {
	1029	+	_c.Call.Run(func(args mock.Arguments) {
	1030	+	var arg0 bool
	1031	+	if args[0] != nil {
	1032	+	arg0 = args[0].(bool)
	1033	+	}
	1034	+	run(
	1035	+	arg0,
	1036	+	)
	1037	+	})
	1038	+	return _c
	1039	+	}
	1040	+
	1041	+	func (_c MockPanedWidget_SetCanFocus_Call) Return() MockPanedWidget_SetCanFocus_Call {
	1042	+	_c.Call.Return()
	1043	+	return _c
	1044	+	}
	1045	+
	1046	+	func (_c MockPanedWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockPanedWidget_SetCanFocus_Call {
	1047	+	_c.Run(run)
	1048	+	return _c
	1049	+	}
	1050	+
	1051	+	// SetEndChild provides a mock function for the type MockPanedWidget
	1052	+	func (_mock *MockPanedWidget) SetEndChild(child layout.Widget) {
	1053	+	_mock.Called(child)
	1054	+	return
	1055	+	}
	1056	+
	1057	+	// MockPanedWidget_SetEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetEndChild'
	1058	+	type MockPanedWidget_SetEndChild_Call struct {
	1059	+	*mock.Call
	1060	+	}
	1061	+
	1062	+	// SetEndChild is a helper method to define mock.On call
	1063	+	// - child layout.Widget
	1064	+	func (_e MockPanedWidget_Expecter) SetEndChild(child interface{}) MockPanedWidget_SetEndChild_Call {
	1065	+	return &MockPanedWidget_SetEndChild_Call{Call: _e.mock.On("SetEndChild", child)}
	1066	+	}
	1067	+
	1068	+	func (_c MockPanedWidget_SetEndChild_Call) Run(run func(child layout.Widget)) MockPanedWidget_SetEndChild_Call {
	1069	+	_c.Call.Run(func(args mock.Arguments) {
	1070	+	var arg0 layout.Widget
	1071	+	if args[0] != nil {
	1072	+	arg0 = args[0].(layout.Widget)
	1073	+	}
	1074	+	run(
	1075	+	arg0,
	1076	+	)
	1077	+	})
	1078	+	return _c
	1079	+	}
	1080	+
	1081	+	func (_c MockPanedWidget_SetEndChild_Call) Return() MockPanedWidget_SetEndChild_Call {
	1082	+	_c.Call.Return()
	1083	+	return _c
	1084	+	}
	1085	+
	1086	+	func (_c MockPanedWidget_SetEndChild_Call) RunAndReturn(run func(child layout.Widget)) MockPanedWidget_SetEndChild_Call {
	1087	+	_c.Run(run)
	1088	+	return _c
	1089	+	}
	1090	+
	1091	+	// SetFocusOnClick provides a mock function for the type MockPanedWidget
	1092	+	func (_mock *MockPanedWidget) SetFocusOnClick(focusOnClick bool) {
	1093	+	_mock.Called(focusOnClick)
	1094	+	return
	1095	+	}
	1096	+
	1097	+	// MockPanedWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	1098	+	type MockPanedWidget_SetFocusOnClick_Call struct {
	1099	+	*mock.Call
	1100	+	}
	1101	+
	1102	+	// SetFocusOnClick is a helper method to define mock.On call
	1103	+	// - focusOnClick bool
	1104	+	func (_e MockPanedWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockPanedWidget_SetFocusOnClick_Call {
	1105	+	return &MockPanedWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	1106	+	}
	1107	+
	1108	+	func (_c MockPanedWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockPanedWidget_SetFocusOnClick_Call {
	1109	+	_c.Call.Run(func(args mock.Arguments) {
	1110	+	var arg0 bool
	1111	+	if args[0] != nil {
	1112	+	arg0 = args[0].(bool)
	1113	+	}
	1114	+	run(
	1115	+	arg0,
	1116	+	)
	1117	+	})
	1118	+	return _c
	1119	+	}
	1120	+
	1121	+	func (_c MockPanedWidget_SetFocusOnClick_Call) Return() MockPanedWidget_SetFocusOnClick_Call {
	1122	+	_c.Call.Return()
	1123	+	return _c
	1124	+	}
	1125	+
	1126	+	func (_c MockPanedWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockPanedWidget_SetFocusOnClick_Call {
	1127	+	_c.Run(run)
	1128	+	return _c
	1129	+	}
	1130	+
	1131	+	// SetHalign provides a mock function for the type MockPanedWidget
	1132	+	func (_mock *MockPanedWidget) SetHalign(align gtk.Align) {
	1133	+	_mock.Called(align)
	1134	+	return
	1135	+	}
	1136	+
	1137	+	// MockPanedWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	1138	+	type MockPanedWidget_SetHalign_Call struct {
	1139	+	*mock.Call
	1140	+	}
	1141	+
	1142	+	// SetHalign is a helper method to define mock.On call
	1143	+	// - align gtk.Align
	1144	+	func (_e MockPanedWidget_Expecter) SetHalign(align interface{}) MockPanedWidget_SetHalign_Call {
	1145	+	return &MockPanedWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	1146	+	}
	1147	+
	1148	+	func (_c MockPanedWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockPanedWidget_SetHalign_Call {
	1149	+	_c.Call.Run(func(args mock.Arguments) {
	1150	+	var arg0 gtk.Align
	1151	+	if args[0] != nil {
	1152	+	arg0 = args[0].(gtk.Align)
	1153	+	}
	1154	+	run(
	1155	+	arg0,
	1156	+	)
	1157	+	})
	1158	+	return _c
	1159	+	}
	1160	+
	1161	+	func (_c MockPanedWidget_SetHalign_Call) Return() MockPanedWidget_SetHalign_Call {
	1162	+	_c.Call.Return()
	1163	+	return _c
	1164	+	}
	1165	+
	1166	+	func (_c MockPanedWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockPanedWidget_SetHalign_Call {
	1167	+	_c.Run(run)
	1168	+	return _c
	1169	+	}
	1170	+
	1171	+	// SetHexpand provides a mock function for the type MockPanedWidget
	1172	+	func (_mock *MockPanedWidget) SetHexpand(expand bool) {
	1173	+	_mock.Called(expand)
	1174	+	return
	1175	+	}
	1176	+
	1177	+	// MockPanedWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	1178	+	type MockPanedWidget_SetHexpand_Call struct {
	1179	+	*mock.Call
	1180	+	}
	1181	+
	1182	+	// SetHexpand is a helper method to define mock.On call
	1183	+	// - expand bool
	1184	+	func (_e MockPanedWidget_Expecter) SetHexpand(expand interface{}) MockPanedWidget_SetHexpand_Call {
	1185	+	return &MockPanedWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	1186	+	}
	1187	+
	1188	+	func (_c MockPanedWidget_SetHexpand_Call) Run(run func(expand bool)) MockPanedWidget_SetHexpand_Call {
	1189	+	_c.Call.Run(func(args mock.Arguments) {
	1190	+	var arg0 bool
	1191	+	if args[0] != nil {
	1192	+	arg0 = args[0].(bool)
	1193	+	}
	1194	+	run(
	1195	+	arg0,
	1196	+	)
	1197	+	})
	1198	+	return _c
	1199	+	}
	1200	+
	1201	+	func (_c MockPanedWidget_SetHexpand_Call) Return() MockPanedWidget_SetHexpand_Call {
	1202	+	_c.Call.Return()
	1203	+	return _c
	1204	+	}
	1205	+
	1206	+	func (_c MockPanedWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockPanedWidget_SetHexpand_Call {
	1207	+	_c.Run(run)
	1208	+	return _c
	1209	+	}
	1210	+
	1211	+	// SetPosition provides a mock function for the type MockPanedWidget
	1212	+	func (_mock *MockPanedWidget) SetPosition(position int) {
	1213	+	_mock.Called(position)
	1214	+	return
	1215	+	}
	1216	+
	1217	+	// MockPanedWidget_SetPosition_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPosition'
	1218	+	type MockPanedWidget_SetPosition_Call struct {
	1219	+	*mock.Call
	1220	+	}
	1221	+
	1222	+	// SetPosition is a helper method to define mock.On call
	1223	+	// - position int
	1224	+	func (_e MockPanedWidget_Expecter) SetPosition(position interface{}) MockPanedWidget_SetPosition_Call {
	1225	+	return &MockPanedWidget_SetPosition_Call{Call: _e.mock.On("SetPosition", position)}
	1226	+	}
	1227	+
	1228	+	func (_c MockPanedWidget_SetPosition_Call) Run(run func(position int)) MockPanedWidget_SetPosition_Call {
	1229	+	_c.Call.Run(func(args mock.Arguments) {
	1230	+	var arg0 int
	1231	+	if args[0] != nil {
	1232	+	arg0 = args[0].(int)
	1233	+	}
	1234	+	run(
	1235	+	arg0,
	1236	+	)
	1237	+	})
	1238	+	return _c
	1239	+	}
	1240	+
	1241	+	func (_c MockPanedWidget_SetPosition_Call) Return() MockPanedWidget_SetPosition_Call {
	1242	+	_c.Call.Return()
	1243	+	return _c
	1244	+	}
	1245	+
	1246	+	func (_c MockPanedWidget_SetPosition_Call) RunAndReturn(run func(position int)) MockPanedWidget_SetPosition_Call {
	1247	+	_c.Run(run)
	1248	+	return _c
	1249	+	}
	1250	+
	1251	+	// SetResizeEndChild provides a mock function for the type MockPanedWidget
	1252	+	func (_mock *MockPanedWidget) SetResizeEndChild(resize bool) {
	1253	+	_mock.Called(resize)
	1254	+	return
	1255	+	}
	1256	+
	1257	+	// MockPanedWidget_SetResizeEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeEndChild'
	1258	+	type MockPanedWidget_SetResizeEndChild_Call struct {
	1259	+	*mock.Call
	1260	+	}
	1261	+
	1262	+	// SetResizeEndChild is a helper method to define mock.On call
	1263	+	// - resize bool
	1264	+	func (_e MockPanedWidget_Expecter) SetResizeEndChild(resize interface{}) MockPanedWidget_SetResizeEndChild_Call {
	1265	+	return &MockPanedWidget_SetResizeEndChild_Call{Call: _e.mock.On("SetResizeEndChild", resize)}
	1266	+	}
	1267	+
	1268	+	func (_c MockPanedWidget_SetResizeEndChild_Call) Run(run func(resize bool)) MockPanedWidget_SetResizeEndChild_Call {
	1269	+	_c.Call.Run(func(args mock.Arguments) {
	1270	+	var arg0 bool
	1271	+	if args[0] != nil {
	1272	+	arg0 = args[0].(bool)
	1273	+	}
	1274	+	run(
	1275	+	arg0,
	1276	+	)
	1277	+	})
	1278	+	return _c
	1279	+	}
	1280	+
	1281	+	func (_c MockPanedWidget_SetResizeEndChild_Call) Return() MockPanedWidget_SetResizeEndChild_Call {
	1282	+	_c.Call.Return()
	1283	+	return _c
	1284	+	}
	1285	+
	1286	+	func (_c MockPanedWidget_SetResizeEndChild_Call) RunAndReturn(run func(resize bool)) MockPanedWidget_SetResizeEndChild_Call {
	1287	+	_c.Run(run)
	1288	+	return _c
	1289	+	}
	1290	+
	1291	+	// SetResizeStartChild provides a mock function for the type MockPanedWidget
	1292	+	func (_mock *MockPanedWidget) SetResizeStartChild(resize bool) {
	1293	+	_mock.Called(resize)
	1294	+	return
	1295	+	}
	1296	+
	1297	+	// MockPanedWidget_SetResizeStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResizeStartChild'
	1298	+	type MockPanedWidget_SetResizeStartChild_Call struct {
	1299	+	*mock.Call
	1300	+	}
	1301	+
	1302	+	// SetResizeStartChild is a helper method to define mock.On call
	1303	+	// - resize bool
	1304	+	func (_e MockPanedWidget_Expecter) SetResizeStartChild(resize interface{}) MockPanedWidget_SetResizeStartChild_Call {
	1305	+	return &MockPanedWidget_SetResizeStartChild_Call{Call: _e.mock.On("SetResizeStartChild", resize)}
	1306	+	}
	1307	+
	1308	+	func (_c MockPanedWidget_SetResizeStartChild_Call) Run(run func(resize bool)) MockPanedWidget_SetResizeStartChild_Call {
	1309	+	_c.Call.Run(func(args mock.Arguments) {
	1310	+	var arg0 bool
	1311	+	if args[0] != nil {
	1312	+	arg0 = args[0].(bool)
	1313	+	}
	1314	+	run(
	1315	+	arg0,
	1316	+	)
	1317	+	})
	1318	+	return _c
	1319	+	}
	1320	+
	1321	+	func (_c MockPanedWidget_SetResizeStartChild_Call) Return() MockPanedWidget_SetResizeStartChild_Call {
	1322	+	_c.Call.Return()
	1323	+	return _c
	1324	+	}
	1325	+
	1326	+	func (_c MockPanedWidget_SetResizeStartChild_Call) RunAndReturn(run func(resize bool)) MockPanedWidget_SetResizeStartChild_Call {
	1327	+	_c.Run(run)
	1328	+	return _c
	1329	+	}
	1330	+
	1331	+	// SetShrinkEndChild provides a mock function for the type MockPanedWidget
	1332	+	func (_mock *MockPanedWidget) SetShrinkEndChild(shrink bool) {
	1333	+	_mock.Called(shrink)
	1334	+	return
	1335	+	}
	1336	+
	1337	+	// MockPanedWidget_SetShrinkEndChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkEndChild'
	1338	+	type MockPanedWidget_SetShrinkEndChild_Call struct {
	1339	+	*mock.Call
	1340	+	}
	1341	+
	1342	+	// SetShrinkEndChild is a helper method to define mock.On call
	1343	+	// - shrink bool
	1344	+	func (_e MockPanedWidget_Expecter) SetShrinkEndChild(shrink interface{}) MockPanedWidget_SetShrinkEndChild_Call {
	1345	+	return &MockPanedWidget_SetShrinkEndChild_Call{Call: _e.mock.On("SetShrinkEndChild", shrink)}
	1346	+	}
	1347	+
	1348	+	func (_c MockPanedWidget_SetShrinkEndChild_Call) Run(run func(shrink bool)) MockPanedWidget_SetShrinkEndChild_Call {
	1349	+	_c.Call.Run(func(args mock.Arguments) {
	1350	+	var arg0 bool
	1351	+	if args[0] != nil {
	1352	+	arg0 = args[0].(bool)
	1353	+	}
	1354	+	run(
	1355	+	arg0,
	1356	+	)
	1357	+	})
	1358	+	return _c
	1359	+	}
	1360	+
	1361	+	func (_c MockPanedWidget_SetShrinkEndChild_Call) Return() MockPanedWidget_SetShrinkEndChild_Call {
	1362	+	_c.Call.Return()
	1363	+	return _c
	1364	+	}
	1365	+
	1366	+	func (_c MockPanedWidget_SetShrinkEndChild_Call) RunAndReturn(run func(shrink bool)) MockPanedWidget_SetShrinkEndChild_Call {
	1367	+	_c.Run(run)
	1368	+	return _c
	1369	+	}
	1370	+
	1371	+	// SetShrinkStartChild provides a mock function for the type MockPanedWidget
	1372	+	func (_mock *MockPanedWidget) SetShrinkStartChild(shrink bool) {
	1373	+	_mock.Called(shrink)
	1374	+	return
	1375	+	}
	1376	+
	1377	+	// MockPanedWidget_SetShrinkStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetShrinkStartChild'
	1378	+	type MockPanedWidget_SetShrinkStartChild_Call struct {
	1379	+	*mock.Call
	1380	+	}
	1381	+
	1382	+	// SetShrinkStartChild is a helper method to define mock.On call
	1383	+	// - shrink bool
	1384	+	func (_e MockPanedWidget_Expecter) SetShrinkStartChild(shrink interface{}) MockPanedWidget_SetShrinkStartChild_Call {
	1385	+	return &MockPanedWidget_SetShrinkStartChild_Call{Call: _e.mock.On("SetShrinkStartChild", shrink)}
	1386	+	}
	1387	+
	1388	+	func (_c MockPanedWidget_SetShrinkStartChild_Call) Run(run func(shrink bool)) MockPanedWidget_SetShrinkStartChild_Call {
	1389	+	_c.Call.Run(func(args mock.Arguments) {
	1390	+	var arg0 bool
	1391	+	if args[0] != nil {
	1392	+	arg0 = args[0].(bool)
	1393	+	}
	1394	+	run(
	1395	+	arg0,
	1396	+	)
	1397	+	})
	1398	+	return _c
	1399	+	}
	1400	+
	1401	+	func (_c MockPanedWidget_SetShrinkStartChild_Call) Return() MockPanedWidget_SetShrinkStartChild_Call {
	1402	+	_c.Call.Return()
	1403	+	return _c
	1404	+	}
	1405	+
	1406	+	func (_c MockPanedWidget_SetShrinkStartChild_Call) RunAndReturn(run func(shrink bool)) MockPanedWidget_SetShrinkStartChild_Call {
	1407	+	_c.Run(run)
	1408	+	return _c
	1409	+	}
	1410	+
	1411	+	// SetSizeRequest provides a mock function for the type MockPanedWidget
	1412	+	func (_mock *MockPanedWidget) SetSizeRequest(width int, height int) {
	1413	+	_mock.Called(width, height)
	1414	+	return
	1415	+	}
	1416	+
	1417	+	// MockPanedWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	1418	+	type MockPanedWidget_SetSizeRequest_Call struct {
	1419	+	*mock.Call
	1420	+	}
	1421	+
	1422	+	// SetSizeRequest is a helper method to define mock.On call
	1423	+	// - width int
	1424	+	// - height int
	1425	+	func (_e MockPanedWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockPanedWidget_SetSizeRequest_Call {
	1426	+	return &MockPanedWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	1427	+	}
	1428	+
	1429	+	func (_c MockPanedWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockPanedWidget_SetSizeRequest_Call {
	1430	+	_c.Call.Run(func(args mock.Arguments) {
	1431	+	var arg0 int
	1432	+	if args[0] != nil {
	1433	+	arg0 = args[0].(int)
	1434	+	}
	1435	+	var arg1 int
	1436	+	if args[1] != nil {
	1437	+	arg1 = args[1].(int)
	1438	+	}
	1439	+	run(
	1440	+	arg0,
	1441	+	arg1,
	1442	+	)
	1443	+	})
	1444	+	return _c
	1445	+	}
	1446	+
	1447	+	func (_c MockPanedWidget_SetSizeRequest_Call) Return() MockPanedWidget_SetSizeRequest_Call {
	1448	+	_c.Call.Return()
	1449	+	return _c
	1450	+	}
	1451	+
	1452	+	func (_c MockPanedWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockPanedWidget_SetSizeRequest_Call {
	1453	+	_c.Run(run)
	1454	+	return _c
	1455	+	}
	1456	+
	1457	+	// SetStartChild provides a mock function for the type MockPanedWidget
	1458	+	func (_mock *MockPanedWidget) SetStartChild(child layout.Widget) {
	1459	+	_mock.Called(child)
	1460	+	return
	1461	+	}
	1462	+
	1463	+	// MockPanedWidget_SetStartChild_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStartChild'
	1464	+	type MockPanedWidget_SetStartChild_Call struct {
	1465	+	*mock.Call
	1466	+	}
	1467	+
	1468	+	// SetStartChild is a helper method to define mock.On call
	1469	+	// - child layout.Widget
	1470	+	func (_e MockPanedWidget_Expecter) SetStartChild(child interface{}) MockPanedWidget_SetStartChild_Call {
	1471	+	return &MockPanedWidget_SetStartChild_Call{Call: _e.mock.On("SetStartChild", child)}
	1472	+	}
	1473	+
	1474	+	func (_c MockPanedWidget_SetStartChild_Call) Run(run func(child layout.Widget)) MockPanedWidget_SetStartChild_Call {
	1475	+	_c.Call.Run(func(args mock.Arguments) {
	1476	+	var arg0 layout.Widget
	1477	+	if args[0] != nil {
	1478	+	arg0 = args[0].(layout.Widget)
	1479	+	}
	1480	+	run(
	1481	+	arg0,
	1482	+	)
	1483	+	})
	1484	+	return _c
	1485	+	}
	1486	+
	1487	+	func (_c MockPanedWidget_SetStartChild_Call) Return() MockPanedWidget_SetStartChild_Call {
	1488	+	_c.Call.Return()
	1489	+	return _c
	1490	+	}
	1491	+
	1492	+	func (_c MockPanedWidget_SetStartChild_Call) RunAndReturn(run func(child layout.Widget)) MockPanedWidget_SetStartChild_Call {
	1493	+	_c.Run(run)
	1494	+	return _c
	1495	+	}
	1496	+
	1497	+	// SetValign provides a mock function for the type MockPanedWidget
	1498	+	func (_mock *MockPanedWidget) SetValign(align gtk.Align) {
	1499	+	_mock.Called(align)
	1500	+	return
	1501	+	}
	1502	+
	1503	+	// MockPanedWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	1504	+	type MockPanedWidget_SetValign_Call struct {
	1505	+	*mock.Call
	1506	+	}
	1507	+
	1508	+	// SetValign is a helper method to define mock.On call
	1509	+	// - align gtk.Align
	1510	+	func (_e MockPanedWidget_Expecter) SetValign(align interface{}) MockPanedWidget_SetValign_Call {
	1511	+	return &MockPanedWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	1512	+	}
	1513	+
	1514	+	func (_c MockPanedWidget_SetValign_Call) Run(run func(align gtk.Align)) MockPanedWidget_SetValign_Call {
	1515	+	_c.Call.Run(func(args mock.Arguments) {
	1516	+	var arg0 gtk.Align
	1517	+	if args[0] != nil {
	1518	+	arg0 = args[0].(gtk.Align)
	1519	+	}
	1520	+	run(
	1521	+	arg0,
	1522	+	)
	1523	+	})
	1524	+	return _c
	1525	+	}
	1526	+
	1527	+	func (_c MockPanedWidget_SetValign_Call) Return() MockPanedWidget_SetValign_Call {
	1528	+	_c.Call.Return()
	1529	+	return _c
	1530	+	}
	1531	+
	1532	+	func (_c MockPanedWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockPanedWidget_SetValign_Call {
	1533	+	_c.Run(run)
	1534	+	return _c
	1535	+	}
	1536	+
	1537	+	// SetVexpand provides a mock function for the type MockPanedWidget
	1538	+	func (_mock *MockPanedWidget) SetVexpand(expand bool) {
	1539	+	_mock.Called(expand)
	1540	+	return
	1541	+	}
	1542	+
	1543	+	// MockPanedWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	1544	+	type MockPanedWidget_SetVexpand_Call struct {
	1545	+	*mock.Call
	1546	+	}
	1547	+
	1548	+	// SetVexpand is a helper method to define mock.On call
	1549	+	// - expand bool
	1550	+	func (_e MockPanedWidget_Expecter) SetVexpand(expand interface{}) MockPanedWidget_SetVexpand_Call {
	1551	+	return &MockPanedWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	1552	+	}
	1553	+
	1554	+	func (_c MockPanedWidget_SetVexpand_Call) Run(run func(expand bool)) MockPanedWidget_SetVexpand_Call {
	1555	+	_c.Call.Run(func(args mock.Arguments) {
	1556	+	var arg0 bool
	1557	+	if args[0] != nil {
	1558	+	arg0 = args[0].(bool)
	1559	+	}
	1560	+	run(
	1561	+	arg0,
	1562	+	)
	1563	+	})
	1564	+	return _c
	1565	+	}
	1566	+
	1567	+	func (_c MockPanedWidget_SetVexpand_Call) Return() MockPanedWidget_SetVexpand_Call {
	1568	+	_c.Call.Return()
	1569	+	return _c
	1570	+	}
	1571	+
	1572	+	func (_c MockPanedWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockPanedWidget_SetVexpand_Call {
	1573	+	_c.Run(run)
	1574	+	return _c
	1575	+	}
	1576	+
	1577	+	// SetVisible provides a mock function for the type MockPanedWidget
	1578	+	func (_mock *MockPanedWidget) SetVisible(visible bool) {
	1579	+	_mock.Called(visible)
	1580	+	return
	1581	+	}
	1582	+
	1583	+	// MockPanedWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	1584	+	type MockPanedWidget_SetVisible_Call struct {
	1585	+	*mock.Call
	1586	+	}
	1587	+
	1588	+	// SetVisible is a helper method to define mock.On call
	1589	+	// - visible bool
	1590	+	func (_e MockPanedWidget_Expecter) SetVisible(visible interface{}) MockPanedWidget_SetVisible_Call {
	1591	+	return &MockPanedWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	1592	+	}
	1593	+
	1594	+	func (_c MockPanedWidget_SetVisible_Call) Run(run func(visible bool)) MockPanedWidget_SetVisible_Call {
	1595	+	_c.Call.Run(func(args mock.Arguments) {
	1596	+	var arg0 bool
	1597	+	if args[0] != nil {
	1598	+	arg0 = args[0].(bool)
	1599	+	}
	1600	+	run(
	1601	+	arg0,
	1602	+	)
	1603	+	})
	1604	+	return _c
	1605	+	}
	1606	+
	1607	+	func (_c MockPanedWidget_SetVisible_Call) Return() MockPanedWidget_SetVisible_Call {
	1608	+	_c.Call.Return()
	1609	+	return _c
	1610	+	}
	1611	+
	1612	+	func (_c MockPanedWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockPanedWidget_SetVisible_Call {
	1613	+	_c.Run(run)
	1614	+	return _c
	1615	+	}
	1616	+
	1617	+	// SetWideHandle provides a mock function for the type MockPanedWidget
	1618	+	func (_mock *MockPanedWidget) SetWideHandle(wide bool) {
	1619	+	_mock.Called(wide)
	1620	+	return
	1621	+	}
	1622	+
	1623	+	// MockPanedWidget_SetWideHandle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWideHandle'
	1624	+	type MockPanedWidget_SetWideHandle_Call struct {
	1625	+	*mock.Call
	1626	+	}
	1627	+
	1628	+	// SetWideHandle is a helper method to define mock.On call
	1629	+	// - wide bool
	1630	+	func (_e MockPanedWidget_Expecter) SetWideHandle(wide interface{}) MockPanedWidget_SetWideHandle_Call {
	1631	+	return &MockPanedWidget_SetWideHandle_Call{Call: _e.mock.On("SetWideHandle", wide)}
	1632	+	}
	1633	+
	1634	+	func (_c MockPanedWidget_SetWideHandle_Call) Run(run func(wide bool)) MockPanedWidget_SetWideHandle_Call {
	1635	+	_c.Call.Run(func(args mock.Arguments) {
	1636	+	var arg0 bool
	1637	+	if args[0] != nil {
	1638	+	arg0 = args[0].(bool)
	1639	+	}
	1640	+	run(
	1641	+	arg0,
	1642	+	)
	1643	+	})
	1644	+	return _c
	1645	+	}
	1646	+
	1647	+	func (_c MockPanedWidget_SetWideHandle_Call) Return() MockPanedWidget_SetWideHandle_Call {
	1648	+	_c.Call.Return()
	1649	+	return _c
	1650	+	}
	1651	+
	1652	+	func (_c MockPanedWidget_SetWideHandle_Call) RunAndReturn(run func(wide bool)) MockPanedWidget_SetWideHandle_Call {
	1653	+	_c.Run(run)
	1654	+	return _c
	1655	+	}
	1656	+
	1657	+	// Show provides a mock function for the type MockPanedWidget
	1658	+	func (_mock *MockPanedWidget) Show() {
	1659	+	_mock.Called()
	1660	+	return
	1661	+	}
	1662	+
	1663	+	// MockPanedWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	1664	+	type MockPanedWidget_Show_Call struct {
	1665	+	*mock.Call
	1666	+	}
	1667	+
	1668	+	// Show is a helper method to define mock.On call
	1669	+	func (_e MockPanedWidget_Expecter) Show() MockPanedWidget_Show_Call {
	1670	+	return &MockPanedWidget_Show_Call{Call: _e.mock.On("Show")}
	1671	+	}
	1672	+
	1673	+	func (_c MockPanedWidget_Show_Call) Run(run func()) MockPanedWidget_Show_Call {
	1674	+	_c.Call.Run(func(args mock.Arguments) {
	1675	+	run()
	1676	+	})
	1677	+	return _c
	1678	+	}
	1679	+
	1680	+	func (_c MockPanedWidget_Show_Call) Return() MockPanedWidget_Show_Call {
	1681	+	_c.Call.Return()
	1682	+	return _c
	1683	+	}
	1684	+
	1685	+	func (_c MockPanedWidget_Show_Call) RunAndReturn(run func()) MockPanedWidget_Show_Call {
	1686	+	_c.Run(run)
	1687	+	return _c
	1688	+	}
	1689	+
	1690	+	// Unparent provides a mock function for the type MockPanedWidget
	1691	+	func (_mock *MockPanedWidget) Unparent() {
	1692	+	_mock.Called()
	1693	+	return
	1694	+	}
	1695	+
	1696	+	// MockPanedWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	1697	+	type MockPanedWidget_Unparent_Call struct {
	1698	+	*mock.Call
	1699	+	}
	1700	+
	1701	+	// Unparent is a helper method to define mock.On call
	1702	+	func (_e MockPanedWidget_Expecter) Unparent() MockPanedWidget_Unparent_Call {
	1703	+	return &MockPanedWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	1704	+	}
	1705	+
	1706	+	func (_c MockPanedWidget_Unparent_Call) Run(run func()) MockPanedWidget_Unparent_Call {
	1707	+	_c.Call.Run(func(args mock.Arguments) {
	1708	+	run()
	1709	+	})
	1710	+	return _c
	1711	+	}
	1712	+
	1713	+	func (_c MockPanedWidget_Unparent_Call) Return() MockPanedWidget_Unparent_Call {
	1714	+	_c.Call.Return()
	1715	+	return _c
	1716	+	}
	1717	+
	1718	+	func (_c MockPanedWidget_Unparent_Call) RunAndReturn(run func()) MockPanedWidget_Unparent_Call {
	1719	+	_c.Run(run)
	1720	+	return _c
	1721	+	}

A internal/ui/layout/mocks/mock_widget.go +906 -0

@@ -0,0 +1,906 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockWidget(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockWidget {
	19	+	mock := &MockWidget{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockWidget is an autogenerated mock type for the Widget type
	28	+	type MockWidget struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockWidget_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockWidget) EXPECT() MockWidget_Expecter {
	37	+	return &MockWidget_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// AddCssClass provides a mock function for the type MockWidget
	41	+	func (_mock *MockWidget) AddCssClass(cssClass string) {
	42	+	_mock.Called(cssClass)
	43	+	return
	44	+	}
	45	+
	46	+	// MockWidget_AddCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCssClass'
	47	+	type MockWidget_AddCssClass_Call struct {
	48	+	*mock.Call
	49	+	}
	50	+
	51	+	// AddCssClass is a helper method to define mock.On call
	52	+	// - cssClass string
	53	+	func (_e MockWidget_Expecter) AddCssClass(cssClass interface{}) MockWidget_AddCssClass_Call {
	54	+	return &MockWidget_AddCssClass_Call{Call: _e.mock.On("AddCssClass", cssClass)}
	55	+	}
	56	+
	57	+	func (_c MockWidget_AddCssClass_Call) Run(run func(cssClass string)) MockWidget_AddCssClass_Call {
	58	+	_c.Call.Run(func(args mock.Arguments) {
	59	+	var arg0 string
	60	+	if args[0] != nil {
	61	+	arg0 = args[0].(string)
	62	+	}
	63	+	run(
	64	+	arg0,
	65	+	)
	66	+	})
	67	+	return _c
	68	+	}
	69	+
	70	+	func (_c MockWidget_AddCssClass_Call) Return() MockWidget_AddCssClass_Call {
	71	+	_c.Call.Return()
	72	+	return _c
	73	+	}
	74	+
	75	+	func (_c MockWidget_AddCssClass_Call) RunAndReturn(run func(cssClass string)) MockWidget_AddCssClass_Call {
	76	+	_c.Run(run)
	77	+	return _c
	78	+	}
	79	+
	80	+	// GetHexpand provides a mock function for the type MockWidget
	81	+	func (_mock *MockWidget) GetHexpand() bool {
	82	+	ret := _mock.Called()
	83	+
	84	+	if len(ret) == 0 {
	85	+	panic("no return value specified for GetHexpand")
	86	+	}
	87	+
	88	+	var r0 bool
	89	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	90	+	r0 = returnFunc()
	91	+	} else {
	92	+	r0 = ret.Get(0).(bool)
	93	+	}
	94	+	return r0
	95	+	}
	96	+
	97	+	// MockWidget_GetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHexpand'
	98	+	type MockWidget_GetHexpand_Call struct {
	99	+	*mock.Call
	100	+	}
	101	+
	102	+	// GetHexpand is a helper method to define mock.On call
	103	+	func (_e MockWidget_Expecter) GetHexpand() MockWidget_GetHexpand_Call {
	104	+	return &MockWidget_GetHexpand_Call{Call: _e.mock.On("GetHexpand")}
	105	+	}
	106	+
	107	+	func (_c MockWidget_GetHexpand_Call) Run(run func()) MockWidget_GetHexpand_Call {
	108	+	_c.Call.Run(func(args mock.Arguments) {
	109	+	run()
	110	+	})
	111	+	return _c
	112	+	}
	113	+
	114	+	func (_c MockWidget_GetHexpand_Call) Return(b bool) MockWidget_GetHexpand_Call {
	115	+	_c.Call.Return(b)
	116	+	return _c
	117	+	}
	118	+
	119	+	func (_c MockWidget_GetHexpand_Call) RunAndReturn(run func() bool) MockWidget_GetHexpand_Call {
	120	+	_c.Call.Return(run)
	121	+	return _c
	122	+	}
	123	+
	124	+	// GetParent provides a mock function for the type MockWidget
	125	+	func (_mock *MockWidget) GetParent() layout.Widget {
	126	+	ret := _mock.Called()
	127	+
	128	+	if len(ret) == 0 {
	129	+	panic("no return value specified for GetParent")
	130	+	}
	131	+
	132	+	var r0 layout.Widget
	133	+	if returnFunc, ok := ret.Get(0).(func() layout.Widget); ok {
	134	+	r0 = returnFunc()
	135	+	} else {
	136	+	if ret.Get(0) != nil {
	137	+	r0 = ret.Get(0).(layout.Widget)
	138	+	}
	139	+	}
	140	+	return r0
	141	+	}
	142	+
	143	+	// MockWidget_GetParent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParent'
	144	+	type MockWidget_GetParent_Call struct {
	145	+	*mock.Call
	146	+	}
	147	+
	148	+	// GetParent is a helper method to define mock.On call
	149	+	func (_e MockWidget_Expecter) GetParent() MockWidget_GetParent_Call {
	150	+	return &MockWidget_GetParent_Call{Call: _e.mock.On("GetParent")}
	151	+	}
	152	+
	153	+	func (_c MockWidget_GetParent_Call) Run(run func()) MockWidget_GetParent_Call {
	154	+	_c.Call.Run(func(args mock.Arguments) {
	155	+	run()
	156	+	})
	157	+	return _c
	158	+	}
	159	+
	160	+	func (_c MockWidget_GetParent_Call) Return(widget layout.Widget) MockWidget_GetParent_Call {
	161	+	_c.Call.Return(widget)
	162	+	return _c
	163	+	}
	164	+
	165	+	func (_c MockWidget_GetParent_Call) RunAndReturn(run func() layout.Widget) MockWidget_GetParent_Call {
	166	+	_c.Call.Return(run)
	167	+	return _c
	168	+	}
	169	+
	170	+	// GetVexpand provides a mock function for the type MockWidget
	171	+	func (_mock *MockWidget) GetVexpand() bool {
	172	+	ret := _mock.Called()
	173	+
	174	+	if len(ret) == 0 {
	175	+	panic("no return value specified for GetVexpand")
	176	+	}
	177	+
	178	+	var r0 bool
	179	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	180	+	r0 = returnFunc()
	181	+	} else {
	182	+	r0 = ret.Get(0).(bool)
	183	+	}
	184	+	return r0
	185	+	}
	186	+
	187	+	// MockWidget_GetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetVexpand'
	188	+	type MockWidget_GetVexpand_Call struct {
	189	+	*mock.Call
	190	+	}
	191	+
	192	+	// GetVexpand is a helper method to define mock.On call
	193	+	func (_e MockWidget_Expecter) GetVexpand() MockWidget_GetVexpand_Call {
	194	+	return &MockWidget_GetVexpand_Call{Call: _e.mock.On("GetVexpand")}
	195	+	}
	196	+
	197	+	func (_c MockWidget_GetVexpand_Call) Run(run func()) MockWidget_GetVexpand_Call {
	198	+	_c.Call.Run(func(args mock.Arguments) {
	199	+	run()
	200	+	})
	201	+	return _c
	202	+	}
	203	+
	204	+	func (_c MockWidget_GetVexpand_Call) Return(b bool) MockWidget_GetVexpand_Call {
	205	+	_c.Call.Return(b)
	206	+	return _c
	207	+	}
	208	+
	209	+	func (_c MockWidget_GetVexpand_Call) RunAndReturn(run func() bool) MockWidget_GetVexpand_Call {
	210	+	_c.Call.Return(run)
	211	+	return _c
	212	+	}
	213	+
	214	+	// GrabFocus provides a mock function for the type MockWidget
	215	+	func (_mock *MockWidget) GrabFocus() bool {
	216	+	ret := _mock.Called()
	217	+
	218	+	if len(ret) == 0 {
	219	+	panic("no return value specified for GrabFocus")
	220	+	}
	221	+
	222	+	var r0 bool
	223	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	224	+	r0 = returnFunc()
	225	+	} else {
	226	+	r0 = ret.Get(0).(bool)
	227	+	}
	228	+	return r0
	229	+	}
	230	+
	231	+	// MockWidget_GrabFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GrabFocus'
	232	+	type MockWidget_GrabFocus_Call struct {
	233	+	*mock.Call
	234	+	}
	235	+
	236	+	// GrabFocus is a helper method to define mock.On call
	237	+	func (_e MockWidget_Expecter) GrabFocus() MockWidget_GrabFocus_Call {
	238	+	return &MockWidget_GrabFocus_Call{Call: _e.mock.On("GrabFocus")}
	239	+	}
	240	+
	241	+	func (_c MockWidget_GrabFocus_Call) Run(run func()) MockWidget_GrabFocus_Call {
	242	+	_c.Call.Run(func(args mock.Arguments) {
	243	+	run()
	244	+	})
	245	+	return _c
	246	+	}
	247	+
	248	+	func (_c MockWidget_GrabFocus_Call) Return(b bool) MockWidget_GrabFocus_Call {
	249	+	_c.Call.Return(b)
	250	+	return _c
	251	+	}
	252	+
	253	+	func (_c MockWidget_GrabFocus_Call) RunAndReturn(run func() bool) MockWidget_GrabFocus_Call {
	254	+	_c.Call.Return(run)
	255	+	return _c
	256	+	}
	257	+
	258	+	// GtkWidget provides a mock function for the type MockWidget
	259	+	func (_mock MockWidget) GtkWidget() gtk.Widget {
	260	+	ret := _mock.Called()
	261	+
	262	+	if len(ret) == 0 {
	263	+	panic("no return value specified for GtkWidget")
	264	+	}
	265	+
	266	+	var r0 *gtk.Widget
	267	+	if returnFunc, ok := ret.Get(0).(func() *gtk.Widget); ok {
	268	+	r0 = returnFunc()
	269	+	} else {
	270	+	if ret.Get(0) != nil {
	271	+	r0 = ret.Get(0).(*gtk.Widget)
	272	+	}
	273	+	}
	274	+	return r0
	275	+	}
	276	+
	277	+	// MockWidget_GtkWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GtkWidget'
	278	+	type MockWidget_GtkWidget_Call struct {
	279	+	*mock.Call
	280	+	}
	281	+
	282	+	// GtkWidget is a helper method to define mock.On call
	283	+	func (_e MockWidget_Expecter) GtkWidget() MockWidget_GtkWidget_Call {
	284	+	return &MockWidget_GtkWidget_Call{Call: _e.mock.On("GtkWidget")}
	285	+	}
	286	+
	287	+	func (_c MockWidget_GtkWidget_Call) Run(run func()) MockWidget_GtkWidget_Call {
	288	+	_c.Call.Run(func(args mock.Arguments) {
	289	+	run()
	290	+	})
	291	+	return _c
	292	+	}
	293	+
	294	+	func (_c MockWidget_GtkWidget_Call) Return(widget gtk.Widget) *MockWidget_GtkWidget_Call {
	295	+	_c.Call.Return(widget)
	296	+	return _c
	297	+	}
	298	+
	299	+	func (_c MockWidget_GtkWidget_Call) RunAndReturn(run func() gtk.Widget) *MockWidget_GtkWidget_Call {
	300	+	_c.Call.Return(run)
	301	+	return _c
	302	+	}
	303	+
	304	+	// HasCssClass provides a mock function for the type MockWidget
	305	+	func (_mock *MockWidget) HasCssClass(cssClass string) bool {
	306	+	ret := _mock.Called(cssClass)
	307	+
	308	+	if len(ret) == 0 {
	309	+	panic("no return value specified for HasCssClass")
	310	+	}
	311	+
	312	+	var r0 bool
	313	+	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
	314	+	r0 = returnFunc(cssClass)
	315	+	} else {
	316	+	r0 = ret.Get(0).(bool)
	317	+	}
	318	+	return r0
	319	+	}
	320	+
	321	+	// MockWidget_HasCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasCssClass'
	322	+	type MockWidget_HasCssClass_Call struct {
	323	+	*mock.Call
	324	+	}
	325	+
	326	+	// HasCssClass is a helper method to define mock.On call
	327	+	// - cssClass string
	328	+	func (_e MockWidget_Expecter) HasCssClass(cssClass interface{}) MockWidget_HasCssClass_Call {
	329	+	return &MockWidget_HasCssClass_Call{Call: _e.mock.On("HasCssClass", cssClass)}
	330	+	}
	331	+
	332	+	func (_c MockWidget_HasCssClass_Call) Run(run func(cssClass string)) MockWidget_HasCssClass_Call {
	333	+	_c.Call.Run(func(args mock.Arguments) {
	334	+	var arg0 string
	335	+	if args[0] != nil {
	336	+	arg0 = args[0].(string)
	337	+	}
	338	+	run(
	339	+	arg0,
	340	+	)
	341	+	})
	342	+	return _c
	343	+	}
	344	+
	345	+	func (_c MockWidget_HasCssClass_Call) Return(b bool) MockWidget_HasCssClass_Call {
	346	+	_c.Call.Return(b)
	347	+	return _c
	348	+	}
	349	+
	350	+	func (_c MockWidget_HasCssClass_Call) RunAndReturn(run func(cssClass string) bool) MockWidget_HasCssClass_Call {
	351	+	_c.Call.Return(run)
	352	+	return _c
	353	+	}
	354	+
	355	+	// HasFocus provides a mock function for the type MockWidget
	356	+	func (_mock *MockWidget) HasFocus() bool {
	357	+	ret := _mock.Called()
	358	+
	359	+	if len(ret) == 0 {
	360	+	panic("no return value specified for HasFocus")
	361	+	}
	362	+
	363	+	var r0 bool
	364	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	365	+	r0 = returnFunc()
	366	+	} else {
	367	+	r0 = ret.Get(0).(bool)
	368	+	}
	369	+	return r0
	370	+	}
	371	+
	372	+	// MockWidget_HasFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasFocus'
	373	+	type MockWidget_HasFocus_Call struct {
	374	+	*mock.Call
	375	+	}
	376	+
	377	+	// HasFocus is a helper method to define mock.On call
	378	+	func (_e MockWidget_Expecter) HasFocus() MockWidget_HasFocus_Call {
	379	+	return &MockWidget_HasFocus_Call{Call: _e.mock.On("HasFocus")}
	380	+	}
	381	+
	382	+	func (_c MockWidget_HasFocus_Call) Run(run func()) MockWidget_HasFocus_Call {
	383	+	_c.Call.Run(func(args mock.Arguments) {
	384	+	run()
	385	+	})
	386	+	return _c
	387	+	}
	388	+
	389	+	func (_c MockWidget_HasFocus_Call) Return(b bool) MockWidget_HasFocus_Call {
	390	+	_c.Call.Return(b)
	391	+	return _c
	392	+	}
	393	+
	394	+	func (_c MockWidget_HasFocus_Call) RunAndReturn(run func() bool) MockWidget_HasFocus_Call {
	395	+	_c.Call.Return(run)
	396	+	return _c
	397	+	}
	398	+
	399	+	// Hide provides a mock function for the type MockWidget
	400	+	func (_mock *MockWidget) Hide() {
	401	+	_mock.Called()
	402	+	return
	403	+	}
	404	+
	405	+	// MockWidget_Hide_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Hide'
	406	+	type MockWidget_Hide_Call struct {
	407	+	*mock.Call
	408	+	}
	409	+
	410	+	// Hide is a helper method to define mock.On call
	411	+	func (_e MockWidget_Expecter) Hide() MockWidget_Hide_Call {
	412	+	return &MockWidget_Hide_Call{Call: _e.mock.On("Hide")}
	413	+	}
	414	+
	415	+	func (_c MockWidget_Hide_Call) Run(run func()) MockWidget_Hide_Call {
	416	+	_c.Call.Run(func(args mock.Arguments) {
	417	+	run()
	418	+	})
	419	+	return _c
	420	+	}
	421	+
	422	+	func (_c MockWidget_Hide_Call) Return() MockWidget_Hide_Call {
	423	+	_c.Call.Return()
	424	+	return _c
	425	+	}
	426	+
	427	+	func (_c MockWidget_Hide_Call) RunAndReturn(run func()) MockWidget_Hide_Call {
	428	+	_c.Run(run)
	429	+	return _c
	430	+	}
	431	+
	432	+	// IsVisible provides a mock function for the type MockWidget
	433	+	func (_mock *MockWidget) IsVisible() bool {
	434	+	ret := _mock.Called()
	435	+
	436	+	if len(ret) == 0 {
	437	+	panic("no return value specified for IsVisible")
	438	+	}
	439	+
	440	+	var r0 bool
	441	+	if returnFunc, ok := ret.Get(0).(func() bool); ok {
	442	+	r0 = returnFunc()
	443	+	} else {
	444	+	r0 = ret.Get(0).(bool)
	445	+	}
	446	+	return r0
	447	+	}
	448	+
	449	+	// MockWidget_IsVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsVisible'
	450	+	type MockWidget_IsVisible_Call struct {
	451	+	*mock.Call
	452	+	}
	453	+
	454	+	// IsVisible is a helper method to define mock.On call
	455	+	func (_e MockWidget_Expecter) IsVisible() MockWidget_IsVisible_Call {
	456	+	return &MockWidget_IsVisible_Call{Call: _e.mock.On("IsVisible")}
	457	+	}
	458	+
	459	+	func (_c MockWidget_IsVisible_Call) Run(run func()) MockWidget_IsVisible_Call {
	460	+	_c.Call.Run(func(args mock.Arguments) {
	461	+	run()
	462	+	})
	463	+	return _c
	464	+	}
	465	+
	466	+	func (_c MockWidget_IsVisible_Call) Return(b bool) MockWidget_IsVisible_Call {
	467	+	_c.Call.Return(b)
	468	+	return _c
	469	+	}
	470	+
	471	+	func (_c MockWidget_IsVisible_Call) RunAndReturn(run func() bool) MockWidget_IsVisible_Call {
	472	+	_c.Call.Return(run)
	473	+	return _c
	474	+	}
	475	+
	476	+	// RemoveCssClass provides a mock function for the type MockWidget
	477	+	func (_mock *MockWidget) RemoveCssClass(cssClass string) {
	478	+	_mock.Called(cssClass)
	479	+	return
	480	+	}
	481	+
	482	+	// MockWidget_RemoveCssClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveCssClass'
	483	+	type MockWidget_RemoveCssClass_Call struct {
	484	+	*mock.Call
	485	+	}
	486	+
	487	+	// RemoveCssClass is a helper method to define mock.On call
	488	+	// - cssClass string
	489	+	func (_e MockWidget_Expecter) RemoveCssClass(cssClass interface{}) MockWidget_RemoveCssClass_Call {
	490	+	return &MockWidget_RemoveCssClass_Call{Call: _e.mock.On("RemoveCssClass", cssClass)}
	491	+	}
	492	+
	493	+	func (_c MockWidget_RemoveCssClass_Call) Run(run func(cssClass string)) MockWidget_RemoveCssClass_Call {
	494	+	_c.Call.Run(func(args mock.Arguments) {
	495	+	var arg0 string
	496	+	if args[0] != nil {
	497	+	arg0 = args[0].(string)
	498	+	}
	499	+	run(
	500	+	arg0,
	501	+	)
	502	+	})
	503	+	return _c
	504	+	}
	505	+
	506	+	func (_c MockWidget_RemoveCssClass_Call) Return() MockWidget_RemoveCssClass_Call {
	507	+	_c.Call.Return()
	508	+	return _c
	509	+	}
	510	+
	511	+	func (_c MockWidget_RemoveCssClass_Call) RunAndReturn(run func(cssClass string)) MockWidget_RemoveCssClass_Call {
	512	+	_c.Run(run)
	513	+	return _c
	514	+	}
	515	+
	516	+	// SetCanFocus provides a mock function for the type MockWidget
	517	+	func (_mock *MockWidget) SetCanFocus(canFocus bool) {
	518	+	_mock.Called(canFocus)
	519	+	return
	520	+	}
	521	+
	522	+	// MockWidget_SetCanFocus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCanFocus'
	523	+	type MockWidget_SetCanFocus_Call struct {
	524	+	*mock.Call
	525	+	}
	526	+
	527	+	// SetCanFocus is a helper method to define mock.On call
	528	+	// - canFocus bool
	529	+	func (_e MockWidget_Expecter) SetCanFocus(canFocus interface{}) MockWidget_SetCanFocus_Call {
	530	+	return &MockWidget_SetCanFocus_Call{Call: _e.mock.On("SetCanFocus", canFocus)}
	531	+	}
	532	+
	533	+	func (_c MockWidget_SetCanFocus_Call) Run(run func(canFocus bool)) MockWidget_SetCanFocus_Call {
	534	+	_c.Call.Run(func(args mock.Arguments) {
	535	+	var arg0 bool
	536	+	if args[0] != nil {
	537	+	arg0 = args[0].(bool)
	538	+	}
	539	+	run(
	540	+	arg0,
	541	+	)
	542	+	})
	543	+	return _c
	544	+	}
	545	+
	546	+	func (_c MockWidget_SetCanFocus_Call) Return() MockWidget_SetCanFocus_Call {
	547	+	_c.Call.Return()
	548	+	return _c
	549	+	}
	550	+
	551	+	func (_c MockWidget_SetCanFocus_Call) RunAndReturn(run func(canFocus bool)) MockWidget_SetCanFocus_Call {
	552	+	_c.Run(run)
	553	+	return _c
	554	+	}
	555	+
	556	+	// SetFocusOnClick provides a mock function for the type MockWidget
	557	+	func (_mock *MockWidget) SetFocusOnClick(focusOnClick bool) {
	558	+	_mock.Called(focusOnClick)
	559	+	return
	560	+	}
	561	+
	562	+	// MockWidget_SetFocusOnClick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFocusOnClick'
	563	+	type MockWidget_SetFocusOnClick_Call struct {
	564	+	*mock.Call
	565	+	}
	566	+
	567	+	// SetFocusOnClick is a helper method to define mock.On call
	568	+	// - focusOnClick bool
	569	+	func (_e MockWidget_Expecter) SetFocusOnClick(focusOnClick interface{}) MockWidget_SetFocusOnClick_Call {
	570	+	return &MockWidget_SetFocusOnClick_Call{Call: _e.mock.On("SetFocusOnClick", focusOnClick)}
	571	+	}
	572	+
	573	+	func (_c MockWidget_SetFocusOnClick_Call) Run(run func(focusOnClick bool)) MockWidget_SetFocusOnClick_Call {
	574	+	_c.Call.Run(func(args mock.Arguments) {
	575	+	var arg0 bool
	576	+	if args[0] != nil {
	577	+	arg0 = args[0].(bool)
	578	+	}
	579	+	run(
	580	+	arg0,
	581	+	)
	582	+	})
	583	+	return _c
	584	+	}
	585	+
	586	+	func (_c MockWidget_SetFocusOnClick_Call) Return() MockWidget_SetFocusOnClick_Call {
	587	+	_c.Call.Return()
	588	+	return _c
	589	+	}
	590	+
	591	+	func (_c MockWidget_SetFocusOnClick_Call) RunAndReturn(run func(focusOnClick bool)) MockWidget_SetFocusOnClick_Call {
	592	+	_c.Run(run)
	593	+	return _c
	594	+	}
	595	+
	596	+	// SetHalign provides a mock function for the type MockWidget
	597	+	func (_mock *MockWidget) SetHalign(align gtk.Align) {
	598	+	_mock.Called(align)
	599	+	return
	600	+	}
	601	+
	602	+	// MockWidget_SetHalign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHalign'
	603	+	type MockWidget_SetHalign_Call struct {
	604	+	*mock.Call
	605	+	}
	606	+
	607	+	// SetHalign is a helper method to define mock.On call
	608	+	// - align gtk.Align
	609	+	func (_e MockWidget_Expecter) SetHalign(align interface{}) MockWidget_SetHalign_Call {
	610	+	return &MockWidget_SetHalign_Call{Call: _e.mock.On("SetHalign", align)}
	611	+	}
	612	+
	613	+	func (_c MockWidget_SetHalign_Call) Run(run func(align gtk.Align)) MockWidget_SetHalign_Call {
	614	+	_c.Call.Run(func(args mock.Arguments) {
	615	+	var arg0 gtk.Align
	616	+	if args[0] != nil {
	617	+	arg0 = args[0].(gtk.Align)
	618	+	}
	619	+	run(
	620	+	arg0,
	621	+	)
	622	+	})
	623	+	return _c
	624	+	}
	625	+
	626	+	func (_c MockWidget_SetHalign_Call) Return() MockWidget_SetHalign_Call {
	627	+	_c.Call.Return()
	628	+	return _c
	629	+	}
	630	+
	631	+	func (_c MockWidget_SetHalign_Call) RunAndReturn(run func(align gtk.Align)) MockWidget_SetHalign_Call {
	632	+	_c.Run(run)
	633	+	return _c
	634	+	}
	635	+
	636	+	// SetHexpand provides a mock function for the type MockWidget
	637	+	func (_mock *MockWidget) SetHexpand(expand bool) {
	638	+	_mock.Called(expand)
	639	+	return
	640	+	}
	641	+
	642	+	// MockWidget_SetHexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHexpand'
	643	+	type MockWidget_SetHexpand_Call struct {
	644	+	*mock.Call
	645	+	}
	646	+
	647	+	// SetHexpand is a helper method to define mock.On call
	648	+	// - expand bool
	649	+	func (_e MockWidget_Expecter) SetHexpand(expand interface{}) MockWidget_SetHexpand_Call {
	650	+	return &MockWidget_SetHexpand_Call{Call: _e.mock.On("SetHexpand", expand)}
	651	+	}
	652	+
	653	+	func (_c MockWidget_SetHexpand_Call) Run(run func(expand bool)) MockWidget_SetHexpand_Call {
	654	+	_c.Call.Run(func(args mock.Arguments) {
	655	+	var arg0 bool
	656	+	if args[0] != nil {
	657	+	arg0 = args[0].(bool)
	658	+	}
	659	+	run(
	660	+	arg0,
	661	+	)
	662	+	})
	663	+	return _c
	664	+	}
	665	+
	666	+	func (_c MockWidget_SetHexpand_Call) Return() MockWidget_SetHexpand_Call {
	667	+	_c.Call.Return()
	668	+	return _c
	669	+	}
	670	+
	671	+	func (_c MockWidget_SetHexpand_Call) RunAndReturn(run func(expand bool)) MockWidget_SetHexpand_Call {
	672	+	_c.Run(run)
	673	+	return _c
	674	+	}
	675	+
	676	+	// SetSizeRequest provides a mock function for the type MockWidget
	677	+	func (_mock *MockWidget) SetSizeRequest(width int, height int) {
	678	+	_mock.Called(width, height)
	679	+	return
	680	+	}
	681	+
	682	+	// MockWidget_SetSizeRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSizeRequest'
	683	+	type MockWidget_SetSizeRequest_Call struct {
	684	+	*mock.Call
	685	+	}
	686	+
	687	+	// SetSizeRequest is a helper method to define mock.On call
	688	+	// - width int
	689	+	// - height int
	690	+	func (_e MockWidget_Expecter) SetSizeRequest(width interface{}, height interface{}) MockWidget_SetSizeRequest_Call {
	691	+	return &MockWidget_SetSizeRequest_Call{Call: _e.mock.On("SetSizeRequest", width, height)}
	692	+	}
	693	+
	694	+	func (_c MockWidget_SetSizeRequest_Call) Run(run func(width int, height int)) MockWidget_SetSizeRequest_Call {
	695	+	_c.Call.Run(func(args mock.Arguments) {
	696	+	var arg0 int
	697	+	if args[0] != nil {
	698	+	arg0 = args[0].(int)
	699	+	}
	700	+	var arg1 int
	701	+	if args[1] != nil {
	702	+	arg1 = args[1].(int)
	703	+	}
	704	+	run(
	705	+	arg0,
	706	+	arg1,
	707	+	)
	708	+	})
	709	+	return _c
	710	+	}
	711	+
	712	+	func (_c MockWidget_SetSizeRequest_Call) Return() MockWidget_SetSizeRequest_Call {
	713	+	_c.Call.Return()
	714	+	return _c
	715	+	}
	716	+
	717	+	func (_c MockWidget_SetSizeRequest_Call) RunAndReturn(run func(width int, height int)) MockWidget_SetSizeRequest_Call {
	718	+	_c.Run(run)
	719	+	return _c
	720	+	}
	721	+
	722	+	// SetValign provides a mock function for the type MockWidget
	723	+	func (_mock *MockWidget) SetValign(align gtk.Align) {
	724	+	_mock.Called(align)
	725	+	return
	726	+	}
	727	+
	728	+	// MockWidget_SetValign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValign'
	729	+	type MockWidget_SetValign_Call struct {
	730	+	*mock.Call
	731	+	}
	732	+
	733	+	// SetValign is a helper method to define mock.On call
	734	+	// - align gtk.Align
	735	+	func (_e MockWidget_Expecter) SetValign(align interface{}) MockWidget_SetValign_Call {
	736	+	return &MockWidget_SetValign_Call{Call: _e.mock.On("SetValign", align)}
	737	+	}
	738	+
	739	+	func (_c MockWidget_SetValign_Call) Run(run func(align gtk.Align)) MockWidget_SetValign_Call {
	740	+	_c.Call.Run(func(args mock.Arguments) {
	741	+	var arg0 gtk.Align
	742	+	if args[0] != nil {
	743	+	arg0 = args[0].(gtk.Align)
	744	+	}
	745	+	run(
	746	+	arg0,
	747	+	)
	748	+	})
	749	+	return _c
	750	+	}
	751	+
	752	+	func (_c MockWidget_SetValign_Call) Return() MockWidget_SetValign_Call {
	753	+	_c.Call.Return()
	754	+	return _c
	755	+	}
	756	+
	757	+	func (_c MockWidget_SetValign_Call) RunAndReturn(run func(align gtk.Align)) MockWidget_SetValign_Call {
	758	+	_c.Run(run)
	759	+	return _c
	760	+	}
	761	+
	762	+	// SetVexpand provides a mock function for the type MockWidget
	763	+	func (_mock *MockWidget) SetVexpand(expand bool) {
	764	+	_mock.Called(expand)
	765	+	return
	766	+	}
	767	+
	768	+	// MockWidget_SetVexpand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVexpand'
	769	+	type MockWidget_SetVexpand_Call struct {
	770	+	*mock.Call
	771	+	}
	772	+
	773	+	// SetVexpand is a helper method to define mock.On call
	774	+	// - expand bool
	775	+	func (_e MockWidget_Expecter) SetVexpand(expand interface{}) MockWidget_SetVexpand_Call {
	776	+	return &MockWidget_SetVexpand_Call{Call: _e.mock.On("SetVexpand", expand)}
	777	+	}
	778	+
	779	+	func (_c MockWidget_SetVexpand_Call) Run(run func(expand bool)) MockWidget_SetVexpand_Call {
	780	+	_c.Call.Run(func(args mock.Arguments) {
	781	+	var arg0 bool
	782	+	if args[0] != nil {
	783	+	arg0 = args[0].(bool)
	784	+	}
	785	+	run(
	786	+	arg0,
	787	+	)
	788	+	})
	789	+	return _c
	790	+	}
	791	+
	792	+	func (_c MockWidget_SetVexpand_Call) Return() MockWidget_SetVexpand_Call {
	793	+	_c.Call.Return()
	794	+	return _c
	795	+	}
	796	+
	797	+	func (_c MockWidget_SetVexpand_Call) RunAndReturn(run func(expand bool)) MockWidget_SetVexpand_Call {
	798	+	_c.Run(run)
	799	+	return _c
	800	+	}
	801	+
	802	+	// SetVisible provides a mock function for the type MockWidget
	803	+	func (_mock *MockWidget) SetVisible(visible bool) {
	804	+	_mock.Called(visible)
	805	+	return
	806	+	}
	807	+
	808	+	// MockWidget_SetVisible_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVisible'
	809	+	type MockWidget_SetVisible_Call struct {
	810	+	*mock.Call
	811	+	}
	812	+
	813	+	// SetVisible is a helper method to define mock.On call
	814	+	// - visible bool
	815	+	func (_e MockWidget_Expecter) SetVisible(visible interface{}) MockWidget_SetVisible_Call {
	816	+	return &MockWidget_SetVisible_Call{Call: _e.mock.On("SetVisible", visible)}
	817	+	}
	818	+
	819	+	func (_c MockWidget_SetVisible_Call) Run(run func(visible bool)) MockWidget_SetVisible_Call {
	820	+	_c.Call.Run(func(args mock.Arguments) {
	821	+	var arg0 bool
	822	+	if args[0] != nil {
	823	+	arg0 = args[0].(bool)
	824	+	}
	825	+	run(
	826	+	arg0,
	827	+	)
	828	+	})
	829	+	return _c
	830	+	}
	831	+
	832	+	func (_c MockWidget_SetVisible_Call) Return() MockWidget_SetVisible_Call {
	833	+	_c.Call.Return()
	834	+	return _c
	835	+	}
	836	+
	837	+	func (_c MockWidget_SetVisible_Call) RunAndReturn(run func(visible bool)) MockWidget_SetVisible_Call {
	838	+	_c.Run(run)
	839	+	return _c
	840	+	}
	841	+
	842	+	// Show provides a mock function for the type MockWidget
	843	+	func (_mock *MockWidget) Show() {
	844	+	_mock.Called()
	845	+	return
	846	+	}
	847	+
	848	+	// MockWidget_Show_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Show'
	849	+	type MockWidget_Show_Call struct {
	850	+	*mock.Call
	851	+	}
	852	+
	853	+	// Show is a helper method to define mock.On call
	854	+	func (_e MockWidget_Expecter) Show() MockWidget_Show_Call {
	855	+	return &MockWidget_Show_Call{Call: _e.mock.On("Show")}
	856	+	}
	857	+
	858	+	func (_c MockWidget_Show_Call) Run(run func()) MockWidget_Show_Call {
	859	+	_c.Call.Run(func(args mock.Arguments) {
	860	+	run()
	861	+	})
	862	+	return _c
	863	+	}
	864	+
	865	+	func (_c MockWidget_Show_Call) Return() MockWidget_Show_Call {
	866	+	_c.Call.Return()
	867	+	return _c
	868	+	}
	869	+
	870	+	func (_c MockWidget_Show_Call) RunAndReturn(run func()) MockWidget_Show_Call {
	871	+	_c.Run(run)
	872	+	return _c
	873	+	}
	874	+
	875	+	// Unparent provides a mock function for the type MockWidget
	876	+	func (_mock *MockWidget) Unparent() {
	877	+	_mock.Called()
	878	+	return
	879	+	}
	880	+
	881	+	// MockWidget_Unparent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unparent'
	882	+	type MockWidget_Unparent_Call struct {
	883	+	*mock.Call
	884	+	}
	885	+
	886	+	// Unparent is a helper method to define mock.On call
	887	+	func (_e MockWidget_Expecter) Unparent() MockWidget_Unparent_Call {
	888	+	return &MockWidget_Unparent_Call{Call: _e.mock.On("Unparent")}
	889	+	}
	890	+
	891	+	func (_c MockWidget_Unparent_Call) Run(run func()) MockWidget_Unparent_Call {
	892	+	_c.Call.Run(func(args mock.Arguments) {
	893	+	run()
	894	+	})
	895	+	return _c
	896	+	}
	897	+
	898	+	func (_c MockWidget_Unparent_Call) Return() MockWidget_Unparent_Call {
	899	+	_c.Call.Return()
	900	+	return _c
	901	+	}
	902	+
	903	+	func (_c MockWidget_Unparent_Call) RunAndReturn(run func()) MockWidget_Unparent_Call {
	904	+	_c.Run(run)
	905	+	return _c
	906	+	}

A internal/ui/layout/mocks/mock_widget_factory.go +394 -0

@@ -0,0 +1,394 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"github.com/bnema/dumber/internal/ui/layout"
	9	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	10	+	mock "github.com/stretchr/testify/mock"
	11	+	)
	12	+
	13	+	// 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.
	14	+	// The first argument is typically a *testing.T value.
	15	+	func NewMockWidgetFactory(t interface {
	16	+	mock.TestingT
	17	+	Cleanup(func())
	18	+	}) *MockWidgetFactory {
	19	+	mock := &MockWidgetFactory{}
	20	+	mock.Mock.Test(t)
	21	+
	22	+	t.Cleanup(func() { mock.AssertExpectations(t) })
	23	+
	24	+	return mock
	25	+	}
	26	+
	27	+	// MockWidgetFactory is an autogenerated mock type for the WidgetFactory type
	28	+	type MockWidgetFactory struct {
	29	+	mock.Mock
	30	+	}
	31	+
	32	+	type MockWidgetFactory_Expecter struct {
	33	+	mock *mock.Mock
	34	+	}
	35	+
	36	+	func (_m MockWidgetFactory) EXPECT() MockWidgetFactory_Expecter {
	37	+	return &MockWidgetFactory_Expecter{mock: &_m.Mock}
	38	+	}
	39	+
	40	+	// NewBox provides a mock function for the type MockWidgetFactory
	41	+	func (_mock *MockWidgetFactory) NewBox(orientation layout.Orientation, spacing int) layout.BoxWidget {
	42	+	ret := _mock.Called(orientation, spacing)
	43	+
	44	+	if len(ret) == 0 {
	45	+	panic("no return value specified for NewBox")
	46	+	}
	47	+
	48	+	var r0 layout.BoxWidget
	49	+	if returnFunc, ok := ret.Get(0).(func(layout.Orientation, int) layout.BoxWidget); ok {
	50	+	r0 = returnFunc(orientation, spacing)
	51	+	} else {
	52	+	if ret.Get(0) != nil {
	53	+	r0 = ret.Get(0).(layout.BoxWidget)
	54	+	}
	55	+	}
	56	+	return r0
	57	+	}
	58	+
	59	+	// MockWidgetFactory_NewBox_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewBox'
	60	+	type MockWidgetFactory_NewBox_Call struct {
	61	+	*mock.Call
	62	+	}
	63	+
	64	+	// NewBox is a helper method to define mock.On call
	65	+	// - orientation layout.Orientation
	66	+	// - spacing int
	67	+	func (_e MockWidgetFactory_Expecter) NewBox(orientation interface{}, spacing interface{}) MockWidgetFactory_NewBox_Call {
	68	+	return &MockWidgetFactory_NewBox_Call{Call: _e.mock.On("NewBox", orientation, spacing)}
	69	+	}
	70	+
	71	+	func (_c MockWidgetFactory_NewBox_Call) Run(run func(orientation layout.Orientation, spacing int)) MockWidgetFactory_NewBox_Call {
	72	+	_c.Call.Run(func(args mock.Arguments) {
	73	+	var arg0 layout.Orientation
	74	+	if args[0] != nil {
	75	+	arg0 = args[0].(layout.Orientation)
	76	+	}
	77	+	var arg1 int
	78	+	if args[1] != nil {
	79	+	arg1 = args[1].(int)
	80	+	}
	81	+	run(
	82	+	arg0,
	83	+	arg1,
	84	+	)
	85	+	})
	86	+	return _c
	87	+	}
	88	+
	89	+	func (_c MockWidgetFactory_NewBox_Call) Return(boxWidget layout.BoxWidget) MockWidgetFactory_NewBox_Call {
	90	+	_c.Call.Return(boxWidget)
	91	+	return _c
	92	+	}
	93	+
	94	+	func (_c MockWidgetFactory_NewBox_Call) RunAndReturn(run func(orientation layout.Orientation, spacing int) layout.BoxWidget) MockWidgetFactory_NewBox_Call {
	95	+	_c.Call.Return(run)
	96	+	return _c
	97	+	}
	98	+
	99	+	// NewButton provides a mock function for the type MockWidgetFactory
	100	+	func (_mock *MockWidgetFactory) NewButton() layout.ButtonWidget {
	101	+	ret := _mock.Called()
	102	+
	103	+	if len(ret) == 0 {
	104	+	panic("no return value specified for NewButton")
	105	+	}
	106	+
	107	+	var r0 layout.ButtonWidget
	108	+	if returnFunc, ok := ret.Get(0).(func() layout.ButtonWidget); ok {
	109	+	r0 = returnFunc()
	110	+	} else {
	111	+	if ret.Get(0) != nil {
	112	+	r0 = ret.Get(0).(layout.ButtonWidget)
	113	+	}
	114	+	}
	115	+	return r0
	116	+	}
	117	+
	118	+	// MockWidgetFactory_NewButton_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewButton'
	119	+	type MockWidgetFactory_NewButton_Call struct {
	120	+	*mock.Call
	121	+	}
	122	+
	123	+	// NewButton is a helper method to define mock.On call
	124	+	func (_e MockWidgetFactory_Expecter) NewButton() MockWidgetFactory_NewButton_Call {
	125	+	return &MockWidgetFactory_NewButton_Call{Call: _e.mock.On("NewButton")}
	126	+	}
	127	+
	128	+	func (_c MockWidgetFactory_NewButton_Call) Run(run func()) MockWidgetFactory_NewButton_Call {
	129	+	_c.Call.Run(func(args mock.Arguments) {
	130	+	run()
	131	+	})
	132	+	return _c
	133	+	}
	134	+
	135	+	func (_c MockWidgetFactory_NewButton_Call) Return(buttonWidget layout.ButtonWidget) MockWidgetFactory_NewButton_Call {
	136	+	_c.Call.Return(buttonWidget)
	137	+	return _c
	138	+	}
	139	+
	140	+	func (_c MockWidgetFactory_NewButton_Call) RunAndReturn(run func() layout.ButtonWidget) MockWidgetFactory_NewButton_Call {
	141	+	_c.Call.Return(run)
	142	+	return _c
	143	+	}
	144	+
	145	+	// NewImage provides a mock function for the type MockWidgetFactory
	146	+	func (_mock *MockWidgetFactory) NewImage() layout.ImageWidget {
	147	+	ret := _mock.Called()
	148	+
	149	+	if len(ret) == 0 {
	150	+	panic("no return value specified for NewImage")
	151	+	}
	152	+
	153	+	var r0 layout.ImageWidget
	154	+	if returnFunc, ok := ret.Get(0).(func() layout.ImageWidget); ok {
	155	+	r0 = returnFunc()
	156	+	} else {
	157	+	if ret.Get(0) != nil {
	158	+	r0 = ret.Get(0).(layout.ImageWidget)
	159	+	}
	160	+	}
	161	+	return r0
	162	+	}
	163	+
	164	+	// MockWidgetFactory_NewImage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewImage'
	165	+	type MockWidgetFactory_NewImage_Call struct {
	166	+	*mock.Call
	167	+	}
	168	+
	169	+	// NewImage is a helper method to define mock.On call
	170	+	func (_e MockWidgetFactory_Expecter) NewImage() MockWidgetFactory_NewImage_Call {
	171	+	return &MockWidgetFactory_NewImage_Call{Call: _e.mock.On("NewImage")}
	172	+	}
	173	+
	174	+	func (_c MockWidgetFactory_NewImage_Call) Run(run func()) MockWidgetFactory_NewImage_Call {
	175	+	_c.Call.Run(func(args mock.Arguments) {
	176	+	run()
	177	+	})
	178	+	return _c
	179	+	}
	180	+
	181	+	func (_c MockWidgetFactory_NewImage_Call) Return(imageWidget layout.ImageWidget) MockWidgetFactory_NewImage_Call {
	182	+	_c.Call.Return(imageWidget)
	183	+	return _c
	184	+	}
	185	+
	186	+	func (_c MockWidgetFactory_NewImage_Call) RunAndReturn(run func() layout.ImageWidget) MockWidgetFactory_NewImage_Call {
	187	+	_c.Call.Return(run)
	188	+	return _c
	189	+	}
	190	+
	191	+	// NewLabel provides a mock function for the type MockWidgetFactory
	192	+	func (_mock *MockWidgetFactory) NewLabel(text string) layout.LabelWidget {
	193	+	ret := _mock.Called(text)
	194	+
	195	+	if len(ret) == 0 {
	196	+	panic("no return value specified for NewLabel")
	197	+	}
	198	+
	199	+	var r0 layout.LabelWidget
	200	+	if returnFunc, ok := ret.Get(0).(func(string) layout.LabelWidget); ok {
	201	+	r0 = returnFunc(text)
	202	+	} else {
	203	+	if ret.Get(0) != nil {
	204	+	r0 = ret.Get(0).(layout.LabelWidget)
	205	+	}
	206	+	}
	207	+	return r0
	208	+	}
	209	+
	210	+	// MockWidgetFactory_NewLabel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewLabel'
	211	+	type MockWidgetFactory_NewLabel_Call struct {
	212	+	*mock.Call
	213	+	}
	214	+
	215	+	// NewLabel is a helper method to define mock.On call
	216	+	// - text string
	217	+	func (_e MockWidgetFactory_Expecter) NewLabel(text interface{}) MockWidgetFactory_NewLabel_Call {
	218	+	return &MockWidgetFactory_NewLabel_Call{Call: _e.mock.On("NewLabel", text)}
	219	+	}
	220	+
	221	+	func (_c MockWidgetFactory_NewLabel_Call) Run(run func(text string)) MockWidgetFactory_NewLabel_Call {
	222	+	_c.Call.Run(func(args mock.Arguments) {
	223	+	var arg0 string
	224	+	if args[0] != nil {
	225	+	arg0 = args[0].(string)
	226	+	}
	227	+	run(
	228	+	arg0,
	229	+	)
	230	+	})
	231	+	return _c
	232	+	}
	233	+
	234	+	func (_c MockWidgetFactory_NewLabel_Call) Return(labelWidget layout.LabelWidget) MockWidgetFactory_NewLabel_Call {
	235	+	_c.Call.Return(labelWidget)
	236	+	return _c
	237	+	}
	238	+
	239	+	func (_c MockWidgetFactory_NewLabel_Call) RunAndReturn(run func(text string) layout.LabelWidget) MockWidgetFactory_NewLabel_Call {
	240	+	_c.Call.Return(run)
	241	+	return _c
	242	+	}
	243	+
	244	+	// NewOverlay provides a mock function for the type MockWidgetFactory
	245	+	func (_mock *MockWidgetFactory) NewOverlay() layout.OverlayWidget {
	246	+	ret := _mock.Called()
	247	+
	248	+	if len(ret) == 0 {
	249	+	panic("no return value specified for NewOverlay")
	250	+	}
	251	+
	252	+	var r0 layout.OverlayWidget
	253	+	if returnFunc, ok := ret.Get(0).(func() layout.OverlayWidget); ok {
	254	+	r0 = returnFunc()
	255	+	} else {
	256	+	if ret.Get(0) != nil {
	257	+	r0 = ret.Get(0).(layout.OverlayWidget)
	258	+	}
	259	+	}
	260	+	return r0
	261	+	}
	262	+
	263	+	// MockWidgetFactory_NewOverlay_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewOverlay'
	264	+	type MockWidgetFactory_NewOverlay_Call struct {
	265	+	*mock.Call
	266	+	}
	267	+
	268	+	// NewOverlay is a helper method to define mock.On call
	269	+	func (_e MockWidgetFactory_Expecter) NewOverlay() MockWidgetFactory_NewOverlay_Call {
	270	+	return &MockWidgetFactory_NewOverlay_Call{Call: _e.mock.On("NewOverlay")}
	271	+	}
	272	+
	273	+	func (_c MockWidgetFactory_NewOverlay_Call) Run(run func()) MockWidgetFactory_NewOverlay_Call {
	274	+	_c.Call.Run(func(args mock.Arguments) {
	275	+	run()
	276	+	})
	277	+	return _c
	278	+	}
	279	+
	280	+	func (_c MockWidgetFactory_NewOverlay_Call) Return(overlayWidget layout.OverlayWidget) MockWidgetFactory_NewOverlay_Call {
	281	+	_c.Call.Return(overlayWidget)
	282	+	return _c
	283	+	}
	284	+
	285	+	func (_c MockWidgetFactory_NewOverlay_Call) RunAndReturn(run func() layout.OverlayWidget) MockWidgetFactory_NewOverlay_Call {
	286	+	_c.Call.Return(run)
	287	+	return _c
	288	+	}
	289	+
	290	+	// NewPaned provides a mock function for the type MockWidgetFactory
	291	+	func (_mock *MockWidgetFactory) NewPaned(orientation layout.Orientation) layout.PanedWidget {
	292	+	ret := _mock.Called(orientation)
	293	+
	294	+	if len(ret) == 0 {
	295	+	panic("no return value specified for NewPaned")
	296	+	}
	297	+
	298	+	var r0 layout.PanedWidget
	299	+	if returnFunc, ok := ret.Get(0).(func(layout.Orientation) layout.PanedWidget); ok {
	300	+	r0 = returnFunc(orientation)
	301	+	} else {
	302	+	if ret.Get(0) != nil {
	303	+	r0 = ret.Get(0).(layout.PanedWidget)
	304	+	}
	305	+	}
	306	+	return r0
	307	+	}
	308	+
	309	+	// MockWidgetFactory_NewPaned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewPaned'
	310	+	type MockWidgetFactory_NewPaned_Call struct {
	311	+	*mock.Call
	312	+	}
	313	+
	314	+	// NewPaned is a helper method to define mock.On call
	315	+	// - orientation layout.Orientation
	316	+	func (_e MockWidgetFactory_Expecter) NewPaned(orientation interface{}) MockWidgetFactory_NewPaned_Call {
	317	+	return &MockWidgetFactory_NewPaned_Call{Call: _e.mock.On("NewPaned", orientation)}
	318	+	}
	319	+
	320	+	func (_c MockWidgetFactory_NewPaned_Call) Run(run func(orientation layout.Orientation)) MockWidgetFactory_NewPaned_Call {
	321	+	_c.Call.Run(func(args mock.Arguments) {
	322	+	var arg0 layout.Orientation
	323	+	if args[0] != nil {
	324	+	arg0 = args[0].(layout.Orientation)
	325	+	}
	326	+	run(
	327	+	arg0,
	328	+	)
	329	+	})
	330	+	return _c
	331	+	}
	332	+
	333	+	func (_c MockWidgetFactory_NewPaned_Call) Return(panedWidget layout.PanedWidget) MockWidgetFactory_NewPaned_Call {
	334	+	_c.Call.Return(panedWidget)
	335	+	return _c
	336	+	}
	337	+
	338	+	func (_c MockWidgetFactory_NewPaned_Call) RunAndReturn(run func(orientation layout.Orientation) layout.PanedWidget) MockWidgetFactory_NewPaned_Call {
	339	+	_c.Call.Return(run)
	340	+	return _c
	341	+	}
	342	+
	343	+	// WrapWidget provides a mock function for the type MockWidgetFactory
	344	+	func (_mock MockWidgetFactory) WrapWidget(w gtk.Widget) layout.Widget {
	345	+	ret := _mock.Called(w)
	346	+
	347	+	if len(ret) == 0 {
	348	+	panic("no return value specified for WrapWidget")
	349	+	}
	350	+
	351	+	var r0 layout.Widget
	352	+	if returnFunc, ok := ret.Get(0).(func(*gtk.Widget) layout.Widget); ok {
	353	+	r0 = returnFunc(w)
	354	+	} else {
	355	+	if ret.Get(0) != nil {
	356	+	r0 = ret.Get(0).(layout.Widget)
	357	+	}
	358	+	}
	359	+	return r0
	360	+	}
	361	+
	362	+	// MockWidgetFactory_WrapWidget_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WrapWidget'
	363	+	type MockWidgetFactory_WrapWidget_Call struct {
	364	+	*mock.Call
	365	+	}
	366	+
	367	+	// WrapWidget is a helper method to define mock.On call
	368	+	// - w *gtk.Widget
	369	+	func (_e MockWidgetFactory_Expecter) WrapWidget(w interface{}) MockWidgetFactory_WrapWidget_Call {
	370	+	return &MockWidgetFactory_WrapWidget_Call{Call: _e.mock.On("WrapWidget", w)}
	371	+	}
	372	+
	373	+	func (_c MockWidgetFactory_WrapWidget_Call) Run(run func(w gtk.Widget)) *MockWidgetFactory_WrapWidget_Call {
	374	+	_c.Call.Run(func(args mock.Arguments) {
	375	+	var arg0 *gtk.Widget
	376	+	if args[0] != nil {
	377	+	arg0 = args[0].(*gtk.Widget)
	378	+	}
	379	+	run(
	380	+	arg0,
	381	+	)
	382	+	})
	383	+	return _c
	384	+	}
	385	+
	386	+	func (_c MockWidgetFactory_WrapWidget_Call) Return(widget layout.Widget) MockWidgetFactory_WrapWidget_Call {
	387	+	_c.Call.Return(widget)
	388	+	return _c
	389	+	}
	390	+
	391	+	func (_c MockWidgetFactory_WrapWidget_Call) RunAndReturn(run func(w gtk.Widget) layout.Widget) *MockWidgetFactory_WrapWidget_Call {
	392	+	_c.Call.Return(run)
	393	+	return _c
	394	+	}

A internal/ui/layout/split.go +191 -0

@@ -0,0 +1,191 @@
	1	+	package layout
	2	+
	3	+	import (
	4	+	"sync"
	5	+	)
	6	+
	7	+	// SplitView wraps a GTK Paned widget for creating split pane layouts.
	8	+	// It manages two child widgets separated by a draggable divider.
	9	+	type SplitView struct {
	10	+	paned PanedWidget
	11	+	orientation Orientation
	12	+	startChild Widget
	13	+	endChild Widget
	14	+	ratio float64 // 0.0-1.0, relative position of divider
	15	+
	16	+	mu sync.RWMutex
	17	+	}
	18	+
	19	+	// NewSplitView creates a new split view with the given orientation and children.
	20	+	// The ratio determines the initial divider position (0.0-1.0).
	21	+	func NewSplitView(factory WidgetFactory, orientation Orientation, startChild, endChild Widget, ratio float64) *SplitView {
	22	+	paned := factory.NewPaned(orientation)
	23	+
	24	+	// Configure resize behavior - both children should resize
	25	+	paned.SetResizeStartChild(true)
	26	+	paned.SetResizeEndChild(true)
	27	+
	28	+	// Prevent children from shrinking below minimum size
	29	+	paned.SetShrinkStartChild(false)
	30	+	paned.SetShrinkEndChild(false)
	31	+
	32	+	sv := &SplitView{
	33	+	paned: paned,
	34	+	orientation: orientation,
	35	+	startChild: startChild,
	36	+	endChild: endChild,
	37	+	ratio: clampRatio(ratio),
	38	+	}
	39	+
	40	+	// Set children
	41	+	if startChild != nil {
	42	+	paned.SetStartChild(startChild)
	43	+	}
	44	+	if endChild != nil {
	45	+	paned.SetEndChild(endChild)
	46	+	}
	47	+
	48	+	// Apply ratio after widget is mapped (when we know the allocated size)
	49	+	paned.ConnectMap(func() {
	50	+	sv.ApplyRatio()
	51	+	})
	52	+
	53	+	return sv
	54	+	}
	55	+
	56	+	// SetRatio updates the divider position.
	57	+	// The ratio is clamped to the range [0.0, 1.0].
	58	+	// Note: This sets the position based on ratio; actual pixel position
	59	+	// depends on the allocated size of the paned widget.
	60	+	func (sv *SplitView) SetRatio(ratio float64) {
	61	+	sv.mu.Lock()
	62	+	defer sv.mu.Unlock()
	63	+
	64	+	sv.ratio = clampRatio(ratio)
	65	+	}
	66	+
	67	+	// GetRatio returns the current ratio setting.
	68	+	func (sv *SplitView) GetRatio() float64 {
	69	+	sv.mu.RLock()
	70	+	defer sv.mu.RUnlock()
	71	+
	72	+	return sv.ratio
	73	+	}
	74	+
	75	+	// ApplyRatio converts the ratio to a pixel position and applies it.
	76	+	// This should be called after the widget has been mapped and has an allocated size.
	77	+	func (sv *SplitView) ApplyRatio() {
	78	+	sv.mu.RLock()
	79	+	ratio := sv.ratio
	80	+	orientation := sv.orientation
	81	+	sv.mu.RUnlock()
	82	+
	83	+	// Get the relevant dimension based on orientation
	84	+	var totalSize int
	85	+	if orientation == OrientationHorizontal {
	86	+	totalSize = sv.paned.GetAllocatedWidth()
	87	+	} else {
	88	+	totalSize = sv.paned.GetAllocatedHeight()
	89	+	}
	90	+
	91	+	if totalSize <= 0 {
	92	+	return // Not yet allocated
	93	+	}
	94	+
	95	+	// Calculate position from ratio
	96	+	position := int(float64(totalSize) * ratio)
	97	+	sv.paned.SetPosition(position)
	98	+	}
	99	+
	100	+	// SetPosition sets the divider position in pixels.
	101	+	func (sv *SplitView) SetPosition(position int) {
	102	+	sv.paned.SetPosition(position)
	103	+	}
	104	+
	105	+	// GetPosition returns the current divider position in pixels.
	106	+	func (sv *SplitView) GetPosition() int {
	107	+	return sv.paned.GetPosition()
	108	+	}
	109	+
	110	+	// SwapStart replaces the start (left/top) child widget.
	111	+	// The old child is unparented before the new child is set.
	112	+	func (sv *SplitView) SwapStart(newWidget Widget) {
	113	+	sv.mu.Lock()
	114	+	defer sv.mu.Unlock()
	115	+
	116	+	// Remove old child from paned
	117	+	if sv.startChild != nil {
	118	+	sv.paned.SetStartChild(nil)
	119	+	}
	120	+
	121	+	sv.startChild = newWidget
	122	+
	123	+	if newWidget != nil {
	124	+	sv.paned.SetStartChild(newWidget)
	125	+	}
	126	+	}
	127	+
	128	+	// SwapEnd replaces the end (right/bottom) child widget.
	129	+	// The old child is unparented before the new child is set.
	130	+	func (sv *SplitView) SwapEnd(newWidget Widget) {
	131	+	sv.mu.Lock()
	132	+	defer sv.mu.Unlock()
	133	+
	134	+	// Remove old child from paned
	135	+	if sv.endChild != nil {
	136	+	sv.paned.SetEndChild(nil)
	137	+	}
	138	+
	139	+	sv.endChild = newWidget
	140	+
	141	+	if newWidget != nil {
	142	+	sv.paned.SetEndChild(newWidget)
	143	+	}
	144	+	}
	145	+
	146	+	// StartChild returns the current start (left/top) child.
	147	+	func (sv *SplitView) StartChild() Widget {
	148	+	sv.mu.RLock()
	149	+	defer sv.mu.RUnlock()
	150	+
	151	+	return sv.startChild
	152	+	}
	153	+
	154	+	// EndChild returns the current end (right/bottom) child.
	155	+	func (sv *SplitView) EndChild() Widget {
	156	+	sv.mu.RLock()
	157	+	defer sv.mu.RUnlock()
	158	+
	159	+	return sv.endChild
	160	+	}
	161	+
	162	+	// Orientation returns the split orientation.
	163	+	func (sv *SplitView) Orientation() Orientation {
	164	+	return sv.orientation
	165	+	}
	166	+
	167	+	// SetWideHandle sets whether the handle has a wide appearance.
	168	+	func (sv *SplitView) SetWideHandle(wide bool) {
	169	+	sv.paned.SetWideHandle(wide)
	170	+	}
	171	+
	172	+	// Widget returns the underlying PanedWidget for embedding in containers.
	173	+	func (sv *SplitView) Widget() Widget {
	174	+	return sv.paned
	175	+	}
	176	+
	177	+	// Paned returns the underlying PanedWidget for direct access.
	178	+	func (sv *SplitView) Paned() PanedWidget {
	179	+	return sv.paned
	180	+	}
	181	+
	182	+	// clampRatio ensures the ratio is within [0.0, 1.0].
	183	+	func clampRatio(ratio float64) float64 {
	184	+	if ratio < 0.0 {
	185	+	return 0.0
	186	+	}
	187	+	if ratio > 1.0 {
	188	+	return 1.0
	189	+	}
	190	+	return ratio
	191	+	}

A internal/ui/layout/split_test.go +386 -0

@@ -0,0 +1,386 @@
	1	+	package layout_test
	2	+
	3	+	import (
	4	+	"testing"
	5	+
	6	+	"github.com/stretchr/testify/assert"
	7	+	"github.com/stretchr/testify/mock"
	8	+	"github.com/stretchr/testify/require"
	9	+
	10	+	"github.com/bnema/dumber/internal/ui/layout"
	11	+	"github.com/bnema/dumber/internal/ui/layout/mocks"
	12	+	)
	13	+
	14	+	func TestNewSplitView_Horizontal(t *testing.T) {
	15	+	// Arrange
	16	+	mockFactory := mocks.NewMockWidgetFactory(t)
	17	+	mockPaned := mocks.NewMockPanedWidget(t)
	18	+	mockStartChild := mocks.NewMockWidget(t)
	19	+	mockEndChild := mocks.NewMockWidget(t)
	20	+
	21	+	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
	22	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	23	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	24	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	25	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	26	+	mockPaned.EXPECT().SetStartChild(mockStartChild).Once()
	27	+	mockPaned.EXPECT().SetEndChild(mockEndChild).Once()
	28	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	29	+
	30	+	// Act
	31	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, mockStartChild, mockEndChild, 0.5)
	32	+
	33	+	// Assert
	34	+	require.NotNil(t, sv)
	35	+	assert.Equal(t, layout.OrientationHorizontal, sv.Orientation())
	36	+	assert.Equal(t, 0.5, sv.GetRatio())
	37	+	assert.Equal(t, mockStartChild, sv.StartChild())
	38	+	assert.Equal(t, mockEndChild, sv.EndChild())
	39	+	}
	40	+
	41	+	func TestNewSplitView_Vertical(t *testing.T) {
	42	+	// Arrange
	43	+	mockFactory := mocks.NewMockWidgetFactory(t)
	44	+	mockPaned := mocks.NewMockPanedWidget(t)
	45	+	mockStartChild := mocks.NewMockWidget(t)
	46	+	mockEndChild := mocks.NewMockWidget(t)
	47	+
	48	+	mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()
	49	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	50	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	51	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	52	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	53	+	mockPaned.EXPECT().SetStartChild(mockStartChild).Once()
	54	+	mockPaned.EXPECT().SetEndChild(mockEndChild).Once()
	55	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	56	+
	57	+	// Act
	58	+	sv := layout.NewSplitView(mockFactory, layout.OrientationVertical, mockStartChild, mockEndChild, 0.5)
	59	+
	60	+	// Assert
	61	+	require.NotNil(t, sv)
	62	+	assert.Equal(t, layout.OrientationVertical, sv.Orientation())
	63	+	}
	64	+
	65	+	func TestNewSplitView_NilChildren(t *testing.T) {
	66	+	// Arrange
	67	+	mockFactory := mocks.NewMockWidgetFactory(t)
	68	+	mockPaned := mocks.NewMockPanedWidget(t)
	69	+
	70	+	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
	71	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	72	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	73	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	74	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	75	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	76	+	// SetStartChild and SetEndChild should NOT be called when children are nil
	77	+
	78	+	// Act
	79	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	80	+
	81	+	// Assert
	82	+	require.NotNil(t, sv)
	83	+	assert.Nil(t, sv.StartChild())
	84	+	assert.Nil(t, sv.EndChild())
	85	+	}
	86	+
	87	+	func TestSetRatio_ValidRange(t *testing.T) {
	88	+	tests := []struct {
	89	+	name string
	90	+	input float64
	91	+	expected float64
	92	+	}{
	93	+	{"zero", 0.0, 0.0},
	94	+	{"one", 1.0, 1.0},
	95	+	{"middle", 0.5, 0.5},
	96	+	{"quarter", 0.25, 0.25},
	97	+	{"three_quarters", 0.75, 0.75},
	98	+	}
	99	+
	100	+	for _, tt := range tests {
	101	+	t.Run(tt.name, func(t *testing.T) {
	102	+	// Arrange
	103	+	mockFactory := mocks.NewMockWidgetFactory(t)
	104	+	mockPaned := mocks.NewMockPanedWidget(t)
	105	+
	106	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	107	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	108	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	109	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	110	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	111	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	112	+
	113	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	114	+
	115	+	// Act
	116	+	sv.SetRatio(tt.input)
	117	+
	118	+	// Assert
	119	+	assert.Equal(t, tt.expected, sv.GetRatio())
	120	+	})
	121	+	}
	122	+	}
	123	+
	124	+	func TestSetRatio_OutOfRange_Clamped(t *testing.T) {
	125	+	tests := []struct {
	126	+	name string
	127	+	input float64
	128	+	expected float64
	129	+	}{
	130	+	{"negative", -0.5, 0.0},
	131	+	{"very_negative", -100.0, 0.0},
	132	+	{"greater_than_one", 1.5, 1.0},
	133	+	{"much_greater", 100.0, 1.0},
	134	+	}
	135	+
	136	+	for _, tt := range tests {
	137	+	t.Run(tt.name, func(t *testing.T) {
	138	+	// Arrange
	139	+	mockFactory := mocks.NewMockWidgetFactory(t)
	140	+	mockPaned := mocks.NewMockPanedWidget(t)
	141	+
	142	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	143	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	144	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	145	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	146	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	147	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	148	+
	149	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	150	+
	151	+	// Act
	152	+	sv.SetRatio(tt.input)
	153	+
	154	+	// Assert
	155	+	assert.Equal(t, tt.expected, sv.GetRatio())
	156	+	})
	157	+	}
	158	+	}
	159	+
	160	+	func TestSwapStart_ReplacesChild(t *testing.T) {
	161	+	// Arrange
	162	+	mockFactory := mocks.NewMockWidgetFactory(t)
	163	+	mockPaned := mocks.NewMockPanedWidget(t)
	164	+	mockOldChild := mocks.NewMockWidget(t)
	165	+	mockNewChild := mocks.NewMockWidget(t)
	166	+
	167	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	168	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	169	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	170	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	171	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	172	+	mockPaned.EXPECT().SetStartChild(mockOldChild).Once()
	173	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	174	+
	175	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, mockOldChild, nil, 0.5)
	176	+
	177	+	// Expect swap operations
	178	+	mockPaned.EXPECT().SetStartChild(nil).Once() // Remove old
	179	+	mockPaned.EXPECT().SetStartChild(mockNewChild).Once() // Add new
	180	+
	181	+	// Act
	182	+	sv.SwapStart(mockNewChild)
	183	+
	184	+	// Assert
	185	+	assert.Equal(t, mockNewChild, sv.StartChild())
	186	+	}
	187	+
	188	+	func TestSwapEnd_ReplacesChild(t *testing.T) {
	189	+	// Arrange
	190	+	mockFactory := mocks.NewMockWidgetFactory(t)
	191	+	mockPaned := mocks.NewMockPanedWidget(t)
	192	+	mockOldChild := mocks.NewMockWidget(t)
	193	+	mockNewChild := mocks.NewMockWidget(t)
	194	+
	195	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	196	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	197	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	198	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	199	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	200	+	mockPaned.EXPECT().SetEndChild(mockOldChild).Once()
	201	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	202	+
	203	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)
	204	+
	205	+	// Expect swap operations
	206	+	mockPaned.EXPECT().SetEndChild(nil).Once() // Remove old
	207	+	mockPaned.EXPECT().SetEndChild(mockNewChild).Once() // Add new
	208	+
	209	+	// Act
	210	+	sv.SwapEnd(mockNewChild)
	211	+
	212	+	// Assert
	213	+	assert.Equal(t, mockNewChild, sv.EndChild())
	214	+	}
	215	+
	216	+	func TestSwapStart_FromNil(t *testing.T) {
	217	+	// Arrange
	218	+	mockFactory := mocks.NewMockWidgetFactory(t)
	219	+	mockPaned := mocks.NewMockPanedWidget(t)
	220	+	mockNewChild := mocks.NewMockWidget(t)
	221	+
	222	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	223	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	224	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	225	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	226	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	227	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	228	+
	229	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	230	+
	231	+	// Expect only adding new child (no removal since old was nil)
	232	+	mockPaned.EXPECT().SetStartChild(mockNewChild).Once()
	233	+
	234	+	// Act
	235	+	sv.SwapStart(mockNewChild)
	236	+
	237	+	// Assert
	238	+	assert.Equal(t, mockNewChild, sv.StartChild())
	239	+	}
	240	+
	241	+	func TestSwapEnd_ToNil(t *testing.T) {
	242	+	// Arrange
	243	+	mockFactory := mocks.NewMockWidgetFactory(t)
	244	+	mockPaned := mocks.NewMockPanedWidget(t)
	245	+	mockOldChild := mocks.NewMockWidget(t)
	246	+
	247	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	248	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	249	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	250	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	251	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	252	+	mockPaned.EXPECT().SetEndChild(mockOldChild).Once()
	253	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	254	+
	255	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, mockOldChild, 0.5)
	256	+
	257	+	// Expect removal (SetEndChild(nil) called for clearing old)
	258	+	mockPaned.EXPECT().SetEndChild(nil).Once()
	259	+
	260	+	// Act
	261	+	sv.SwapEnd(nil)
	262	+
	263	+	// Assert
	264	+	assert.Nil(t, sv.EndChild())
	265	+	}
	266	+
	267	+	func TestWidget_ReturnsPanedWidget(t *testing.T) {
	268	+	// Arrange
	269	+	mockFactory := mocks.NewMockWidgetFactory(t)
	270	+	mockPaned := mocks.NewMockPanedWidget(t)
	271	+
	272	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	273	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	274	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	275	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	276	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	277	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	278	+
	279	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	280	+
	281	+	// Act
	282	+	widget := sv.Widget()
	283	+
	284	+	// Assert
	285	+	assert.Equal(t, mockPaned, widget)
	286	+	}
	287	+
	288	+	func TestSetPosition_DelegatesToPaned(t *testing.T) {
	289	+	// Arrange
	290	+	mockFactory := mocks.NewMockWidgetFactory(t)
	291	+	mockPaned := mocks.NewMockPanedWidget(t)
	292	+
	293	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	294	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	295	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	296	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	297	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	298	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	299	+
	300	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	301	+
	302	+	mockPaned.EXPECT().SetPosition(400).Once()
	303	+
	304	+	// Act
	305	+	sv.SetPosition(400)
	306	+
	307	+	// Assert - verified by mock expectations
	308	+	}
	309	+
	310	+	func TestGetPosition_DelegatesToPaned(t *testing.T) {
	311	+	// Arrange
	312	+	mockFactory := mocks.NewMockWidgetFactory(t)
	313	+	mockPaned := mocks.NewMockPanedWidget(t)
	314	+
	315	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	316	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	317	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	318	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	319	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	320	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	321	+
	322	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	323	+
	324	+	mockPaned.EXPECT().GetPosition().Return(400).Once()
	325	+
	326	+	// Act
	327	+	pos := sv.GetPosition()
	328	+
	329	+	// Assert
	330	+	assert.Equal(t, 400, pos)
	331	+	}
	332	+
	333	+	func TestSetWideHandle_DelegatesToPaned(t *testing.T) {
	334	+	// Arrange
	335	+	mockFactory := mocks.NewMockWidgetFactory(t)
	336	+	mockPaned := mocks.NewMockPanedWidget(t)
	337	+
	338	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	339	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	340	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	341	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	342	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	343	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	344	+
	345	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, 0.5)
	346	+
	347	+	mockPaned.EXPECT().SetWideHandle(true).Once()
	348	+
	349	+	// Act
	350	+	sv.SetWideHandle(true)
	351	+
	352	+	// Assert - verified by mock expectations
	353	+	}
	354	+
	355	+	func TestNewSplitView_InitialRatio_Clamped(t *testing.T) {
	356	+	tests := []struct {
	357	+	name string
	358	+	input float64
	359	+	expected float64
	360	+	}{
	361	+	{"negative_clamped_to_zero", -0.5, 0.0},
	362	+	{"greater_than_one_clamped", 1.5, 1.0},
	363	+	{"valid_preserved", 0.3, 0.3},
	364	+	}
	365	+
	366	+	for _, tt := range tests {
	367	+	t.Run(tt.name, func(t *testing.T) {
	368	+	// Arrange
	369	+	mockFactory := mocks.NewMockWidgetFactory(t)
	370	+	mockPaned := mocks.NewMockPanedWidget(t)
	371	+
	372	+	mockFactory.EXPECT().NewPaned(mock.Anything).Return(mockPaned).Once()
	373	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	374	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	375	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	376	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	377	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	378	+
	379	+	// Act
	380	+	sv := layout.NewSplitView(mockFactory, layout.OrientationHorizontal, nil, nil, tt.input)
	381	+
	382	+	// Assert
	383	+	assert.Equal(t, tt.expected, sv.GetRatio())
	384	+	})
	385	+	}
	386	+	}

A internal/ui/layout/stacked.go +334 -0

@@ -0,0 +1,334 @@
	1	+	package layout
	2	+
	3	+	import (
	4	+	"errors"
	5	+	"sync"
	6	+	)
	7	+
	8	+	// ErrStackEmpty is returned when operating on an empty stack.
	9	+	var ErrStackEmpty = errors.New("stack is empty")
	10	+
	11	+	// ErrIndexOutOfBounds is returned when an index is out of range.
	12	+	var ErrIndexOutOfBounds = errors.New("index out of bounds")
	13	+
	14	+	// ErrCannotRemoveLastPane is returned when trying to remove the last pane from a stack.
	15	+	var ErrCannotRemoveLastPane = errors.New("cannot remove last pane from stack")
	16	+
	17	+	// stackedPane represents a single pane within a stacked container.
	18	+	type stackedPane struct {
	19	+	titleBar BoxWidget // horizontal box with favicon + title label
	20	+	container Widget // the pane view widget
	21	+	title string
	22	+	favicon ImageWidget
	23	+	label LabelWidget
	24	+	isActive bool
	25	+	}
	26	+
	27	+	// StackedView manages a stack of panes where only one is visible at a time.
	28	+	// Inactive panes show title bars that can be clicked to activate them.
	29	+	type StackedView struct {
	30	+	factory WidgetFactory
	31	+	box BoxWidget // vertical container for all content
	32	+	panes []*stackedPane
	33	+	activeIndex int
	34	+
	35	+	onActivate func(index int) // called when a pane is activated via title bar click
	36	+
	37	+	mu sync.RWMutex
	38	+	}
	39	+
	40	+	// NewStackedView creates a new stacked pane container.
	41	+	func NewStackedView(factory WidgetFactory) *StackedView {
	42	+	box := factory.NewBox(OrientationVertical, 0)
	43	+	box.SetHexpand(true)
	44	+	box.SetVexpand(true)
	45	+
	46	+	return &StackedView{
	47	+	factory: factory,
	48	+	box: box,
	49	+	panes: make([]*stackedPane, 0),
	50	+	activeIndex: -1,
	51	+	}
	52	+	}
	53	+
	54	+	// AddPane adds a new pane to the stack.
	55	+	// The new pane becomes active (visible).
	56	+	func (sv *StackedView) AddPane(title, faviconIconName string, container Widget) int {
	57	+	sv.mu.Lock()
	58	+	defer sv.mu.Unlock()
	59	+
	60	+	// Create title bar
	61	+	titleBar := sv.factory.NewBox(OrientationHorizontal, 4)
	62	+	titleBar.AddCssClass("stacked-pane-titlebar")
	63	+
	64	+	// Create favicon image
	65	+	favicon := sv.factory.NewImage()
	66	+	if faviconIconName != "" {
	67	+	favicon.SetFromIconName(faviconIconName)
	68	+	} else {
	69	+	favicon.SetFromIconName("web-browser-symbolic")
	70	+	}
	71	+	favicon.SetPixelSize(16)
	72	+	titleBar.Append(favicon)
	73	+
	74	+	// Create title label
	75	+	label := sv.factory.NewLabel(title)
	76	+	label.SetEllipsize(EllipsizeEnd)
	77	+	label.SetMaxWidthChars(30)
	78	+	label.SetHexpand(true)
	79	+	label.SetXalign(0.0)
	80	+	titleBar.Append(label)
	81	+
	82	+	// Make title bar clickable
	83	+	titleButton := sv.factory.NewButton()
	84	+	titleButton.SetChild(titleBar)
	85	+	titleButton.AddCssClass("stacked-pane-title-button")
	86	+	titleButton.SetFocusOnClick(false)
	87	+
	88	+	pane := &stackedPane{
	89	+	titleBar: titleBar,
	90	+	container: container,
	91	+	title: title,
	92	+	favicon: favicon,
	93	+	label: label,
	94	+	isActive: false,
	95	+	}
	96	+
	97	+	index := len(sv.panes)
	98	+	sv.panes = append(sv.panes, pane)
	99	+
	100	+	// Connect click handler
	101	+	titleButton.ConnectClicked(func() {
	102	+	sv.mu.RLock()
	103	+	callback := sv.onActivate
	104	+	sv.mu.RUnlock()
	105	+
	106	+	if callback != nil {
	107	+	callback(index)
	108	+	}
	109	+	})
	110	+
	111	+	// Add to container
	112	+	sv.box.Append(titleButton)
	113	+	if container != nil {
	114	+	sv.box.Append(container)
	115	+	}
	116	+
	117	+	// Set this pane as active
	118	+	sv.setActiveInternal(index)
	119	+
	120	+	return index
	121	+	}
	122	+
	123	+	// RemovePane removes a pane from the stack by index.
	124	+	// Returns an error if trying to remove the last pane.
	125	+	func (sv *StackedView) RemovePane(index int) error {
	126	+	sv.mu.Lock()
	127	+	defer sv.mu.Unlock()
	128	+
	129	+	if len(sv.panes) == 0 {
	130	+	return ErrStackEmpty
	131	+	}
	132	+	if index < 0 \|\| index >= len(sv.panes) {
	133	+	return ErrIndexOutOfBounds
	134	+	}
	135	+	if len(sv.panes) == 1 {
	136	+	return ErrCannotRemoveLastPane
	137	+	}
	138	+
	139	+	pane := sv.panes[index]
	140	+
	141	+	// Remove from container
	142	+	if pane.titleBar != nil {
	143	+	// The title bar is wrapped in a button, need to get parent
	144	+	parent := pane.titleBar.GetParent()
	145	+	if parent != nil {
	146	+	sv.box.Remove(parent)
	147	+	}
	148	+	}
	149	+	if pane.container != nil {
	150	+	sv.box.Remove(pane.container)
	151	+	}
	152	+
	153	+	// Remove from slice
	154	+	sv.panes = append(sv.panes[:index], sv.panes[index+1:]...)
	155	+
	156	+	// Adjust active index
	157	+	if sv.activeIndex >= len(sv.panes) {
	158	+	sv.activeIndex = len(sv.panes) - 1
	159	+	} else if sv.activeIndex > index {
	160	+	sv.activeIndex--
	161	+	}
	162	+
	163	+	// Update visibility
	164	+	if sv.activeIndex >= 0 {
	165	+	sv.updateVisibilityInternal()
	166	+	}
	167	+
	168	+	return nil
	169	+	}
	170	+
	171	+	// SetActive activates the pane at the given index.
	172	+	// The active pane's container is shown; inactive panes show only title bars.
	173	+	func (sv *StackedView) SetActive(index int) error {
	174	+	sv.mu.Lock()
	175	+	defer sv.mu.Unlock()
	176	+
	177	+	if len(sv.panes) == 0 {
	178	+	return ErrStackEmpty
	179	+	}
	180	+	if index < 0 \|\| index >= len(sv.panes) {
	181	+	return ErrIndexOutOfBounds
	182	+	}
	183	+
	184	+	sv.setActiveInternal(index)
	185	+	return nil
	186	+	}
	187	+
	188	+	// setActiveInternal sets the active pane without locking.
	189	+	func (sv *StackedView) setActiveInternal(index int) {
	190	+	sv.activeIndex = index
	191	+	sv.updateVisibilityInternal()
	192	+	}
	193	+
	194	+	// updateVisibilityInternal updates visibility of all panes based on activeIndex.
	195	+	func (sv *StackedView) updateVisibilityInternal() {
	196	+	for i, pane := range sv.panes {
	197	+	isActive := i == sv.activeIndex
	198	+	pane.isActive = isActive
	199	+
	200	+	// Title bar is always visible for inactive panes, hidden for active
	201	+	if pane.titleBar != nil {
	202	+	parent := pane.titleBar.GetParent()
	203	+	if parent != nil {
	204	+	parent.SetVisible(!isActive)
	205	+	}
	206	+	}
	207	+
	208	+	// Container is visible only for active pane
	209	+	if pane.container != nil {
	210	+	pane.container.SetVisible(isActive)
	211	+	}
	212	+
	213	+	// Update CSS classes
	214	+	if pane.titleBar != nil {
	215	+	if isActive {
	216	+	pane.titleBar.AddCssClass("active")
	217	+	} else {
	218	+	pane.titleBar.RemoveCssClass("active")
	219	+	}
	220	+	}
	221	+	}
	222	+	}
	223	+
	224	+	// ActiveIndex returns the index of the currently active pane.
	225	+	// Returns -1 if the stack is empty.
	226	+	func (sv *StackedView) ActiveIndex() int {
	227	+	sv.mu.RLock()
	228	+	defer sv.mu.RUnlock()
	229	+
	230	+	return sv.activeIndex
	231	+	}
	232	+
	233	+	// Count returns the number of panes in the stack.
	234	+	func (sv *StackedView) Count() int {
	235	+	sv.mu.RLock()
	236	+	defer sv.mu.RUnlock()
	237	+
	238	+	return len(sv.panes)
	239	+	}
	240	+
	241	+	// SetOnActivate sets the callback for when a pane is activated via title bar click.
	242	+	func (sv *StackedView) SetOnActivate(fn func(index int)) {
	243	+	sv.mu.Lock()
	244	+	defer sv.mu.Unlock()
	245	+
	246	+	sv.onActivate = fn
	247	+	}
	248	+
	249	+	// UpdateTitle updates the title of a pane at the given index.
	250	+	func (sv *StackedView) UpdateTitle(index int, title string) error {
	251	+	sv.mu.Lock()
	252	+	defer sv.mu.Unlock()
	253	+
	254	+	if index < 0 \|\| index >= len(sv.panes) {
	255	+	return ErrIndexOutOfBounds
	256	+	}
	257	+
	258	+	sv.panes[index].title = title
	259	+	if sv.panes[index].label != nil {
	260	+	sv.panes[index].label.SetText(title)
	261	+	}
	262	+
	263	+	return nil
	264	+	}
	265	+
	266	+	// UpdateFavicon updates the favicon of a pane at the given index.
	267	+	func (sv *StackedView) UpdateFavicon(index int, iconName string) error {
	268	+	sv.mu.Lock()
	269	+	defer sv.mu.Unlock()
	270	+
	271	+	if index < 0 \|\| index >= len(sv.panes) {
	272	+	return ErrIndexOutOfBounds
	273	+	}
	274	+
	275	+	if sv.panes[index].favicon != nil {
	276	+	if iconName != "" {
	277	+	sv.panes[index].favicon.SetFromIconName(iconName)
	278	+	} else {
	279	+	sv.panes[index].favicon.SetFromIconName("web-browser-symbolic")
	280	+	}
	281	+	}
	282	+
	283	+	return nil
	284	+	}
	285	+
	286	+	// GetContainer returns the container widget for the pane at the given index.
	287	+	func (sv *StackedView) GetContainer(index int) (Widget, error) {
	288	+	sv.mu.RLock()
	289	+	defer sv.mu.RUnlock()
	290	+
	291	+	if index < 0 \|\| index >= len(sv.panes) {
	292	+	return nil, ErrIndexOutOfBounds
	293	+	}
	294	+
	295	+	return sv.panes[index].container, nil
	296	+	}
	297	+
	298	+	// Widget returns the underlying BoxWidget for embedding in containers.
	299	+	func (sv *StackedView) Widget() Widget {
	300	+	return sv.box
	301	+	}
	302	+
	303	+	// Box returns the underlying BoxWidget for direct access.
	304	+	func (sv *StackedView) Box() BoxWidget {
	305	+	return sv.box
	306	+	}
	307	+
	308	+	// NavigateNext moves to the next pane in the stack (wraps around).
	309	+	func (sv *StackedView) NavigateNext() error {
	310	+	sv.mu.Lock()
	311	+	defer sv.mu.Unlock()
	312	+
	313	+	if len(sv.panes) == 0 {
	314	+	return ErrStackEmpty
	315	+	}
	316	+
	317	+	newIndex := (sv.activeIndex + 1) % len(sv.panes)
	318	+	sv.setActiveInternal(newIndex)
	319	+	return nil
	320	+	}
	321	+
	322	+	// NavigatePrevious moves to the previous pane in the stack (wraps around).
	323	+	func (sv *StackedView) NavigatePrevious() error {
	324	+	sv.mu.Lock()
	325	+	defer sv.mu.Unlock()
	326	+
	327	+	if len(sv.panes) == 0 {
	328	+	return ErrStackEmpty
	329	+	}
	330	+
	331	+	newIndex := (sv.activeIndex - 1 + len(sv.panes)) % len(sv.panes)
	332	+	sv.setActiveInternal(newIndex)
	333	+	return nil
	334	+	}

A internal/ui/layout/stacked_test.go +486 -0

@@ -0,0 +1,486 @@
	1	+	package layout_test
	2	+
	3	+	import (
	4	+	"testing"
	5	+
	6	+	"github.com/stretchr/testify/assert"
	7	+	"github.com/stretchr/testify/mock"
	8	+	"github.com/stretchr/testify/require"
	9	+
	10	+	"github.com/bnema/dumber/internal/ui/layout"
	11	+	"github.com/bnema/dumber/internal/ui/layout/mocks"
	12	+	)
	13	+
	14	+	// setupMockFactory creates a factory that returns configured mocks for stacked view tests.
	15	+	func setupMockFactory(t testing.T) (mocks.MockWidgetFactory, *mocks.MockBoxWidget) {
	16	+	mockFactory := mocks.NewMockWidgetFactory(t)
	17	+	mockBox := mocks.NewMockBoxWidget(t)
	18	+
	19	+	mockFactory.EXPECT().NewBox(layout.OrientationVertical, 0).Return(mockBox).Once()
	20	+	mockBox.EXPECT().SetHexpand(true).Once()
	21	+	mockBox.EXPECT().SetVexpand(true).Once()
	22	+
	23	+	return mockFactory, mockBox
	24	+	}
	25	+
	26	+	// setupPaneMocks creates mocks needed for AddPane
	27	+	func setupPaneMocks(t testing.T, mockFactory mocks.MockWidgetFactory, mockBox *mocks.MockBoxWidget) (
	28	+	mocks.MockBoxWidget, mocks.MockImageWidget, mocks.MockLabelWidget, mocks.MockButtonWidget, *mocks.MockWidget,
	29	+	) {
	30	+	mockTitleBar := mocks.NewMockBoxWidget(t)
	31	+	mockFavicon := mocks.NewMockImageWidget(t)
	32	+	mockLabel := mocks.NewMockLabelWidget(t)
	33	+	mockButton := mocks.NewMockButtonWidget(t)
	34	+	mockContainer := mocks.NewMockWidget(t)
	35	+
	36	+	// Title bar creation
	37	+	mockFactory.EXPECT().NewBox(layout.OrientationHorizontal, 4).Return(mockTitleBar).Once()
	38	+	mockTitleBar.EXPECT().AddCssClass("stacked-pane-titlebar").Once()
	39	+
	40	+	// Favicon
	41	+	mockFactory.EXPECT().NewImage().Return(mockFavicon).Once()
	42	+	mockFavicon.EXPECT().SetFromIconName(mock.Anything).Once()
	43	+	mockFavicon.EXPECT().SetPixelSize(16).Once()
	44	+	mockTitleBar.EXPECT().Append(mockFavicon).Once()
	45	+
	46	+	// Label
	47	+	mockFactory.EXPECT().NewLabel(mock.Anything).Return(mockLabel).Once()
	48	+	mockLabel.EXPECT().SetEllipsize(layout.EllipsizeEnd).Once()
	49	+	mockLabel.EXPECT().SetMaxWidthChars(30).Once()
	50	+	mockLabel.EXPECT().SetHexpand(true).Once()
	51	+	mockLabel.EXPECT().SetXalign(float32(0.0)).Once()
	52	+	mockTitleBar.EXPECT().Append(mockLabel).Once()
	53	+
	54	+	// Button wrapping title bar
	55	+	mockFactory.EXPECT().NewButton().Return(mockButton).Once()
	56	+	mockButton.EXPECT().SetChild(mockTitleBar).Once()
	57	+	mockButton.EXPECT().AddCssClass("stacked-pane-title-button").Once()
	58	+	mockButton.EXPECT().SetFocusOnClick(false).Once()
	59	+	mockButton.EXPECT().ConnectClicked(mock.Anything).Return(uint32(1)).Once()
	60	+
	61	+	// Adding to main box
	62	+	mockBox.EXPECT().Append(mockButton).Once()
	63	+	mockBox.EXPECT().Append(mockContainer).Once()
	64	+
	65	+	return mockTitleBar, mockFavicon, mockLabel, mockButton, mockContainer
	66	+	}
	67	+
	68	+	func TestNewStackedView_EmptyStack(t *testing.T) {
	69	+	// Arrange
	70	+	mockFactory, _ := setupMockFactory(t)
	71	+
	72	+	// Act
	73	+	sv := layout.NewStackedView(mockFactory)
	74	+
	75	+	// Assert
	76	+	require.NotNil(t, sv)
	77	+	assert.Equal(t, 0, sv.Count())
	78	+	assert.Equal(t, -1, sv.ActiveIndex())
	79	+	}
	80	+
	81	+	func TestAddPane_SinglePane_BecomesActive(t *testing.T) {
	82	+	// Arrange
	83	+	mockFactory, mockBox := setupMockFactory(t)
	84	+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	85	+
	86	+	// Visibility updates for active pane
	87	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	88	+	mockContainer.EXPECT().SetVisible(true).Once()
	89	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	90	+
	91	+	sv := layout.NewStackedView(mockFactory)
	92	+
	93	+	// Act
	94	+	index := sv.AddPane("Test Page", "web-browser-symbolic", mockContainer)
	95	+
	96	+	// Assert
	97	+	assert.Equal(t, 0, index)
	98	+	assert.Equal(t, 1, sv.Count())
	99	+	assert.Equal(t, 0, sv.ActiveIndex())
	100	+	}
	101	+
	102	+	func TestAddPane_MultiplePanes_LastBecomesActive(t *testing.T) {
	103	+	// Arrange
	104	+	mockFactory, mockBox := setupMockFactory(t)
	105	+
	106	+	// First pane
	107	+	mockTitleBar1, _, _, _, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
	108	+	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
	109	+	mockContainer1.EXPECT().SetVisible(true).Once()
	110	+	mockTitleBar1.EXPECT().AddCssClass("active").Once()
	111	+
	112	+	// Second pane - first pane becomes inactive
	113	+	mockTitleBar2, _, _, _, mockContainer2 := setupPaneMocks(t, mockFactory, mockBox)
	114	+
	115	+	// When second pane is added, update visibility for both
	116	+	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
	117	+	mockContainer1.EXPECT().SetVisible(false).Once()
	118	+	mockTitleBar1.EXPECT().RemoveCssClass("active").Once()
	119	+
	120	+	mockTitleBar2.EXPECT().GetParent().Return(nil).Maybe()
	121	+	mockContainer2.EXPECT().SetVisible(true).Once()
	122	+	mockTitleBar2.EXPECT().AddCssClass("active").Once()
	123	+
	124	+	sv := layout.NewStackedView(mockFactory)
	125	+
	126	+	// Act
	127	+	sv.AddPane("Page 1", "", mockContainer1)
	128	+	index := sv.AddPane("Page 2", "", mockContainer2)
	129	+
	130	+	// Assert
	131	+	assert.Equal(t, 1, index)
	132	+	assert.Equal(t, 2, sv.Count())
	133	+	assert.Equal(t, 1, sv.ActiveIndex())
	134	+	}
	135	+
	136	+	func TestRemovePane_MiddlePane(t *testing.T) {
	137	+	// Arrange
	138	+	mockFactory, mockBox := setupMockFactory(t)
	139	+
	140	+	// Setup 3 panes (simplified - just track the key behaviors)
	141	+	containers := make([]*mocks.MockWidget, 3)
	142	+	titleBars := make([]*mocks.MockBoxWidget, 3)
	143	+	buttons := make([]*mocks.MockButtonWidget, 3)
	144	+
	145	+	for i := 0; i < 3; i++ {
	146	+	var btn *mocks.MockButtonWidget
	147	+	titleBars[i], _, _, btn, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
	148	+	buttons[i] = btn
	149	+	}
	150	+
	151	+	// Allow any visibility calls during setup and removal
	152	+	for i := 0; i < 3; i++ {
	153	+	titleBars[i].EXPECT().GetParent().Return(buttons[i]).Maybe()
	154	+	containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
	155	+	titleBars[i].EXPECT().AddCssClass("active").Maybe()
	156	+	titleBars[i].EXPECT().RemoveCssClass("active").Maybe()
	157	+	// Button visibility changes when panes are activated/deactivated
	158	+	buttons[i].EXPECT().SetVisible(mock.Anything).Maybe()
	159	+	}
	160	+
	161	+	sv := layout.NewStackedView(mockFactory)
	162	+	sv.AddPane("Page 1", "", containers[0])
	163	+	sv.AddPane("Page 2", "", containers[1])
	164	+	sv.AddPane("Page 3", "", containers[2])
	165	+
	166	+	// Remove middle pane (index 1)
	167	+	// The parent of titleBar is the button widget
	168	+	mockBox.EXPECT().Remove(buttons[1]).Once()
	169	+	mockBox.EXPECT().Remove(containers[1]).Once()
	170	+
	171	+	// Act
	172	+	err := sv.RemovePane(1)
	173	+
	174	+	// Assert
	175	+	require.NoError(t, err)
	176	+	assert.Equal(t, 2, sv.Count())
	177	+	}
	178	+
	179	+	func TestRemovePane_LastPane_ReturnsError(t *testing.T) {
	180	+	// Arrange
	181	+	mockFactory, mockBox := setupMockFactory(t)
	182	+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	183	+
	184	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	185	+	mockContainer.EXPECT().SetVisible(true).Once()
	186	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	187	+
	188	+	sv := layout.NewStackedView(mockFactory)
	189	+	sv.AddPane("Only Page", "", mockContainer)
	190	+
	191	+	// Act
	192	+	err := sv.RemovePane(0)
	193	+
	194	+	// Assert
	195	+	assert.ErrorIs(t, err, layout.ErrCannotRemoveLastPane)
	196	+	assert.Equal(t, 1, sv.Count())
	197	+	}
	198	+
	199	+	func TestRemovePane_EmptyStack_ReturnsError(t *testing.T) {
	200	+	// Arrange
	201	+	mockFactory, _ := setupMockFactory(t)
	202	+	sv := layout.NewStackedView(mockFactory)
	203	+
	204	+	// Act
	205	+	err := sv.RemovePane(0)
	206	+
	207	+	// Assert
	208	+	assert.ErrorIs(t, err, layout.ErrStackEmpty)
	209	+	}
	210	+
	211	+	func TestRemovePane_IndexOutOfBounds(t *testing.T) {
	212	+	// Arrange
	213	+	mockFactory, mockBox := setupMockFactory(t)
	214	+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	215	+
	216	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	217	+	mockContainer.EXPECT().SetVisible(true).Once()
	218	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	219	+
	220	+	sv := layout.NewStackedView(mockFactory)
	221	+	sv.AddPane("Page", "", mockContainer)
	222	+
	223	+	// Act
	224	+	err := sv.RemovePane(5)
	225	+
	226	+	// Assert
	227	+	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
	228	+	}
	229	+
	230	+	func TestSetActive_ValidIndex(t *testing.T) {
	231	+	// Arrange
	232	+	mockFactory, mockBox := setupMockFactory(t)
	233	+
	234	+	containers := make([]*mocks.MockWidget, 2)
	235	+	titleBars := make([]*mocks.MockBoxWidget, 2)
	236	+
	237	+	for i := 0; i < 2; i++ {
	238	+	titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
	239	+	titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
	240	+	containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
	241	+	titleBars[i].EXPECT().AddCssClass("active").Maybe()
	242	+	titleBars[i].EXPECT().RemoveCssClass("active").Maybe()
	243	+	}
	244	+
	245	+	sv := layout.NewStackedView(mockFactory)
	246	+	sv.AddPane("Page 1", "", containers[0])
	247	+	sv.AddPane("Page 2", "", containers[1])
	248	+
	249	+	// Act - switch back to first pane
	250	+	err := sv.SetActive(0)
	251	+
	252	+	// Assert
	253	+	require.NoError(t, err)
	254	+	assert.Equal(t, 0, sv.ActiveIndex())
	255	+	}
	256	+
	257	+	func TestSetActive_OutOfBounds(t *testing.T) {
	258	+	// Arrange
	259	+	mockFactory, mockBox := setupMockFactory(t)
	260	+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	261	+
	262	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	263	+	mockContainer.EXPECT().SetVisible(true).Once()
	264	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	265	+
	266	+	sv := layout.NewStackedView(mockFactory)
	267	+	sv.AddPane("Page", "", mockContainer)
	268	+
	269	+	// Act
	270	+	err := sv.SetActive(5)
	271	+
	272	+	// Assert
	273	+	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
	274	+	}
	275	+
	276	+	func TestSetActive_EmptyStack(t *testing.T) {
	277	+	// Arrange
	278	+	mockFactory, _ := setupMockFactory(t)
	279	+	sv := layout.NewStackedView(mockFactory)
	280	+
	281	+	// Act
	282	+	err := sv.SetActive(0)
	283	+
	284	+	// Assert
	285	+	assert.ErrorIs(t, err, layout.ErrStackEmpty)
	286	+	}
	287	+
	288	+	func TestUpdateTitle(t *testing.T) {
	289	+	// Arrange
	290	+	mockFactory, mockBox := setupMockFactory(t)
	291	+	mockTitleBar, _, mockLabel, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	292	+
	293	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	294	+	mockContainer.EXPECT().SetVisible(true).Once()
	295	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	296	+
	297	+	sv := layout.NewStackedView(mockFactory)
	298	+	sv.AddPane("Old Title", "", mockContainer)
	299	+
	300	+	mockLabel.EXPECT().SetText("New Title").Once()
	301	+
	302	+	// Act
	303	+	err := sv.UpdateTitle(0, "New Title")
	304	+
	305	+	// Assert
	306	+	require.NoError(t, err)
	307	+	}
	308	+
	309	+	func TestUpdateTitle_InvalidIndex(t *testing.T) {
	310	+	// Arrange
	311	+	mockFactory, _ := setupMockFactory(t)
	312	+	sv := layout.NewStackedView(mockFactory)
	313	+
	314	+	// Act
	315	+	err := sv.UpdateTitle(0, "Title")
	316	+
	317	+	// Assert
	318	+	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
	319	+	}
	320	+
	321	+	func TestUpdateFavicon(t *testing.T) {
	322	+	// Arrange
	323	+	mockFactory, mockBox := setupMockFactory(t)
	324	+	mockTitleBar, mockFavicon, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	325	+
	326	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	327	+	mockContainer.EXPECT().SetVisible(true).Once()
	328	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	329	+
	330	+	sv := layout.NewStackedView(mockFactory)
	331	+	sv.AddPane("Page", "", mockContainer)
	332	+
	333	+	mockFavicon.EXPECT().SetFromIconName("new-icon").Once()
	334	+
	335	+	// Act
	336	+	err := sv.UpdateFavicon(0, "new-icon")
	337	+
	338	+	// Assert
	339	+	require.NoError(t, err)
	340	+	}
	341	+
	342	+	func TestGetContainer(t *testing.T) {
	343	+	// Arrange
	344	+	mockFactory, mockBox := setupMockFactory(t)
	345	+	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
	346	+
	347	+	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
	348	+	mockContainer.EXPECT().SetVisible(true).Once()
	349	+	mockTitleBar.EXPECT().AddCssClass("active").Once()
	350	+
	351	+	sv := layout.NewStackedView(mockFactory)
	352	+	sv.AddPane("Page", "", mockContainer)
	353	+
	354	+	// Act
	355	+	container, err := sv.GetContainer(0)
	356	+
	357	+	// Assert
	358	+	require.NoError(t, err)
	359	+	assert.Equal(t, mockContainer, container)
	360	+	}
	361	+
	362	+	func TestGetContainer_InvalidIndex(t *testing.T) {
	363	+	// Arrange
	364	+	mockFactory, _ := setupMockFactory(t)
	365	+	sv := layout.NewStackedView(mockFactory)
	366	+
	367	+	// Act
	368	+	container, err := sv.GetContainer(0)
	369	+
	370	+	// Assert
	371	+	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
	372	+	assert.Nil(t, container)
	373	+	}
	374	+
	375	+	func TestWidget_ReturnsBoxWidget(t *testing.T) {
	376	+	// Arrange
	377	+	mockFactory, mockBox := setupMockFactory(t)
	378	+	sv := layout.NewStackedView(mockFactory)
	379	+
	380	+	// Act
	381	+	widget := sv.Widget()
	382	+
	383	+	// Assert
	384	+	assert.Equal(t, mockBox, widget)
	385	+	}
	386	+
	387	+	func TestNavigateNext_WrapsAround(t *testing.T) {
	388	+	// Arrange
	389	+	mockFactory, mockBox := setupMockFactory(t)
	390	+
	391	+	containers := make([]*mocks.MockWidget, 2)
	392	+	titleBars := make([]*mocks.MockBoxWidget, 2)
	393	+
	394	+	for i := 0; i < 2; i++ {
	395	+	titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
	396	+	titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
	397	+	containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
	398	+	titleBars[i].EXPECT().AddCssClass("active").Maybe()
	399	+	titleBars[i].EXPECT().RemoveCssClass("active").Maybe()
	400	+	}
	401	+
	402	+	sv := layout.NewStackedView(mockFactory)
	403	+	sv.AddPane("Page 1", "", containers[0])
	404	+	sv.AddPane("Page 2", "", containers[1])
	405	+
	406	+	// Currently at index 1 (last added)
	407	+	assert.Equal(t, 1, sv.ActiveIndex())
	408	+
	409	+	// Act - navigate next should wrap to 0
	410	+	err := sv.NavigateNext()
	411	+
	412	+	// Assert
	413	+	require.NoError(t, err)
	414	+	assert.Equal(t, 0, sv.ActiveIndex())
	415	+	}
	416	+
	417	+	func TestNavigatePrevious_WrapsAround(t *testing.T) {
	418	+	// Arrange
	419	+	mockFactory, mockBox := setupMockFactory(t)
	420	+
	421	+	containers := make([]*mocks.MockWidget, 2)
	422	+	titleBars := make([]*mocks.MockBoxWidget, 2)
	423	+
	424	+	for i := 0; i < 2; i++ {
	425	+	titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
	426	+	titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
	427	+	containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
	428	+	titleBars[i].EXPECT().AddCssClass("active").Maybe()
	429	+	titleBars[i].EXPECT().RemoveCssClass("active").Maybe()
	430	+	}
	431	+
	432	+	sv := layout.NewStackedView(mockFactory)
	433	+	sv.AddPane("Page 1", "", containers[0])
	434	+	sv.AddPane("Page 2", "", containers[1])
	435	+
	436	+	// Set to first pane
	437	+	sv.SetActive(0)
	438	+
	439	+	// Act - navigate previous should wrap to 1
	440	+	err := sv.NavigatePrevious()
	441	+
	442	+	// Assert
	443	+	require.NoError(t, err)
	444	+	assert.Equal(t, 1, sv.ActiveIndex())
	445	+	}
	446	+
	447	+	func TestNavigateNext_EmptyStack(t *testing.T) {
	448	+	// Arrange
	449	+	mockFactory, _ := setupMockFactory(t)
	450	+	sv := layout.NewStackedView(mockFactory)
	451	+
	452	+	// Act
	453	+	err := sv.NavigateNext()
	454	+
	455	+	// Assert
	456	+	assert.ErrorIs(t, err, layout.ErrStackEmpty)
	457	+	}
	458	+
	459	+	func TestNavigatePrevious_EmptyStack(t *testing.T) {
	460	+	// Arrange
	461	+	mockFactory, _ := setupMockFactory(t)
	462	+	sv := layout.NewStackedView(mockFactory)
	463	+
	464	+	// Act
	465	+	err := sv.NavigatePrevious()
	466	+
	467	+	// Assert
	468	+	assert.ErrorIs(t, err, layout.ErrStackEmpty)
	469	+	}
	470	+
	471	+	func TestSetOnActivate_Callback(t *testing.T) {
	472	+	// Arrange
	473	+	mockFactory, _ := setupMockFactory(t)
	474	+	sv := layout.NewStackedView(mockFactory)
	475	+
	476	+	callback := func(index int) {
	477	+	_ = index // Used to test callback registration
	478	+	}
	479	+
	480	+	// Act
	481	+	sv.SetOnActivate(callback)
	482	+
	483	+	// We can't easily test the callback being triggered since it requires
	484	+	// simulating a button click. The test verifies the method doesn't panic.
	485	+	// Integration tests would verify the actual callback invocation.
	486	+	}

A internal/ui/layout/tree.go +225 -0

@@ -0,0 +1,225 @@
	1	+	package layout
	2	+
	3	+	import (
	4	+	"errors"
	5	+	"sync"
	6	+
	7	+	"github.com/bnema/dumber/internal/domain/entity"
	8	+	)
	9	+
	10	+	// ErrNilRoot is returned when attempting to build from a nil root node.
	11	+	var ErrNilRoot = errors.New("root node is nil")
	12	+
	13	+	// ErrNodeNotFound is returned when a node lookup fails.
	14	+	var ErrNodeNotFound = errors.New("node not found")
	15	+
	16	+	// PaneViewFactory creates pane view widgets from pane nodes.
	17	+	// This decouples the TreeRenderer from concrete PaneView implementation.
	18	+	type PaneViewFactory interface {
	19	+	// CreatePaneView creates a widget for a leaf pane node.
	20	+	CreatePaneView(node *entity.PaneNode) Widget
	21	+	}
	22	+
	23	+	// TreeRenderer builds GTK widget trees from domain PaneNode trees.
	24	+	// It maps each node to its corresponding GTK widget and maintains
	25	+	// a lookup table for finding widgets by node ID.
	26	+	type TreeRenderer struct {
	27	+	factory WidgetFactory
	28	+	paneViewFactory PaneViewFactory
	29	+	nodeToWidget map[string]Widget
	30	+	mu sync.RWMutex
	31	+	}
	32	+
	33	+	// NewTreeRenderer creates a new tree renderer.
	34	+	func NewTreeRenderer(factory WidgetFactory, paneViewFactory PaneViewFactory) *TreeRenderer {
	35	+	return &TreeRenderer{
	36	+	factory: factory,
	37	+	paneViewFactory: paneViewFactory,
	38	+	nodeToWidget: make(map[string]Widget),
	39	+	}
	40	+	}
	41	+
	42	+	// Build constructs the entire widget tree from a root PaneNode.
	43	+	// Returns the root widget that can be embedded in a container.
	44	+	func (tr TreeRenderer) Build(root entity.PaneNode) (Widget, error) {
	45	+	if root == nil {
	46	+	return nil, ErrNilRoot
	47	+	}
	48	+
	49	+	tr.mu.Lock()
	50	+	defer tr.mu.Unlock()
	51	+
	52	+	// Clear previous mappings
	53	+	tr.nodeToWidget = make(map[string]Widget)
	54	+
	55	+	return tr.renderNode(root)
	56	+	}
	57	+
	58	+	// renderNode recursively renders a single node and its children.
	59	+	// Must be called with lock held.
	60	+	func (tr TreeRenderer) renderNode(node entity.PaneNode) (Widget, error) {
	61	+	if node == nil {
	62	+	return nil, nil
	63	+	}
	64	+
	65	+	var widget Widget
	66	+	var err error
	67	+
	68	+	switch {
	69	+	case node.IsLeaf():
	70	+	widget = tr.renderLeaf(node)
	71	+	case node.IsSplit():
	72	+	widget, err = tr.renderSplit(node)
	73	+	case node.IsStacked:
	74	+	widget, err = tr.renderStacked(node)
	75	+	default:
	76	+	// Unknown node type - treat as leaf if it has a pane
	77	+	if node.Pane != nil {
	78	+	widget = tr.renderLeaf(node)
	79	+	}
	80	+	}
	81	+
	82	+	if err != nil {
	83	+	return nil, err
	84	+	}
	85	+
	86	+	// Store mapping
	87	+	if widget != nil && node.ID != "" {
	88	+	tr.nodeToWidget[node.ID] = widget
	89	+	}
	90	+
	91	+	return widget, nil
	92	+	}
	93	+
	94	+	// renderLeaf creates a PaneView widget for a leaf node.
	95	+	func (tr TreeRenderer) renderLeaf(node entity.PaneNode) Widget {
	96	+	if tr.paneViewFactory == nil {
	97	+	return nil
	98	+	}
	99	+	return tr.paneViewFactory.CreatePaneView(node)
	100	+	}
	101	+
	102	+	// renderSplit creates a SplitView for a split node.
	103	+	func (tr TreeRenderer) renderSplit(node entity.PaneNode) (Widget, error) {
	104	+	// Render children first
	105	+	leftWidget, err := tr.renderNode(node.Left())
	106	+	if err != nil {
	107	+	return nil, err
	108	+	}
	109	+
	110	+	rightWidget, err := tr.renderNode(node.Right())
	111	+	if err != nil {
	112	+	return nil, err
	113	+	}
	114	+
	115	+	// Determine orientation
	116	+	orientation := OrientationHorizontal
	117	+	if node.SplitDir == entity.SplitVertical {
	118	+	orientation = OrientationVertical
	119	+	}
	120	+
	121	+	// Create split view
	122	+	splitView := NewSplitView(tr.factory, orientation, leftWidget, rightWidget, node.SplitRatio)
	123	+
	124	+	return splitView.Widget(), nil
	125	+	}
	126	+
	127	+	// renderStacked creates a StackedView for a stacked node.
	128	+	func (tr TreeRenderer) renderStacked(node entity.PaneNode) (Widget, error) {
	129	+	stackedView := NewStackedView(tr.factory)
	130	+
	131	+	// Add each child pane to the stack
	132	+	for _, child := range node.Children {
	133	+	childWidget, err := tr.renderNode(child)
	134	+	if err != nil {
	135	+	return nil, err
	136	+	}
	137	+
	138	+	// Get title and favicon from pane if available
	139	+	title := "Untitled"
	140	+	favicon := ""
	141	+	if child.Pane != nil {
	142	+	if child.Pane.Title != "" {
	143	+	title = child.Pane.Title
	144	+	}
	145	+	favicon = child.Pane.FaviconURL
	146	+	}
	147	+
	148	+	stackedView.AddPane(title, favicon, childWidget)
	149	+	}
	150	+
	151	+	// Set active index
	152	+	if node.ActiveStackIndex >= 0 && node.ActiveStackIndex < stackedView.Count() {
	153	+	_ = stackedView.SetActive(node.ActiveStackIndex)
	154	+	}
	155	+
	156	+	return stackedView.Widget(), nil
	157	+	}
	158	+
	159	+	// Lookup finds the widget associated with a node ID.
	160	+	// Returns nil if the node was not found or hasn't been rendered.
	161	+	func (tr *TreeRenderer) Lookup(nodeID string) Widget {
	162	+	tr.mu.RLock()
	163	+	defer tr.mu.RUnlock()
	164	+
	165	+	return tr.nodeToWidget[nodeID]
	166	+	}
	167	+
	168	+	// LookupNode finds both the widget and verifies the node ID exists.
	169	+	// Returns the widget and true if found, nil and false otherwise.
	170	+	func (tr *TreeRenderer) LookupNode(nodeID string) (Widget, bool) {
	171	+	tr.mu.RLock()
	172	+	defer tr.mu.RUnlock()
	173	+
	174	+	widget, ok := tr.nodeToWidget[nodeID]
	175	+	return widget, ok
	176	+	}
	177	+
	178	+	// NodeCount returns the number of nodes currently tracked.
	179	+	func (tr *TreeRenderer) NodeCount() int {
	180	+	tr.mu.RLock()
	181	+	defer tr.mu.RUnlock()
	182	+
	183	+	return len(tr.nodeToWidget)
	184	+	}
	185	+
	186	+	// Clear removes all node-to-widget mappings.
	187	+	func (tr *TreeRenderer) Clear() {
	188	+	tr.mu.Lock()
	189	+	defer tr.mu.Unlock()
	190	+
	191	+	tr.nodeToWidget = make(map[string]Widget)
	192	+	}
	193	+
	194	+	// UpdateSplitRatio updates the ratio of a split view by node ID.
	195	+	// Returns an error if the node is not found or is not a split.
	196	+	func (tr *TreeRenderer) UpdateSplitRatio(nodeID string, ratio float64) error {
	197	+	tr.mu.RLock()
	198	+	widget, ok := tr.nodeToWidget[nodeID]
	199	+	tr.mu.RUnlock()
	200	+
	201	+	if !ok {
	202	+	return ErrNodeNotFound
	203	+	}
	204	+
	205	+	// The widget should be a PanedWidget from a SplitView
	206	+	// We can't directly update the ratio since we only store the Widget interface
	207	+	// The caller would need to track SplitView instances separately or
	208	+	// use the underlying PanedWidget's SetPosition method
	209	+
	210	+	// For now, we can at least verify the widget exists
	211	+	_ = widget
	212	+	return nil
	213	+	}
	214	+
	215	+	// GetNodeIDs returns all tracked node IDs.
	216	+	func (tr *TreeRenderer) GetNodeIDs() []string {
	217	+	tr.mu.RLock()
	218	+	defer tr.mu.RUnlock()
	219	+
	220	+	ids := make([]string, 0, len(tr.nodeToWidget))
	221	+	for id := range tr.nodeToWidget {
	222	+	ids = append(ids, id)
	223	+	}
	224	+	return ids
	225	+	}

A internal/ui/layout/tree_test.go +515 -0

@@ -0,0 +1,515 @@
	1	+	package layout_test
	2	+
	3	+	import (
	4	+	"testing"
	5	+
	6	+	"github.com/stretchr/testify/assert"
	7	+	"github.com/stretchr/testify/mock"
	8	+	"github.com/stretchr/testify/require"
	9	+
	10	+	"github.com/bnema/dumber/internal/domain/entity"
	11	+	"github.com/bnema/dumber/internal/ui/layout"
	12	+	"github.com/bnema/dumber/internal/ui/layout/mocks"
	13	+	)
	14	+
	15	+	func TestNewTreeRenderer_CreatesRenderer(t *testing.T) {
	16	+	// Arrange
	17	+	mockFactory := mocks.NewMockWidgetFactory(t)
	18	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	19	+
	20	+	// Act
	21	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	22	+
	23	+	// Assert
	24	+	require.NotNil(t, renderer)
	25	+	assert.Equal(t, 0, renderer.NodeCount())
	26	+	}
	27	+
	28	+	func TestBuild_NilRoot_ReturnsError(t *testing.T) {
	29	+	// Arrange
	30	+	mockFactory := mocks.NewMockWidgetFactory(t)
	31	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	32	+
	33	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	34	+
	35	+	// Act
	36	+	widget, err := renderer.Build(nil)
	37	+
	38	+	// Assert
	39	+	assert.Nil(t, widget)
	40	+	assert.ErrorIs(t, err, layout.ErrNilRoot)
	41	+	}
	42	+
	43	+	func TestBuild_SingleLeafPane(t *testing.T) {
	44	+	// Arrange
	45	+	mockFactory := mocks.NewMockWidgetFactory(t)
	46	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	47	+	mockWidget := mocks.NewMockWidget(t)
	48	+
	49	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	50	+	node := &entity.PaneNode{
	51	+	ID: "node-1",
	52	+	Pane: pane,
	53	+	}
	54	+
	55	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	56	+
	57	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	58	+
	59	+	// Act
	60	+	widget, err := renderer.Build(node)
	61	+
	62	+	// Assert
	63	+	require.NoError(t, err)
	64	+	assert.Equal(t, mockWidget, widget)
	65	+	assert.Equal(t, 1, renderer.NodeCount())
	66	+
	67	+	// Verify lookup works
	68	+	assert.Equal(t, mockWidget, renderer.Lookup("node-1"))
	69	+	}
	70	+
	71	+	func TestBuild_HorizontalSplit(t *testing.T) {
	72	+	// Arrange
	73	+	mockFactory := mocks.NewMockWidgetFactory(t)
	74	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	75	+	mockPaned := mocks.NewMockPanedWidget(t)
	76	+	mockLeftWidget := mocks.NewMockWidget(t)
	77	+	mockRightWidget := mocks.NewMockWidget(t)
	78	+
	79	+	leftPane := entity.NewPane(entity.PaneID("pane-left"))
	80	+	rightPane := entity.NewPane(entity.PaneID("pane-right"))
	81	+
	82	+	leftNode := &entity.PaneNode{ID: "node-left", Pane: leftPane}
	83	+	rightNode := &entity.PaneNode{ID: "node-right", Pane: rightPane}
	84	+
	85	+	splitNode := &entity.PaneNode{
	86	+	ID: "node-split",
	87	+	SplitDir: entity.SplitHorizontal,
	88	+	SplitRatio: 0.5,
	89	+	Children: []*entity.PaneNode{leftNode, rightNode},
	90	+	}
	91	+
	92	+	mockPaneViewFactory.EXPECT().CreatePaneView(leftNode).Return(mockLeftWidget).Once()
	93	+	mockPaneViewFactory.EXPECT().CreatePaneView(rightNode).Return(mockRightWidget).Once()
	94	+
	95	+	// SplitView creation expectations
	96	+	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
	97	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	98	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	99	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	100	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	101	+	mockPaned.EXPECT().SetStartChild(mockLeftWidget).Once()
	102	+	mockPaned.EXPECT().SetEndChild(mockRightWidget).Once()
	103	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	104	+
	105	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	106	+
	107	+	// Act
	108	+	widget, err := renderer.Build(splitNode)
	109	+
	110	+	// Assert
	111	+	require.NoError(t, err)
	112	+	assert.NotNil(t, widget)
	113	+	assert.Equal(t, 3, renderer.NodeCount()) // split + 2 leaves
	114	+	}
	115	+
	116	+	func TestBuild_VerticalSplit(t *testing.T) {
	117	+	// Arrange
	118	+	mockFactory := mocks.NewMockWidgetFactory(t)
	119	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	120	+	mockPaned := mocks.NewMockPanedWidget(t)
	121	+	mockTopWidget := mocks.NewMockWidget(t)
	122	+	mockBottomWidget := mocks.NewMockWidget(t)
	123	+
	124	+	topPane := entity.NewPane(entity.PaneID("pane-top"))
	125	+	bottomPane := entity.NewPane(entity.PaneID("pane-bottom"))
	126	+
	127	+	topNode := &entity.PaneNode{ID: "node-top", Pane: topPane}
	128	+	bottomNode := &entity.PaneNode{ID: "node-bottom", Pane: bottomPane}
	129	+
	130	+	splitNode := &entity.PaneNode{
	131	+	ID: "node-split",
	132	+	SplitDir: entity.SplitVertical,
	133	+	SplitRatio: 0.3,
	134	+	Children: []*entity.PaneNode{topNode, bottomNode},
	135	+	}
	136	+
	137	+	mockPaneViewFactory.EXPECT().CreatePaneView(topNode).Return(mockTopWidget).Once()
	138	+	mockPaneViewFactory.EXPECT().CreatePaneView(bottomNode).Return(mockBottomWidget).Once()
	139	+
	140	+	// SplitView creation expectations - should be vertical
	141	+	mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockPaned).Once()
	142	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	143	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	144	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	145	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	146	+	mockPaned.EXPECT().SetStartChild(mockTopWidget).Once()
	147	+	mockPaned.EXPECT().SetEndChild(mockBottomWidget).Once()
	148	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	149	+
	150	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	151	+
	152	+	// Act
	153	+	widget, err := renderer.Build(splitNode)
	154	+
	155	+	// Assert
	156	+	require.NoError(t, err)
	157	+	assert.NotNil(t, widget)
	158	+	}
	159	+
	160	+	func TestBuild_NestedSplits(t *testing.T) {
	161	+	// Arrange
	162	+	mockFactory := mocks.NewMockWidgetFactory(t)
	163	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	164	+	mockOuterPaned := mocks.NewMockPanedWidget(t)
	165	+	mockInnerPaned := mocks.NewMockPanedWidget(t)
	166	+	mockWidget1 := mocks.NewMockWidget(t)
	167	+	mockWidget2 := mocks.NewMockWidget(t)
	168	+	mockWidget3 := mocks.NewMockWidget(t)
	169	+
	170	+	// Create tree structure:
	171	+	// outer (horizontal)
	172	+	// / \
	173	+	// inner (vertical) pane3
	174	+	// / \
	175	+	// pane1 pane2
	176	+
	177	+	pane1 := entity.NewPane(entity.PaneID("pane-1"))
	178	+	pane2 := entity.NewPane(entity.PaneID("pane-2"))
	179	+	pane3 := entity.NewPane(entity.PaneID("pane-3"))
	180	+
	181	+	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
	182	+	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
	183	+	node3 := &entity.PaneNode{ID: "node-3", Pane: pane3}
	184	+
	185	+	innerSplit := &entity.PaneNode{
	186	+	ID: "inner-split",
	187	+	SplitDir: entity.SplitVertical,
	188	+	SplitRatio: 0.5,
	189	+	Children: []*entity.PaneNode{node1, node2},
	190	+	}
	191	+
	192	+	outerSplit := &entity.PaneNode{
	193	+	ID: "outer-split",
	194	+	SplitDir: entity.SplitHorizontal,
	195	+	SplitRatio: 0.6,
	196	+	Children: []*entity.PaneNode{innerSplit, node3},
	197	+	}
	198	+
	199	+	// Setup expectations for leaf nodes
	200	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
	201	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	202	+	mockPaneViewFactory.EXPECT().CreatePaneView(node3).Return(mockWidget3).Once()
	203	+
	204	+	// Inner split (vertical) is created first
	205	+	mockFactory.EXPECT().NewPaned(layout.OrientationVertical).Return(mockInnerPaned).Once()
	206	+	mockInnerPaned.EXPECT().SetResizeStartChild(true).Once()
	207	+	mockInnerPaned.EXPECT().SetResizeEndChild(true).Once()
	208	+	mockInnerPaned.EXPECT().SetShrinkStartChild(false).Once()
	209	+	mockInnerPaned.EXPECT().SetShrinkEndChild(false).Once()
	210	+	mockInnerPaned.EXPECT().SetStartChild(mockWidget1).Once()
	211	+	mockInnerPaned.EXPECT().SetEndChild(mockWidget2).Once()
	212	+	mockInnerPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	213	+
	214	+	// Outer split (horizontal) gets inner paned and pane3
	215	+	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockOuterPaned).Once()
	216	+	mockOuterPaned.EXPECT().SetResizeStartChild(true).Once()
	217	+	mockOuterPaned.EXPECT().SetResizeEndChild(true).Once()
	218	+	mockOuterPaned.EXPECT().SetShrinkStartChild(false).Once()
	219	+	mockOuterPaned.EXPECT().SetShrinkEndChild(false).Once()
	220	+	mockOuterPaned.EXPECT().SetStartChild(mockInnerPaned).Once()
	221	+	mockOuterPaned.EXPECT().SetEndChild(mockWidget3).Once()
	222	+	mockOuterPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	223	+
	224	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	225	+
	226	+	// Act
	227	+	widget, err := renderer.Build(outerSplit)
	228	+
	229	+	// Assert
	230	+	require.NoError(t, err)
	231	+	assert.NotNil(t, widget)
	232	+	assert.Equal(t, 5, renderer.NodeCount()) // 2 splits + 3 leaves
	233	+	}
	234	+
	235	+	// Note: TestBuild_StackedPanes is omitted because StackedView has complex internal
	236	+	// widget creation that makes mocking unwieldy. StackedView is thoroughly tested
	237	+	// in stacked_test.go. TreeRenderer's stacked rendering is verified implicitly
	238	+	// through integration tests.
	239	+
	240	+	func TestLookup_ExistingNode(t *testing.T) {
	241	+	// Arrange
	242	+	mockFactory := mocks.NewMockWidgetFactory(t)
	243	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	244	+	mockWidget := mocks.NewMockWidget(t)
	245	+
	246	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	247	+	node := &entity.PaneNode{ID: "test-node-id", Pane: pane}
	248	+
	249	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	250	+
	251	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	252	+	_, _ = renderer.Build(node)
	253	+
	254	+	// Act
	255	+	result := renderer.Lookup("test-node-id")
	256	+
	257	+	// Assert
	258	+	assert.Equal(t, mockWidget, result)
	259	+	}
	260	+
	261	+	func TestLookup_NonExistentNode(t *testing.T) {
	262	+	// Arrange
	263	+	mockFactory := mocks.NewMockWidgetFactory(t)
	264	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	265	+	mockWidget := mocks.NewMockWidget(t)
	266	+
	267	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	268	+	node := &entity.PaneNode{ID: "node-1", Pane: pane}
	269	+
	270	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	271	+
	272	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	273	+	_, _ = renderer.Build(node)
	274	+
	275	+	// Act
	276	+	result := renderer.Lookup("non-existent-id")
	277	+
	278	+	// Assert
	279	+	assert.Nil(t, result)
	280	+	}
	281	+
	282	+	func TestLookupNode_Existing(t *testing.T) {
	283	+	// Arrange
	284	+	mockFactory := mocks.NewMockWidgetFactory(t)
	285	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	286	+	mockWidget := mocks.NewMockWidget(t)
	287	+
	288	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	289	+	node := &entity.PaneNode{ID: "node-1", Pane: pane}
	290	+
	291	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	292	+
	293	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	294	+	_, _ = renderer.Build(node)
	295	+
	296	+	// Act
	297	+	widget, found := renderer.LookupNode("node-1")
	298	+
	299	+	// Assert
	300	+	assert.True(t, found)
	301	+	assert.Equal(t, mockWidget, widget)
	302	+	}
	303	+
	304	+	func TestLookupNode_NonExistent(t *testing.T) {
	305	+	// Arrange
	306	+	mockFactory := mocks.NewMockWidgetFactory(t)
	307	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	308	+
	309	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	310	+
	311	+	// Act
	312	+	widget, found := renderer.LookupNode("non-existent")
	313	+
	314	+	// Assert
	315	+	assert.False(t, found)
	316	+	assert.Nil(t, widget)
	317	+	}
	318	+
	319	+	func TestClear_RemovesAllMappings(t *testing.T) {
	320	+	// Arrange
	321	+	mockFactory := mocks.NewMockWidgetFactory(t)
	322	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	323	+	mockWidget := mocks.NewMockWidget(t)
	324	+
	325	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	326	+	node := &entity.PaneNode{ID: "node-1", Pane: pane}
	327	+
	328	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	329	+
	330	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	331	+	_, _ = renderer.Build(node)
	332	+
	333	+	require.Equal(t, 1, renderer.NodeCount())
	334	+
	335	+	// Act
	336	+	renderer.Clear()
	337	+
	338	+	// Assert
	339	+	assert.Equal(t, 0, renderer.NodeCount())
	340	+	assert.Nil(t, renderer.Lookup("node-1"))
	341	+	}
	342	+
	343	+	func TestGetNodeIDs_ReturnsAllIDs(t *testing.T) {
	344	+	// Arrange
	345	+	mockFactory := mocks.NewMockWidgetFactory(t)
	346	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	347	+	mockPaned := mocks.NewMockPanedWidget(t)
	348	+	mockWidget1 := mocks.NewMockWidget(t)
	349	+	mockWidget2 := mocks.NewMockWidget(t)
	350	+
	351	+	pane1 := entity.NewPane(entity.PaneID("pane-1"))
	352	+	pane2 := entity.NewPane(entity.PaneID("pane-2"))
	353	+
	354	+	node1 := &entity.PaneNode{ID: "left-node", Pane: pane1}
	355	+	node2 := &entity.PaneNode{ID: "right-node", Pane: pane2}
	356	+
	357	+	splitNode := &entity.PaneNode{
	358	+	ID: "split-node",
	359	+	SplitDir: entity.SplitHorizontal,
	360	+	SplitRatio: 0.5,
	361	+	Children: []*entity.PaneNode{node1, node2},
	362	+	}
	363	+
	364	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
	365	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	366	+
	367	+	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
	368	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	369	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	370	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	371	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	372	+	mockPaned.EXPECT().SetStartChild(mockWidget1).Once()
	373	+	mockPaned.EXPECT().SetEndChild(mockWidget2).Once()
	374	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	375	+
	376	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	377	+	_, _ = renderer.Build(splitNode)
	378	+
	379	+	// Act
	380	+	ids := renderer.GetNodeIDs()
	381	+
	382	+	// Assert
	383	+	assert.Len(t, ids, 3)
	384	+	assert.Contains(t, ids, "split-node")
	385	+	assert.Contains(t, ids, "left-node")
	386	+	assert.Contains(t, ids, "right-node")
	387	+	}
	388	+
	389	+	func TestBuild_ClearsPreviousMappings(t *testing.T) {
	390	+	// Arrange
	391	+	mockFactory := mocks.NewMockWidgetFactory(t)
	392	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	393	+	mockWidget1 := mocks.NewMockWidget(t)
	394	+	mockWidget2 := mocks.NewMockWidget(t)
	395	+
	396	+	pane1 := entity.NewPane(entity.PaneID("pane-1"))
	397	+	node1 := &entity.PaneNode{ID: "old-node", Pane: pane1}
	398	+
	399	+	pane2 := entity.NewPane(entity.PaneID("pane-2"))
	400	+	node2 := &entity.PaneNode{ID: "new-node", Pane: pane2}
	401	+
	402	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
	403	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	404	+
	405	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	406	+
	407	+	// First build
	408	+	_, _ = renderer.Build(node1)
	409	+	require.Equal(t, 1, renderer.NodeCount())
	410	+	require.NotNil(t, renderer.Lookup("old-node"))
	411	+
	412	+	// Act - second build should clear old mappings
	413	+	_, _ = renderer.Build(node2)
	414	+
	415	+	// Assert
	416	+	assert.Equal(t, 1, renderer.NodeCount())
	417	+	assert.Nil(t, renderer.Lookup("old-node"))
	418	+	assert.NotNil(t, renderer.Lookup("new-node"))
	419	+	}
	420	+
	421	+	func TestBuild_NilPaneViewFactory_ReturnsNilForLeaves(t *testing.T) {
	422	+	// Arrange
	423	+	mockFactory := mocks.NewMockWidgetFactory(t)
	424	+
	425	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	426	+	node := &entity.PaneNode{ID: "node-1", Pane: pane}
	427	+
	428	+	renderer := layout.NewTreeRenderer(mockFactory, nil)
	429	+
	430	+	// Act
	431	+	widget, err := renderer.Build(node)
	432	+
	433	+	// Assert
	434	+	require.NoError(t, err)
	435	+	assert.Nil(t, widget) // nil because paneViewFactory is nil
	436	+	}
	437	+
	438	+	func TestBuild_EmptyNodeID_NotStored(t *testing.T) {
	439	+	// Arrange
	440	+	mockFactory := mocks.NewMockWidgetFactory(t)
	441	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	442	+	mockWidget := mocks.NewMockWidget(t)
	443	+
	444	+	pane := entity.NewPane(entity.PaneID("pane-1"))
	445	+	node := &entity.PaneNode{ID: "", Pane: pane} // Empty ID
	446	+
	447	+	mockPaneViewFactory.EXPECT().CreatePaneView(node).Return(mockWidget).Once()
	448	+
	449	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	450	+
	451	+	// Act
	452	+	widget, err := renderer.Build(node)
	453	+
	454	+	// Assert
	455	+	require.NoError(t, err)
	456	+	assert.NotNil(t, widget)
	457	+	assert.Equal(t, 0, renderer.NodeCount()) // Empty ID nodes aren't stored
	458	+	}
	459	+
	460	+	func TestUpdateSplitRatio_ExistingNode(t *testing.T) {
	461	+	// Arrange
	462	+	mockFactory := mocks.NewMockWidgetFactory(t)
	463	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	464	+	mockPaned := mocks.NewMockPanedWidget(t)
	465	+	mockWidget1 := mocks.NewMockWidget(t)
	466	+	mockWidget2 := mocks.NewMockWidget(t)
	467	+
	468	+	pane1 := entity.NewPane(entity.PaneID("pane-1"))
	469	+	pane2 := entity.NewPane(entity.PaneID("pane-2"))
	470	+
	471	+	node1 := &entity.PaneNode{ID: "node-1", Pane: pane1}
	472	+	node2 := &entity.PaneNode{ID: "node-2", Pane: pane2}
	473	+
	474	+	splitNode := &entity.PaneNode{
	475	+	ID: "split-node",
	476	+	SplitDir: entity.SplitHorizontal,
	477	+	SplitRatio: 0.5,
	478	+	Children: []*entity.PaneNode{node1, node2},
	479	+	}
	480	+
	481	+	mockPaneViewFactory.EXPECT().CreatePaneView(node1).Return(mockWidget1).Once()
	482	+	mockPaneViewFactory.EXPECT().CreatePaneView(node2).Return(mockWidget2).Once()
	483	+
	484	+	mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()
	485	+	mockPaned.EXPECT().SetResizeStartChild(true).Once()
	486	+	mockPaned.EXPECT().SetResizeEndChild(true).Once()
	487	+	mockPaned.EXPECT().SetShrinkStartChild(false).Once()
	488	+	mockPaned.EXPECT().SetShrinkEndChild(false).Once()
	489	+	mockPaned.EXPECT().SetStartChild(mockWidget1).Once()
	490	+	mockPaned.EXPECT().SetEndChild(mockWidget2).Once()
	491	+	mockPaned.EXPECT().ConnectMap(mock.Anything).Return(uint32(0)).Once()
	492	+
	493	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	494	+	_, _ = renderer.Build(splitNode)
	495	+
	496	+	// Act
	497	+	err := renderer.UpdateSplitRatio("split-node", 0.7)
	498	+
	499	+	// Assert
	500	+	assert.NoError(t, err)
	501	+	}
	502	+
	503	+	func TestUpdateSplitRatio_NonExistentNode(t *testing.T) {
	504	+	// Arrange
	505	+	mockFactory := mocks.NewMockWidgetFactory(t)
	506	+	mockPaneViewFactory := mocks.NewMockPaneViewFactory(t)
	507	+
	508	+	renderer := layout.NewTreeRenderer(mockFactory, mockPaneViewFactory)
	509	+
	510	+	// Act
	511	+	err := renderer.UpdateSplitRatio("non-existent", 0.7)
	512	+
	513	+	// Assert
	514	+	assert.ErrorIs(t, err, layout.ErrNodeNotFound)
	515	+	}

A internal/ui/layout/widgets.go +204 -0

@@ -0,0 +1,204 @@
	1	+	// Package layout provides GTK widget abstractions and layout management for the pane system.
	2	+	// It defines interfaces that wrap GTK types, enabling unit testing without GTK runtime.
	3	+	package layout
	4	+
	5	+	import (
	6	+	"github.com/jwijenbergh/puregotk/v4/gtk"
	7	+	)
	8	+
	9	+	// Orientation represents the orientation for layout widgets.
	10	+	type Orientation = gtk.Orientation
	11	+
	12	+	// Orientation constants matching GTK values.
	13	+	const (
	14	+	OrientationHorizontal = gtk.OrientationHorizontalValue
	15	+	OrientationVertical = gtk.OrientationVerticalValue
	16	+	)
	17	+
	18	+	// Widget is the base interface that all GTK widgets implement.
	19	+	// It provides common widget operations needed for layout management.
	20	+	type Widget interface {
	21	+	// Visibility
	22	+	Show()
	23	+	Hide()
	24	+	SetVisible(visible bool)
	25	+	IsVisible() bool
	26	+
	27	+	// Focus
	28	+	GrabFocus() bool
	29	+	HasFocus() bool
	30	+	SetCanFocus(canFocus bool)
	31	+	SetFocusOnClick(focusOnClick bool)
	32	+
	33	+	// Layout
	34	+	SetHexpand(expand bool)
	35	+	SetVexpand(expand bool)
	36	+	GetHexpand() bool
	37	+	GetVexpand() bool
	38	+	SetHalign(align gtk.Align)
	39	+	SetValign(align gtk.Align)
	40	+	SetSizeRequest(width, height int)
	41	+
	42	+	// CSS styling
	43	+	AddCssClass(cssClass string)
	44	+	RemoveCssClass(cssClass string)
	45	+	HasCssClass(cssClass string) bool
	46	+
	47	+	// Parent management
	48	+	Unparent()
	49	+	GetParent() Widget
	50	+
	51	+	// GTK interop - returns the underlying GTK widget for embedding
	52	+	GtkWidget() *gtk.Widget
	53	+	}
	54	+
	55	+	// PanedWidget wraps gtk.Paned for creating split views.
	56	+	// It manages two child widgets separated by a draggable divider.
	57	+	type PanedWidget interface {
	58	+	Widget
	59	+
	60	+	// Child management
	61	+	SetStartChild(child Widget)
	62	+	SetEndChild(child Widget)
	63	+	GetStartChild() Widget
	64	+	GetEndChild() Widget
	65	+
	66	+	// Divider position
	67	+	SetPosition(position int)
	68	+	GetPosition() int
	69	+
	70	+	// Resize behavior
	71	+	SetResizeStartChild(resize bool)
	72	+	SetResizeEndChild(resize bool)
	73	+	GetResizeStartChild() bool
	74	+	GetResizeEndChild() bool
	75	+
	76	+	// Shrink behavior (whether child can be smaller than its minimum size)
	77	+	SetShrinkStartChild(shrink bool)
	78	+	SetShrinkEndChild(shrink bool)
	79	+	GetShrinkStartChild() bool
	80	+	GetShrinkEndChild() bool
	81	+
	82	+	// Signals
	83	+	ConnectMap(callback func()) uint32
	84	+
	85	+	// Size information (for ratio calculation)
	86	+	GetAllocatedWidth() int
	87	+	GetAllocatedHeight() int
	88	+
	89	+	// Handle appearance
	90	+	SetWideHandle(wide bool)
	91	+	GetWideHandle() bool
	92	+	}
	93	+
	94	+	// BoxWidget wraps gtk.Box for linear layouts.
	95	+	// It arranges children in a single row or column.
	96	+	type BoxWidget interface {
	97	+	Widget
	98	+
	99	+	// Child management
	100	+	Append(child Widget)
	101	+	Prepend(child Widget)
	102	+	Remove(child Widget)
	103	+	InsertChildAfter(child Widget, sibling Widget)
	104	+	ReorderChildAfter(child Widget, sibling Widget)
	105	+
	106	+	// Configuration
	107	+	SetHomogeneous(homogeneous bool)
	108	+	GetHomogeneous() bool
	109	+	SetSpacing(spacing int)
	110	+	GetSpacing() int
	111	+	SetOrientation(orientation Orientation)
	112	+	GetOrientation() Orientation
	113	+	}
	114	+
	115	+	// OverlayWidget wraps gtk.Overlay for layered content.
	116	+	// It displays overlay widgets on top of a main child widget.
	117	+	type OverlayWidget interface {
	118	+	Widget
	119	+
	120	+	// Main child
	121	+	SetChild(child Widget)
	122	+	GetChild() Widget
	123	+
	124	+	// Overlay management
	125	+	AddOverlay(overlay Widget)
	126	+	RemoveOverlay(overlay Widget)
	127	+
	128	+	// Overlay configuration
	129	+	SetClipOverlay(overlay Widget, clip bool)
	130	+	GetClipOverlay(overlay Widget) bool
	131	+	SetMeasureOverlay(overlay Widget, measure bool)
	132	+	GetMeasureOverlay(overlay Widget) bool
	133	+	}
	134	+
	135	+	// EllipsizeMode represents pango ellipsize modes.
	136	+	type EllipsizeMode = int
	137	+
	138	+	// Ellipsize mode constants.
	139	+	const (
	140	+	EllipsizeNone EllipsizeMode = 0
	141	+	EllipsizeStart EllipsizeMode = 1
	142	+	EllipsizeMiddle EllipsizeMode = 2
	143	+	EllipsizeEnd EllipsizeMode = 3
	144	+	)
	145	+
	146	+	// LabelWidget wraps gtk.Label for text display.
	147	+	type LabelWidget interface {
	148	+	Widget
	149	+
	150	+	SetText(text string)
	151	+	GetText() string
	152	+	SetMarkup(markup string)
	153	+	SetEllipsize(mode EllipsizeMode)
	154	+	SetMaxWidthChars(nChars int)
	155	+	SetXalign(xalign float32)
	156	+	}
	157	+
	158	+	// ButtonWidget wraps gtk.Button for clickable elements.
	159	+	type ButtonWidget interface {
	160	+	Widget
	161	+
	162	+	SetLabel(label string)
	163	+	GetLabel() string
	164	+	SetChild(child Widget)
	165	+	GetChild() Widget
	166	+
	167	+	// Connect click handler, returns signal ID for disconnection
	168	+	ConnectClicked(callback func()) uint32
	169	+	}
	170	+
	171	+	// ImageWidget wraps gtk.Image for displaying images.
	172	+	type ImageWidget interface {
	173	+	Widget
	174	+
	175	+	SetFromIconName(iconName string)
	176	+	SetFromFile(filename string)
	177	+	SetPixelSize(pixelSize int)
	178	+	Clear()
	179	+	}
	180	+
	181	+	// WidgetFactory creates widget instances.
	182	+	// This abstraction allows tests to inject mock factories.
	183	+	type WidgetFactory interface {
	184	+	// Container widgets
	185	+	NewPaned(orientation Orientation) PanedWidget
	186	+	NewBox(orientation Orientation, spacing int) BoxWidget
	187	+	NewOverlay() OverlayWidget
	188	+
	189	+	// Display widgets
	190	+	NewLabel(text string) LabelWidget
	191	+	NewButton() ButtonWidget
	192	+	NewImage() ImageWidget
	193	+
	194	+	// Wrap existing GTK widget
	195	+	WrapWidget(w *gtk.Widget) Widget
	196	+	}
	197	+
	198	+	// PaneRenderer creates pane view widgets from domain entities.
	199	+	// This decouples the tree renderer from concrete PaneView implementation.
	200	+	type PaneRenderer interface {
	201	+	// RenderPane creates a widget for a pane node.
	202	+	// The webViewWidget is the GTK widget from the WebView.
	203	+	RenderPane(paneID string, webViewWidget Widget) Widget
	204	+	}